eddacraft-kindling 0.3.0

Local-first memory and continuity CLI for AI-assisted development (the `kindling` binary).
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! `search <query>` — deterministic retrieval.
//!
//! Ports `packages/kindling-cli/src/commands/search.ts`. `--via-daemon` routes
//! through the daemon client. The `--json` output is the full `RetrieveResult`
//! (already camelCase via its `Serialize`).

use kindling_types::{RetrieveOptions, RetrievedEntity};

use crate::cli::SearchArgs;
use crate::commands::scope_from;
use crate::output::{format_json, format_timestamp, truncate};
use crate::{build_client, open_service, runtime, CliResult};

pub fn run(args: SearchArgs, via_daemon: bool) -> CliResult {
    let scope = scope_from(args.session.as_deref(), args.repo.as_deref());
    let options = RetrieveOptions {
        query: args.query.clone(),
        scope_ids: scope,
        token_budget: None,
        max_candidates: Some(args.max),
        include_redacted: None,
    };

    let result = if via_daemon {
        let client = build_client()?;
        runtime()?.block_on(async { client.retrieve(options).await })?
    } else {
        let (service, _db) = open_service(args.common.db.as_deref())?;
        service.retrieve(options)?
    };

    if args.common.json {
        println!("{}", format_json(&result, true)?);
    } else {
        println!("\nSearch Results for: \"{}\"", args.query);
        println!("{}\n", "=".repeat(50));

        if !result.pins.is_empty() {
            println!("Pins ({}):", result.pins.len());
            for (i, pin) in result.pins.iter().enumerate() {
                let (id, type_label, content) = entity_fields(&pin.target);
                println!("\n{}. [PIN] {id}", i + 1);
                println!("   Type: {type_label}");
                println!("   Content: {}", truncate(content, 100));
                if let Some(reason) = &pin.pin.reason {
                    println!("   Note: {reason}");
                }
            }
            println!();
        }

        if let Some(summary) = &result.current_summary {
            println!("Current Summary:");
            println!("  {}", truncate(&summary.content, 200));
            println!("  Confidence: {}", summary.confidence);
            println!();
        }

        if !result.candidates.is_empty() {
            println!("Candidates ({}):", result.candidates.len());
            for (i, candidate) in result.candidates.iter().enumerate() {
                let (id, type_label, content) = entity_fields(&candidate.entity);
                println!("\n{}. {id} (score: {:.2})", i + 1, candidate.score);
                println!("   Type: {type_label}");
                println!("   Content: {}", truncate(content, 100));
                if let RetrievedEntity::Observation(obs) = &candidate.entity {
                    println!("   Time: {}", format_timestamp(obs.ts));
                }
            }
        } else if result.pins.is_empty() && result.current_summary.is_none() {
            println!("No results found.");
        }

        println!();
    }
    Ok(())
}

/// `(id, "type label", content)` for an observation or summary. The type label
/// mirrors the TS `'kind' in entity ? entity.kind : 'summary'`.
fn entity_fields(entity: &RetrievedEntity) -> (&str, String, &str) {
    match entity {
        RetrievedEntity::Observation(obs) => {
            (obs.id.as_str(), kind_label(obs.kind), obs.content.as_str())
        }
        RetrievedEntity::Summary(summary) => (
            summary.id.as_str(),
            "summary".to_string(),
            summary.content.as_str(),
        ),
    }
}

fn kind_label(kind: kindling_types::ObservationKind) -> String {
    use kindling_types::ObservationKind::*;
    match kind {
        ToolCall => "tool_call",
        Command => "command",
        FileDiff => "file_diff",
        Error => "error",
        Message => "message",
        NodeStart => "node_start",
        NodeEnd => "node_end",
        NodeOutput => "node_output",
        NodeError => "node_error",
    }
    .to_string()
}