add a ACPR library API

.github/workflows/ci.yml

@@ -18,6 +18,8 @@ jobs:
 
   test:
     runs-on: ubuntu-latest
+    env:
+      ACPR_SKIP_AGENT: 1
     steps:
     - uses: actions/checkout@v4
     - uses: dtolnay/rust-toolchain@stable

Cargo.toml

@@ -18,19 +18,43 @@ path = "src/main.rs"
 name = "acpr"
 path = "src/lib.rs"
 
+[[example]]
+name = "simple"
+path = "examples/simple.rs"
+
+[[example]]
+name = "sacp_integration"
+path = "examples/sacp_integration.rs"
+
+[[example]]
+name = "complete_interface"
+path = "examples/complete_interface.rs"
+
+[[example]]
+name = "bytestreams_integration"
+path = "examples/bytestreams_integration.rs"
+
+[[example]]
+name = "client_connection"
+path = "examples/client_connection.rs"
+
 [dependencies]
 anstyle = "1.0.14"
 clap = { version = "4", features = ["derive"] }
 dirs = "6.0.0"
 flate2 = "1.1.9"
 reqwest = { version = "0.13.2", features = ["json"] }
+sacp = "11.0.0"
+sacp-tokio = "11.0.0"
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.149"
 tar = "0.4.45"
-tokio = { version = "1.52.1", features = ["full"] }
+tokio = { version = "1.52.1", features = ["rt", "macros", "io-util", "process", "fs"] }
+tokio-util = { version = "0.7.18", features = ["compat"] }
 tracing = "0.1.44"
 tracing-subscriber = "0.3.23"
 zip = "8.5.1"
 
 [dev-dependencies]
 tempfile = "3.27.0"
+tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }

examples/bytestreams_integration.rs

@@ -0,0 +1,26 @@
+use acpr::Acpr;
+use sacp::ByteStreams;
+use tokio_util::compat::{TokioAsyncReadCompatExt, TokioAsyncWriteCompatExt};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Demonstrating ByteStreams integration...");
+
+    // Example 1: Using Acpr directly (it handles ByteStreams internally)
+    let agent = Acpr::new("auggie");
+    println!("Created agent: {}", agent.agent_name);
+
+    // Example 2: Manual ByteStreams creation (for custom stdio handling)
+    let (stdin_read, _stdin_write) = tokio::io::duplex(1024);
+    let (_stdout_read, stdout_write) = tokio::io::duplex(1024);
+
+    let _byte_streams = ByteStreams::new(stdout_write.compat_write(), stdin_read.compat());
+
+    println!("Created ByteStreams from custom stdio");
+
+    // In a real application, you would connect these:
+    // ConnectTo::<Client>::connect_to(byte_streams, client).await?;
+
+    println!("ByteStreams ready for sacp communication");
+    Ok(())
+}

examples/client_connection.rs

@@ -0,0 +1,26 @@
+use acpr::Acpr;
+use sacp::Client;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Connecting to auggie agent via sacp...");
+
+    // Create an acpr agent that implements ConnectTo<Client>
+    let agent = Acpr::new("auggie");
+
+    // Connect as a client to the agent
+    match Client
+        .builder()
+        .connect_with(agent, |_cx| async {
+            println!("Connected to agent successfully!");
+            // In a real application, you would send prompts and receive responses here
+            Ok(())
+        })
+        .await
+    {
+        Ok(_) => println!("Client connection completed"),
+        Err(e) => println!("Client connection failed: {}", e),
+    }
+
+    Ok(())
+}

examples/complete_interface.rs

@@ -0,0 +1,38 @@
+use acpr::{self, Acpr};
+use sacp::{Client, DynConnectTo};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // 1. Simple function interface
+    println!("Testing simple interface...");
+    match acpr::run("auggie").await {
+        Ok(_) => println!("✓ Simple interface works"),
+        Err(e) => println!("✗ Simple interface failed: {}", e),
+    }
+
+    // 2. Builder pattern with configuration
+    println!("\nTesting builder pattern...");
+    let agent = Acpr::new("auggie")
+        .with_cache_dir("/tmp/acpr_test".into())
+        .with_force(acpr::ForceOption::All);
+
+    match agent.run().await {
+        Ok(_) => println!("✓ Builder pattern works"),
+        Err(e) => println!("✗ Builder pattern failed: {}", e),
+    }
+
+    // 3. sacp integration
+    println!("\nTesting sacp integration...");
+    let agents: Vec<DynConnectTo<Client>> = vec![
+        DynConnectTo::new(Acpr::new("auggie")),
+        DynConnectTo::new(Acpr::new("cline")),
+    ];
+    println!("✓ Created {} sacp-compatible agents", agents.len());
+
+    // 4. Direct field access
+    let agent = Acpr::new("test-agent");
+    println!("✓ Agent name accessible: {}", agent.agent_name);
+
+    println!("\nAll interfaces working correctly!");
+    Ok(())
+}

examples/sacp_integration.rs

@@ -0,0 +1,26 @@
+use acpr::Acpr;
+use sacp::{Client, DynConnectTo};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Create multiple agents that can be used in sacp ecosystem
+    let agents: Vec<DynConnectTo<Client>> = vec![
+        DynConnectTo::new(Acpr::new("auggie")),
+        DynConnectTo::new(Acpr::new("cline")),
+    ];
+
+    println!(
+        "Created {} agents implementing ConnectTo<Client>",
+        agents.len()
+    );
+
+    // Example: Use first agent directly
+    let agent = Acpr::new("auggie");
+    println!("Agent name: {}", agent.agent_name);
+
+    // In a real sacp application, you would connect these to clients:
+    // Client.builder().connect_to(agent).await?;
+
+    println!("Agents ready for sacp integration");
+    Ok(())
+}

examples/simple.rs

@@ -0,0 +1,22 @@
+use acpr;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Simple usage - run an agent directly
+    println!("Running agent with simple interface...");
+    match acpr::run("auggie").await {
+        Ok(_) => println!("Agent completed successfully"),
+        Err(e) => println!("Agent failed: {}", e),
+    }
+
+    // Builder pattern with configuration
+    println!("\nRunning agent with builder pattern...");
+    let agent = acpr::Acpr::new("auggie").with_cache_dir("/tmp/acpr_example".into());
+
+    match agent.run().await {
+        Ok(_) => println!("Configured agent completed successfully"),
+        Err(e) => println!("Configured agent failed: {}", e),
+    }
+
+    Ok(())
+}