init

Signed-off-by: eric-epsilla <[email protected]>

Author: eric-epsilla

Cargo.toml

@@ -0,0 +1,35 @@
+[package]
+name = "claude-code-sdk"
+version = "0.0.1"
+edition = "2021"
+description = "Rust SDK for Claude Code"
+readme = "README.md"
+license = "MIT"
+authors = ["eric <[email protected]>"]
+keywords = ["claude", "ai", "sdk", "anthropic"]
+categories = ["api-bindings", "development-tools"]
+repository = "https://github.com/epsilla-cloud/claude-code-sdk-rust"
+homepage = "https://github.com/epsilla-cloud/claude-code-sdk-rust"
+documentation = "https://docs.anthropic.com/en/docs/claude-code/sdk"
+
+[dependencies]
+tokio = { version = "1.0", features = ["full"] }
+tokio-stream = { version = "0.1", features = ["io-util"] }
+futures = "0.3"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+thiserror = "1.0"
+which = "6.0"
+home = "0.5"
+async-trait = "0.1"
+
+[dev-dependencies]
+tokio-test = "0.4"
+
+[lib]
+name = "claude_code_sdk"
+path = "src/lib.rs"
+
+[[example]]
+name = "quick_start"
+path = "examples/quick_start.rs" 

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Epsilla
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

README.md

@@ -0,0 +1,156 @@
+# Claude Code SDK for Rust
+
+Rust SDK for Claude Code. See the [Claude Code SDK documentation](https://docs.anthropic.com/en/docs/claude-code/sdk) for more information.
+
+## Installation
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+claude-code-sdk = "0.0.10"
+tokio = { version = "1.0", features = ["full"] }
+```
+
+**Prerequisites:**
+- Rust 1.70+
+- Node.js 
+- Claude Code: `npm install -g @anthropic-ai/claude-code`
+
+## Quick Start
+
+```rust
+use claude_code_sdk::query;
+use tokio_stream::StreamExt;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut stream = query("What is 2 + 2?", None).await?;
+    
+    while let Some(message) = stream.next().await {
+        println!("{:?}", message);
+    }
+    
+    Ok(())
+}
+```
+
+## Usage
+
+### Basic Query
+
+```rust
+use claude_code_sdk::{query, ClaudeCodeOptions, Message};
+use tokio_stream::StreamExt;
+
+// Simple query
+let mut stream = query("Hello Claude", None).await?;
+while let Some(message) = stream.next().await {
+    match message {
+        Message::Assistant(msg) => {
+            for block in &msg.content {
+                if let ContentBlock::Text(text_block) = block {
+                    println!("Claude: {}", text_block.text);
+                }
+            }
+        }
+        _ => {}
+    }
+}
+
+// With options
+let options = ClaudeCodeOptions {
+    system_prompt: Some("You are a helpful assistant".to_string()),
+    max_turns: Some(1),
+    ..Default::default()
+};
+
+let mut stream = query("Tell me a joke", Some(options)).await?;
+while let Some(message) = stream.next().await {
+    println!("{:?}", message);
+}
+```
+
+### Using Tools
+
+```rust
+let options = ClaudeCodeOptions {
+    allowed_tools: vec!["Read".to_string(), "Write".to_string()],
+    permission_mode: Some(PermissionMode::AcceptEdits),
+    ..Default::default()
+};
+
+let mut stream = query("Create a hello.rs file", Some(options)).await?;
+while let Some(message) = stream.next().await {
+    // Process tool use and results
+}
+```
+
+### Working Directory
+
+```rust
+use std::path::PathBuf;
+
+let options = ClaudeCodeOptions {
+    cwd: Some(PathBuf::from("/path/to/project")),
+    ..Default::default()
+};
+```
+
+## API Reference
+
+### `query(prompt: &str, options: Option<ClaudeCodeOptions>)`
+
+Main async function for querying Claude.
+
+**Parameters:**
+- `prompt`: The prompt to send to Claude
+- `options`: Optional configuration
+
+**Returns:** `Result<Pin<Box<dyn Stream<Item = Message>>>, ClaudeSDKError>`
+
+### Types
+
+See [src/types.rs](src/types.rs) for complete type definitions:
+- `ClaudeCodeOptions` - Configuration options
+- `Message` variants - `Assistant`, `User`, `System`, `Result`
+- `ContentBlock` variants - `Text`, `ToolUse`, `ToolResult`
+
+## Error Handling
+
+```rust
+use claude_code_sdk::{
+    ClaudeSDKError,      // Base error
+    CLINotFoundError,    // Claude Code not installed
+    CLIConnectionError,  // Connection issues
+    ProcessError,        // Process failed
+    CLIJSONDecodeError,  // JSON parsing issues
+};
+
+match query("Hello", None).await {
+    Ok(mut stream) => {
+        // Process messages
+    }
+    Err(ClaudeSDKError::CLINotFound(e)) => {
+        println!("Please install Claude Code: {}", e);
+    }
+    Err(ClaudeSDKError::Process(e)) => {
+        println!("Process failed with exit code: {:?}", e.exit_code);
+    }
+    Err(e) => {
+        println!("Error: {}", e);
+    }
+}
+```
+
+## Available Tools
+
+See the [Claude Code documentation](https://docs.anthropic.com/en/docs/claude-code/security#tools-available-to-claude) for a complete list of available tools.
+
+## Examples
+
+See [examples/quick_start.rs](examples/quick_start.rs) for a complete working example.
+
+## License
+
+MIT 

examples/quick_start.rs

@@ -0,0 +1,99 @@
+//! Quick start example for Claude Code SDK.
+
+use claude_code_sdk::{
+    query, AssistantMessage, ClaudeCodeOptions, ContentBlock, Message, PermissionMode,
+    ResultMessage, TextBlock,
+};
+use tokio_stream::StreamExt;
+
+/// Basic example - simple question
+async fn basic_example() -> Result<(), Box<dyn std::error::Error>> {
+    println!("=== Basic Example ===");
+
+    let mut stream = query("What is 2 + 2?", None).await?;
+
+    while let Some(message) = stream.next().await {
+        if let Message::Assistant(AssistantMessage { content }) = message {
+            for block in content {
+                if let ContentBlock::Text(TextBlock { text }) = block {
+                    println!("Claude: {}", text);
+                }
+            }
+        }
+    }
+    println!();
+    Ok(())
+}
+
+/// Example with custom options
+async fn with_options_example() -> Result<(), Box<dyn std::error::Error>> {
+    println!("=== With Options Example ===");
+
+    let options = ClaudeCodeOptions {
+        system_prompt: Some("You are a helpful assistant that explains things simply.".to_string()),
+        max_turns: Some(1),
+        ..Default::default()
+    };
+
+    let mut stream = query("Explain what Rust is in one sentence.", Some(options)).await?;
+
+    while let Some(message) = stream.next().await {
+        if let Message::Assistant(AssistantMessage { content }) = message {
+            for block in content {
+                if let ContentBlock::Text(TextBlock { text }) = block {
+                    println!("Claude: {}", text);
+                }
+            }
+        }
+    }
+    println!();
+    Ok(())
+}
+
+/// Example using tools
+async fn with_tools_example() -> Result<(), Box<dyn std::error::Error>> {
+    println!("=== With Tools Example ===");
+
+    let options = ClaudeCodeOptions {
+        allowed_tools: vec!["Read".to_string(), "Write".to_string()],
+        system_prompt: Some("You are a helpful file assistant.".to_string()),
+        permission_mode: Some(PermissionMode::AcceptEdits),
+        ..Default::default()
+    };
+
+    let mut stream = query(
+        "Create a file called hello.txt with 'Hello, World!' in it",
+        Some(options),
+    )
+    .await?;
+
+    while let Some(message) = stream.next().await {
+        match message {
+            Message::Assistant(AssistantMessage { content }) => {
+                for block in content {
+                    if let ContentBlock::Text(TextBlock { text }) = block {
+                        println!("Claude: {}", text);
+                    }
+                }
+            }
+            Message::Result(ResultMessage {
+                total_cost_usd: Some(cost),
+                ..
+            }) if cost > 0.0 => {
+                println!("\nCost: ${:.4}", cost);
+            }
+            _ => {}
+        }
+    }
+    println!();
+    Ok(())
+}
+
+/// Run all examples
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    basic_example().await?;
+    with_options_example().await?;
+    with_tools_example().await?;
+    Ok(())
+}