Merge pull request #41 from tcdent/claude/library-refactor-6QbUF

Add library support for using codey as a Rust dependency

Author: tcdent

Cargo.toml

@@ -7,6 +7,14 @@ description = "A terminal-based AI coding assistant"
 license = "MIT"
 repository = "https://github.com/tcdent/codey"
 
+[lib]
+name = "codey"
+path = "src/lib.rs"
+
+[[bin]]
+name = "codey"
+path = "src/main.rs"
+
 [dependencies]
 # TUI
 ratatui = { version = "0.30.0-beta.0", features = ["scrolling-regions"] }

LIBRARY.md

@@ -0,0 +1,266 @@
+# Using Codey as a Library
+
+Codey can be used as a library to create AI agents with custom system prompts and tools in your Rust projects.
+
+## Installation
+
+Add codey to your `Cargo.toml`:
+
+```toml
+[dependencies]
+codey = { git = "https://github.com/tcdent/codey" }
+tokio = { version = "1", features = ["full"] }
+serde_json = "1"
+```
+
+### Patched Dependencies
+
+Codey uses a patched version of the `genai` crate. To use Codey as a library, you'll need to apply the same patch in your project's `Cargo.toml`:
+
+```toml
+[patch.crates-io]
+genai = { git = "https://github.com/tcdent/codey", branch = "main" }
+```
+
+Alternatively, clone the codey repository and reference the patched genai locally:
+
+```toml
+[patch.crates-io]
+genai = { path = "../codey/lib/genai" }
+```
+
+Note: Run `make patch` in the codey repository first to download and patch the dependencies.
+
+## Basic Usage (No Tools)
+
+```rust
+use codey::{Agent, AgentRuntimeConfig, AgentStep, RequestMode, ToolRegistry};
+
+#[tokio::main]
+async fn main() {
+    let mut agent = Agent::new(
+        AgentRuntimeConfig::default(),
+        "You are a helpful assistant.",
+        None, // uses ANTHROPIC_API_KEY env var
+        ToolRegistry::empty(),
+    );
+
+    agent.send_request("What is the capital of France?", RequestMode::Normal);
+
+    while let Some(step) = agent.next().await {
+        match step {
+            AgentStep::TextDelta(text) => print!("{}", text),
+            AgentStep::Finished { .. } => break,
+            AgentStep::Error(e) => {
+                eprintln!("Error: {}", e);
+                break;
+            }
+            _ => {}
+        }
+    }
+}
+```
+
+## Custom Tools
+
+You can define custom tools using `SimpleTool` and handle their execution yourself.
+
+### Defining Tools
+
+```rust
+use codey::{SimpleTool, ToolRegistry};
+use serde_json::json;
+use std::sync::Arc;
+
+// Define a tool
+let weather_tool = SimpleTool::new(
+    "get_weather",
+    "Get the current weather for a location",
+    json!({
+        "type": "object",
+        "properties": {
+            "location": {
+                "type": "string",
+                "description": "City name, e.g. 'San Francisco'"
+            }
+        },
+        "required": ["location"]
+    }),
+);
+
+// Register tools
+let mut tools = ToolRegistry::empty();
+tools.register(Arc::new(weather_tool));
+```
+
+### Handling Tool Calls
+
+When the LLM wants to use a tool, you'll receive an `AgentStep::ToolRequest`. You must execute the tool and submit the result back to the agent:
+
+```rust
+use codey::{Agent, AgentRuntimeConfig, AgentStep, RequestMode, SimpleTool, ToolCall, ToolRegistry};
+use serde_json::json;
+use std::sync::Arc;
+
+#[tokio::main]
+async fn main() {
+    // Set up tools
+    let weather_tool = SimpleTool::new(
+        "get_weather",
+        "Get the current weather for a location",
+        json!({
+            "type": "object",
+            "properties": {
+                "location": { "type": "string" }
+            },
+            "required": ["location"]
+        }),
+    );
+
+    let mut tools = ToolRegistry::empty();
+    tools.register(Arc::new(weather_tool));
+
+    // Create agent with tools
+    let mut agent = Agent::new(
+        AgentRuntimeConfig::default(),
+        "You are a helpful assistant with access to weather data.",
+        None,
+        tools,
+    );
+
+    agent.send_request("What's the weather in Paris?", RequestMode::Normal);
+
+    loop {
+        match agent.next().await {
+            Some(AgentStep::TextDelta(text)) => print!("{}", text),
+
+            Some(AgentStep::ToolRequest(calls)) => {
+                // Handle each tool call
+                for call in calls {
+                    let result = execute_tool(&call);
+                    agent.submit_tool_result(&call.call_id, result);
+                }
+                // Continue processing after submitting results
+            }
+
+            Some(AgentStep::Finished { .. }) => {
+                println!();
+                break;
+            }
+
+            Some(AgentStep::Error(e)) => {
+                eprintln!("Error: {}", e);
+                break;
+            }
+
+            None => break,
+            _ => {}
+        }
+    }
+}
+
+fn execute_tool(call: &ToolCall) -> String {
+    match call.name.as_str() {
+        "get_weather" => {
+            let location = call.params["location"].as_str().unwrap_or("unknown");
+            // Your actual implementation here
+            format!("Weather in {}: Sunny, 22°C", location)
+        }
+        _ => format!("Unknown tool: {}", call.name),
+    }
+}
+```
+
+### `ToolCall` Structure
+
+When you receive a tool request, each `ToolCall` contains:
+
+```rust
+pub struct ToolCall {
+    pub call_id: String,           // Unique ID for this call (use with submit_tool_result)
+    pub name: String,              // Tool name
+    pub params: serde_json::Value, // Parameters from the LLM
+    // ... other fields
+}
+```
+
+## Public API Reference
+
+### `Agent`
+
+The main agent type for conversations with Claude.
+
+```rust
+let mut agent = Agent::new(config, system_prompt, oauth, tools);
+agent.send_request("Hello!", RequestMode::Normal);
+while let Some(step) = agent.next().await { /* ... */ }
+agent.submit_tool_result(&call_id, result);
+```
+
+### `AgentRuntimeConfig`
+
+```rust
+let config = AgentRuntimeConfig {
+    model: "claude-sonnet-4-20250514".to_string(),
+    max_tokens: 8192,
+    thinking_budget: 2_000,
+    max_retries: 5,
+    compaction_thinking_budget: 8_000,
+};
+
+// Or use defaults
+let config = AgentRuntimeConfig::default();
+```
+
+### `AgentStep`
+
+Events emitted during processing:
+
+- `TextDelta(String)` - Streaming text output
+- `ThinkingDelta(String)` - Extended thinking output
+- `ToolRequest(Vec<ToolCall>)` - LLM wants to use tools
+- `Finished { usage: Usage }` - Processing complete
+- `Error(String)` - Error occurred
+- `Retrying { attempt, error }` - Retrying after error
+
+### `SimpleTool`
+
+Define a tool for the LLM to use:
+
+```rust
+let tool = SimpleTool::new(
+    "tool_name",           // Name the LLM will use
+    "Description of tool", // Help the LLM understand when to use it
+    json!({ /* JSON Schema for parameters */ }),
+);
+```
+
+### `ToolRegistry`
+
+Manage available tools:
+
+```rust
+let mut tools = ToolRegistry::empty();
+tools.register(Arc::new(my_tool));
+```
+
+### `Usage`
+
+Token usage statistics:
+
+```rust
+pub struct Usage {
+    pub output_tokens: u32,
+    pub context_tokens: u32,
+    pub cache_creation_tokens: u32,
+    pub cache_read_tokens: u32,
+}
+```
+
+## Authentication
+
+Set the `ANTHROPIC_API_KEY` environment variable:
+
+```bash
+export ANTHROPIC_API_KEY=sk-ant-...
+```

src/app.rs

@@ -17,11 +17,12 @@ use ratatui::{
 use tokio::sync::oneshot;
 
 use crate::commands::Command;
-use crate::config::{AgentRuntimeConfig, Config};
+use crate::config::{AgentRuntimeConfig, Config, CODEY_DIR};
 use crate::ide::{Ide, IdeEvent, Nvim};
 use crate::llm::{Agent, AgentId, AgentRegistry, AgentStep, RequestMode};
 #[cfg(feature = "profiling")]
 use crate::{profile_frame, profile_span};
+use crate::prompts::{COMPACTION_PROMPT, SYSTEM_MD_FILENAME, SYSTEM_PROMPT, WELCOME_MESSAGE};
 use crate::tool_filter::ToolFilters;
 use crate::tools::{
     init_agent_context, update_agent_oauth, Effect, ToolCall, ToolDecision, ToolEvent,
@@ -34,88 +35,6 @@ const MIN_FRAME_TIME: Duration = Duration::from_millis(16);
 
 pub const APP_NAME: &str = "Codey";
 pub const APP_VERSION: &str = env!("CARGO_PKG_VERSION");
-pub const CODEY_DIR: &str = ".codey";
-pub const TRANSCRIPTS_DIR: &str = "transcripts";
-
-const WELCOME_MESSAGE: &str =
-    "Welcome to Codey! I'm your AI coding assistant. How can I help you today?";
-const SYSTEM_PROMPT: &str = r#"You are Codey, an AI coding assistant running in a terminal interface.
-
-## Capabilities
-You have access to the following tools:
-- `read_file`: Read file contents, optionally with line ranges
-- `write_file`: Create new files
-- `edit_file`: Make precise edits using search/replace
-- `shell`: Execute bash commands
-- `fetch_url`: Fetch web content
-
-## Guidelines
-
-### Reading Files
-- Always read a file before editing it
-- Use line ranges for large files: `read_file(path, start_line=100, end_line=200)`
-- Use `shell("ls -la")` to explore directories
-- When reading files, be careful about reading large files in one-go. Use line ranges, 
-    or check the file stats with `shell("stat <file_path>")` first.
-- shell grep is a great way to get a line number to read a targeted section of a file
-
-### Editing Files
-- Use `edit_file` for existing files, `write_file` only for new files
-- The `old_string` must match EXACTLY, including whitespace and indentation
-- If `old_string` appears multiple times, include more context to make it unique
-- Apply edits sequentially; each edit sees the result of previous edits
-- You can do multiple edits at once, but keep it under 1000 lines
-- Avoid the urge to completely rewrite files - make precise, minimal edits so the user can review them easily
-
-### Shell Commands
-- Prefer `read_file` over `cat`, `head`, `tail`
-- Use `ls` for directory exploration
-- Use `grep` or `rg` for searching code
-
-### Background Execution
-For long-running operations, you can execute tools in the background by adding `"background": true` to the tool call. This returns immediately with a task ID while the tool runs asynchronously.
-Use `list_background_tasks` to check status and `get_background_task` to retrieve results when complete.
-
-### General
-- Be concise but thorough
-- Explain what you're doing before executing tools
-- If a tool fails, explain the error and suggest fixes
-- Ask for clarification if the request is ambiguous
-- If you feel like backing out of a path, always get confirmation before git resetting the work tree
-- Always get confirmation before making destructive changes (this includes building a release)
-"#;
-const COMPACTION_PROMPT: &str = r#"The conversation context is getting large and needs to be compacted.
-
-Please provide a comprehensive summary of our conversation so far in markdown format. Include:
-
-1. **What was accomplished** - Main tasks and changes completed as a bulleted list
-2. **What still needs to be done** - Remaining tasks or open areas of work as a bulleted list
-3. **Key project information** - Important facts about the project that the user has shared or that we're not immediately apparent
-4. **Relevant files** - Files most relevant to the current work with brief descriptions, line numbers, or method/variable names
-5. **Relevant documentation paths or URLs** - Links to docs or resources we will use to continue our work
-6. **Quotes and log snippets** - Any important quotes or logs that the user provided that we'll need later
-
-Be thorough but concise - this summary will seed a fresh conversation context."#;
-
-pub const SUB_AGENT_PROMPT: &str = r#"You are a background research agent. Your task is to investigate, explore, or analyze as directed.
-
-## Capabilities
-You have read-only access to:
-- `read_file`: Read file contents
-- `shell`: Execute commands (for searching, exploring)
-- `fetch_url`: Fetch web content
-- `web_search`: Search the web
-- `open_file`: Signal a file to open in the IDE
-
-## Guidelines
-- Focus on the specific task assigned to you
-- Be thorough but concise in your findings
-- Report back with structured, actionable information
-- You cannot modify files - only read and explore
-- If you need to suggest changes, describe them clearly for the primary agent to implement
-"#;
-
-const SYSTEM_MD_FILENAME: &str = "SYSTEM.md";
 
 /// Build the complete system prompt by appending content from SYSTEM.md files.
 /// Checks (in order):