gid-core 0.3.2

Graph-Indexed Development core library — graph-based project management and code analysis for AI agents
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

//! Built-in [`SimpleLlm`] implementations for gid-core.
//!
//! Feature-gated behind `cli-llm`. Provides [`CliLlm`] which shells out
//! to the `claude` CLI for LLM completions.
//!
//! # Why `cli-llm` exists
//!
//! The `SimpleLlm` trait is intentionally minimal — a single `complete(prompt) → String`.
//! Consumers with their own LLM infrastructure (e.g. RustClaw with its Anthropic client,
//! GidHub with a shared LLM pool) implement the trait directly. `CliLlm` is the built-in
//! "batteries included" implementation for everyone else: gid-cli, gid-mcp, quick prototypes.
//!
//! # Adding new backends
//!
//! Future backends (e.g. `AnthropicLlm` with raw HTTP, `OllamaLlm` for local models)
//! can be added here behind their own feature gates.

use anyhow::{bail, Context, Result};

use super::labeling::SimpleLlm;

/// [`SimpleLlm`] implementation that calls the `claude` CLI.
///
/// Suitable for local development and lightweight deployment.
/// Requires the `claude` CLI to be installed and authenticated.
///
/// ```no_run
/// # use gid_core::infer::CliLlm;
/// let llm = CliLlm::new("haiku");
/// // Pass to infer pipeline:
/// // infer::run(&graph, &config, Some(&llm)).await?;
/// ```
///
/// # Model names
///
/// The `model` parameter is passed directly to `claude --model`. Common values:
/// - `"haiku"` — fast and cheap, good for labeling
/// - `"sonnet"` — balanced
/// - `"opus"` — highest quality
pub struct CliLlm {
    model: String,
}

impl CliLlm {
    /// Create a new `CliLlm` targeting the given model.
    pub fn new(model: impl Into<String>) -> Self {
        Self {
            model: model.into(),
        }
    }

    /// Returns the configured model name.
    pub fn model(&self) -> &str {
        &self.model
    }
}

#[async_trait::async_trait]
impl SimpleLlm for CliLlm {
    async fn complete(&self, prompt: &str) -> Result<String> {
        tracing::debug!(
            model = %self.model,
            prompt_len = prompt.len(),
            "CliLlm: calling claude CLI"
        );

        let output = tokio::process::Command::new("claude")
            .arg("-p")
            .arg(prompt)
            .arg("--model")
            .arg(&self.model)
            .output()
            .await
            .context(
                "Failed to run `claude` CLI. Is it installed? \
                 Run: npm install -g @anthropic-ai/claude-code",
            )?;

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);
            bail!("claude CLI failed (exit {}): {}", output.status, stderr);
        }

        let response = String::from_utf8_lossy(&output.stdout).to_string();
        tracing::debug!(response_len = response.len(), "CliLlm: got response");
        Ok(response)
    }
}