forge-pilot 0.1.0

Closed-loop orchestrator over runtime advisories, kernel oracles, and canonical Forge export/import lanes
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

#[path = "repo_chat/answer.rs"]
mod answer;
#[path = "repo_chat/provider.rs"]
mod provider;
#[path = "repo_chat/retrieval.rs"]
mod retrieval;
#[path = "repo_chat/routing.rs"]
mod routing;
#[path = "repo_chat/types.rs"]
mod types;

use crate::config::LoopConfig;
use crate::observe::{observe_scope, Observation};
use crate::PilotError;
use knowledge_runtime::KnowledgeRuntime;
use semantic_memory::{MemoryStore, ProjectionQuery};

pub use provider::{
    provider_fallback_allowed, render_terminal_answer, repo_chat_provider_grounding_message,
};
pub use routing::route_question;
pub use types::{
    RepoChatAnswer, RepoChatCitation, RepoChatEvidence, RepoChatEvidenceType,
    RepoChatGroundingMode, RepoQuestionRoute,
};

pub async fn answer_repo_question(
    runtime: &KnowledgeRuntime,
    store: &MemoryStore,
    config: &LoopConfig,
    question: &str,
) -> Result<RepoChatAnswer, PilotError> {
    let observation = observe_scope(runtime, store, config).await?;
    answer_repo_question_from_observation(store, &observation, config, question).await
}

pub async fn answer_repo_question_from_observation(
    store: &MemoryStore,
    observation: &Observation,
    config: &LoopConfig,
    question: &str,
) -> Result<RepoChatAnswer, PilotError> {
    let route = routing::route_question(question);
    if route == RepoQuestionRoute::GeneralNonRepo {
        return Ok(answer::general_non_repo_answer(question));
    }

    if observation
        .source_inventory
        .imported_current_state
        .file_count
        == 0
    {
        return Ok(answer::missing_import_answer(route));
    }

    let Some(manifest) = retrieval::current_manifest_from_observation(observation) else {
        return Ok(answer::missing_manifest_answer(
            route,
            &observation.source_inventory.imported_current_state,
        ));
    };

    let mut query = ProjectionQuery::new(config.scope.key());
    query.limit = config.observation_projection_limit;
    let claim_versions = store.query_claim_versions(query).await?;
    let retrieval =
        retrieval::retrieve_repo_evidence(observation, &manifest, &claim_versions, question);
    Ok(answer::assemble_answer(
        observation,
        &manifest,
        question,
        retrieval,
    ))
}