@augmentcode/auggie-sdk 0.1.10 → 0.1.11

package/dist/auggie/sdk-acp-client.js

@@ -1,355 +1,322 @@
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { Readable, Writable } from "node:stream";
-import { ClientSideConnection, ndJsonStream, PROTOCOL_VERSION, } from "@agentclientprotocol/sdk";
-import { getSDKVersion } from "../version";
-import { AuggieMCPServer } from "./sdk-mcp-server";
-/**
- * ACP Client for connecting to Auggie as an ACP server
- *
- * This client demonstrates how to:
- * 1. Launch Auggie in ACP mode
- * 2. Establish a bidirectional communication channel
- * 3. Initialize a session
- * 4. Send prompts and receive responses
- */
+import {
+  ClientSideConnection,
+  ndJsonStream,
+  PROTOCOL_VERSION
+} from "@agentclientprotocol/sdk";
+import { getSDKVersion } from "../version.js";
+import { AuggieMCPServer } from "./sdk-mcp-server.js";
 class Auggie {
-    constructor({ auggiePath = "auggie", workspaceRoot, model = "haiku4.5", allowIndexing = true, apiKey, apiUrl = process.env.AUGMENT_API_URL || "https://api.augmentcode.com", rules, excludedTools, } = {}) {
-        this.connection = null;
-        this.sessionId = null;
-        this.workspaceRoot = undefined;
-        this.auggieProcess = null;
-        this.sessionUpdateCallback = null;
-        this.debug = false;
-        this.mcpServer = null;
-        this.auggiePath = auggiePath;
-        this.workspaceRoot = workspaceRoot;
-        this.model = model;
-        this.allowIndexing = allowIndexing;
-        this.apiKey = apiKey;
-        this.apiUrl = apiUrl;
-        this.rules = rules;
-        this.excludedTools = excludedTools;
+  static PATH_SPLIT_REGEX = /\s+/;
+  connection = null;
+  sessionId = null;
+  auggiePath;
+  workspaceRoot = void 0;
+  auggieProcess = null;
+  sessionUpdateCallback = null;
+  debug = false;
+  mcpServer = null;
+  model;
+  allowIndexing;
+  apiKey;
+  apiUrl;
+  rules;
+  excludedTools;
+  constructor({
+    auggiePath = "auggie",
+    workspaceRoot,
+    model = "haiku4.5",
+    allowIndexing = true,
+    apiKey,
+    apiUrl = process.env.AUGMENT_API_URL || "https://api.augmentcode.com",
+    rules,
+    excludedTools
+  } = {}) {
+    this.auggiePath = auggiePath;
+    this.workspaceRoot = workspaceRoot;
+    this.model = model;
+    this.allowIndexing = allowIndexing;
+    this.apiKey = apiKey;
+    this.apiUrl = apiUrl;
+    this.rules = rules;
+    this.excludedTools = excludedTools;
+  }
+  /**
+   * Create and initialize a new Auggie instance
+   * This static factory method automatically connects and creates a session
+   */
+  static async create(options = {}) {
+    const instance = new Auggie(options);
+    await instance.connect();
+    const tools = options.tools || options.toolsMap;
+    await instance.createSession(tools);
+    return instance;
+  }
+  /**
+   * Connect to Auggie ACP server
+   */
+  async connect() {
+    const args = ["--acp", "--log-level=debug"];
+    if (this.model) {
+      args.push("--model", this.model);
     }
-    /**
-     * Create and initialize a new Auggie instance
-     * This static factory method automatically connects and creates a session
-     */
-    static async create(options = {}) {
-        const instance = new Auggie(options);
-        await instance.connect();
-        // Support both 'tools' and 'toolsMap' for backwards compatibility
-        const tools = options.tools || options.toolsMap;
-        await instance.createSession(tools);
-        return instance;
+    if (this.allowIndexing) {
+      args.push("--allow-indexing");
     }
-    /**
-     * Connect to Auggie ACP server
-     */
-    async connect() {
-        const args = ["--acp", "--log-level=debug"];
-        if (this.model) {
-            args.push("--model", this.model);
-        }
-        if (this.allowIndexing) {
-            args.push("--allow-indexing");
-        }
-        if (this.workspaceRoot) {
-            args.push("--workspace-root", this.workspaceRoot);
+    if (this.workspaceRoot) {
+      args.push("--workspace-root", this.workspaceRoot);
+    }
+    if (this.rules && this.rules.length > 0) {
+      for (const rulePath of this.rules) {
+        if (!existsSync(rulePath)) {
+          throw new Error(`Rule file does not exist: ${rulePath}`);
         }
-        if (this.rules && this.rules.length > 0) {
-            // Validate that all rule files exist before proceeding
-            for (const rulePath of this.rules) {
-                if (!existsSync(rulePath)) {
-                    throw new Error(`Rule file does not exist: ${rulePath}`);
-                }
-                args.push("--rules", rulePath);
-            }
+        args.push("--rules", rulePath);
+      }
+    }
+    if (this.excludedTools && this.excludedTools.length > 0) {
+      for (const tool of this.excludedTools) {
+        args.push("--remove-tool", tool);
+      }
+    }
+    const pathParts = this.auggiePath.trim().split(Auggie.PATH_SPLIT_REGEX);
+    if (pathParts.length === 0 || !pathParts[0]) {
+      throw new Error("Invalid auggiePath: cannot be empty");
+    }
+    const command = pathParts[0];
+    const commandArgs = [...pathParts.slice(1), ...args];
+    const env = { ...process.env };
+    if (this.apiKey) {
+      env.AUGMENT_API_TOKEN = this.apiKey;
+    }
+    if (this.apiUrl) {
+      env.AUGMENT_API_URL = this.apiUrl;
+    }
+    this.auggieProcess = spawn(command, commandArgs, {
+      stdio: ["pipe", "pipe", "inherit"],
+      env
+    });
+    this.auggieProcess.on("error", (error) => {
+      console.error("Failed to start Auggie process:", error);
+      throw error;
+    });
+    this.auggieProcess.on("exit", (code, signal) => {
+      if (this.debug)
+        console.log(
+          `Auggie process exited with code ${code} and signal ${signal}`
+        );
+    });
+    if (!(this.auggieProcess.stdout && this.auggieProcess.stdin)) {
+      throw new Error("Failed to create stdio pipes for Auggie process");
+    }
+    const input = Readable.toWeb(
+      this.auggieProcess.stdout
+    );
+    const output = Writable.toWeb(this.auggieProcess.stdin);
+    const stream = ndJsonStream(output, input);
+    this.connection = new ClientSideConnection(
+      (agent) => this.createClient(agent),
+      stream
+    );
+    if (this.debug) {
+      console.log("Connected to Auggie ACP server");
+    }
+    await this.initializeConnection();
+  }
+  /**
+   * Create a Client implementation to handle agent requests
+   */
+  createClient(_agent) {
+    return {
+      // Handle session updates from the agent
+      sessionUpdate: (params) => {
+        if (this.sessionUpdateCallback) {
+          this.sessionUpdateCallback(params);
         }
-        if (this.excludedTools && this.excludedTools.length > 0) {
-            // Add each excluded tool as a separate --remove-tool argument
-            for (const tool of this.excludedTools) {
-                args.push("--remove-tool", tool);
+        return Promise.resolve();
+      },
+      // Handle permission requests from the agent
+      requestPermission: (params) => {
+        if (this.debug) console.log("Permission requested:", params);
+        if (params.options && params.options.length > 0) {
+          return Promise.resolve({
+            outcome: {
+              outcome: "selected",
+              optionId: params.options?.[0]?.name || ""
             }
+          });
         }
-        // Parse auggiePath to handle cases where it includes arguments (e.g., "node /path/to/file.js")
-        const pathParts = this.auggiePath.trim().split(Auggie.PATH_SPLIT_REGEX);
-        if (pathParts.length === 0 || !pathParts[0]) {
-            throw new Error("Invalid auggiePath: cannot be empty");
-        }
-        const command = pathParts[0];
-        const commandArgs = [...pathParts.slice(1), ...args];
-        // Build environment variables for the Auggie process
-        const env = { ...process.env };
-        if (this.apiKey) {
-            env.AUGMENT_API_TOKEN = this.apiKey;
-        }
-        if (this.apiUrl) {
-            env.AUGMENT_API_URL = this.apiUrl;
-        }
-        this.auggieProcess = spawn(command, commandArgs, {
-            stdio: ["pipe", "pipe", "inherit"],
-            env,
+        return Promise.resolve({
+          outcome: {
+            outcome: "cancelled"
+          }
         });
-        // Handle process errors
-        this.auggieProcess.on("error", (error) => {
-            console.error("Failed to start Auggie process:", error);
-            throw error;
-        });
-        this.auggieProcess.on("exit", (code, signal) => {
-            if (this.debug)
-                console.log(`Auggie process exited with code ${code} and signal ${signal}`);
-        });
-        // Create streams for ACP communication
-        // Note: Auggie writes to stdout and reads from stdin
-        if (!(this.auggieProcess.stdout && this.auggieProcess.stdin)) {
-            throw new Error("Failed to create stdio pipes for Auggie process");
-        }
-        const input = Readable.toWeb(this.auggieProcess.stdout);
-        const output = Writable.toWeb(this.auggieProcess.stdin);
-        // Create ndjson stream for ACP protocol
-        const stream = ndJsonStream(output, input);
-        // Create client-side connection with a Client implementation
-        this.connection = new ClientSideConnection((agent) => this.createClient(agent), stream);
-        if (this.debug) {
-            console.log("Connected to Auggie ACP server");
-        }
-        // Initialize the connection
-        await this.initializeConnection();
+      }
+    };
+  }
+  /**
+   * Initialize the ACP connection
+   */
+  async initializeConnection() {
+    if (!this.connection) {
+      throw new Error("Not connected. Call connect() first.");
     }
-    /**
-     * Create a Client implementation to handle agent requests
-     */
-    createClient(_agent) {
-        return {
-            // Handle session updates from the agent
-            sessionUpdate: (params) => {
-                if (this.sessionUpdateCallback) {
-                    this.sessionUpdateCallback(params);
-                }
-                return Promise.resolve();
-            },
-            // Handle permission requests from the agent
-            requestPermission: (params) => {
-                // For this example, auto-select the first option if available
-                // In a real implementation, you'd prompt the user
-                if (this.debug)
-                    console.log("Permission requested:", params);
-                if (params.options && params.options.length > 0) {
-                    return Promise.resolve({
-                        outcome: {
-                            outcome: "selected",
-                            optionId: params.options?.[0]?.name || "",
-                        },
-                    });
-                }
-                // If no options, return cancelled
-                return Promise.resolve({
-                    outcome: {
-                        outcome: "cancelled",
-                    },
-                });
-            },
-        };
+    if (this.debug) console.log("Initializing ACP connection...");
+    const initResponse = await this.connection.initialize({
+      protocolVersion: PROTOCOL_VERSION,
+      clientInfo: {
+        name: "auggie-sdk-typescript",
+        version: getSDKVersion()
+      },
+      clientCapabilities: {}
+    });
+    if (this.debug)
+      console.log("Initialized:", JSON.stringify(initResponse, null, 2));
+  }
+  /**
+   * Create a new session
+   */
+  async createSession(tools) {
+    if (!this.connection) {
+      throw new Error("Not connected. Call connect() first.");
     }
-    /**
-     * Initialize the ACP connection
-     */
-    async initializeConnection() {
-        if (!this.connection) {
-            throw new Error("Not connected. Call connect() first.");
-        }
-        if (this.debug)
-            console.log("Initializing ACP connection...");
-        const initResponse = await this.connection.initialize({
-            protocolVersion: PROTOCOL_VERSION,
-            clientInfo: {
-                name: "auggie-sdk-typescript",
-                version: getSDKVersion(),
-            },
-            clientCapabilities: {},
-        });
-        if (this.debug)
-            console.log("Initialized:", JSON.stringify(initResponse, null, 2));
+    if (this.debug) console.log("Creating new session...");
+    const mcpServers = [];
+    if (tools && Object.keys(tools).length > 0) {
+      if (this.debug) console.log("Starting MCP server with provided tools...");
+      this.mcpServer = new AuggieMCPServer(tools, void 0);
+      const serverUrl = await this.mcpServer.start();
+      if (this.debug) console.log(`MCP server started at: ${serverUrl}`);
+      mcpServers.push({
+        type: "http",
+        name: "auggie_sdk",
+        url: serverUrl,
+        headers: []
+      });
     }
-    /**
-     * Create a new session
-     */
-    async createSession(tools) {
-        if (!this.connection) {
-            throw new Error("Not connected. Call connect() first.");
-        }
-        if (this.debug)
-            console.log("Creating new session...");
-        // Build MCP servers array for the session
-        const mcpServers = [];
-        // If tools are provided, create and start an MCP server
-        if (tools && Object.keys(tools).length > 0) {
-            if (this.debug)
-                console.log("Starting MCP server with provided tools...");
-            this.mcpServer = new AuggieMCPServer(tools, undefined);
-            const serverUrl = await this.mcpServer.start();
-            if (this.debug)
-                console.log(`MCP server started at: ${serverUrl}`);
-            // Add the MCP server to the session configuration
-            mcpServers.push({
-                type: "http",
-                name: "auggie_sdk",
-                url: serverUrl,
-                headers: [],
-            });
-        }
-        const sessionResponse = await this.connection.newSession({
-            cwd: this.workspaceRoot ? this.workspaceRoot : process.cwd(),
-            mcpServers,
-        });
-        this.sessionId = sessionResponse.sessionId;
-        if (this.debug) {
-            console.log(`Session created: ${this.sessionId}`);
-            console.log("   Available modes:", sessionResponse.modes?.availableModes);
-        }
-        return this.sessionId;
+    const sessionResponse = await this.connection.newSession({
+      cwd: this.workspaceRoot ? this.workspaceRoot : process.cwd(),
+      mcpServers
+    });
+    this.sessionId = sessionResponse.sessionId;
+    if (this.debug) {
+      console.log(`Session created: ${this.sessionId}`);
+      console.log("   Available modes:", sessionResponse.modes?.availableModes);
     }
-    /**
-     * Send a prompt to the agent and accumulate the text response
-     * @param message - The text prompt to send to the agent
-     * @param isAnswerOnly - If true, returns only the final response after all tool calls complete.
-     *                        If false or undefined, returns all agent message chunks (default: false)
-     * @returns The accumulated text response from the agent
-     */
-    async prompt(message, { isAnswerOnly = false } = {
-        isAnswerOnly: false,
-    }) {
-        if (!(this.connection && this.sessionId)) {
-            throw new Error("Not connected or no session. Initialization failed.");
-        }
-        if (this.debug)
-            console.log(`\nSending prompt: "${message}"`);
-        // Accumulator for text responses
-        let accumulatedText = "";
-        // Track the final response separately (text after the last tool call)
-        let finalResponseText = "";
-        // Track if we've seen a tool call
-        let hasSeenToolCall = false;
-        // Temporary callback to accumulate text
-        const originalCallback = this.sessionUpdateCallback;
-        const accumulatorCallback = (update) => {
-            // Track tool calls to know when to start capturing final response
-            if (update.update.sessionUpdate === "tool_call") {
-                hasSeenToolCall = true;
-                // Reset final response text when a new tool call starts
-                finalResponseText = "";
-            }
-            // Accumulate text content
-            if (update.update.sessionUpdate === "agent_message_chunk" &&
-                update.update.content.type === "text") {
-                const textChunk = update.update.content.text;
-                accumulatedText += textChunk;
-                // If we've seen a tool call, accumulate text for final response
-                // This captures the agent's response after tool execution
-                if (hasSeenToolCall) {
-                    finalResponseText += textChunk;
-                }
-            }
-            // Also call the original callback if it exists
-            if (originalCallback) {
-                originalCallback(update);
-            }
-        };
-        // Temporarily replace the callback
-        this.sessionUpdateCallback = accumulatorCallback;
-        try {
-            // Build content blocks
-            const content = [
-                {
-                    type: "text",
-                    text: message,
-                },
-            ];
-            // Send the prompt and wait for response
-            const response = await this.connection.prompt({
-                sessionId: this.sessionId,
-                prompt: content,
-            });
-            if (this.debug)
-                console.log("Prompt completed with stop reason:", response.stopReason);
-            // Restore original callback
-            this.sessionUpdateCallback = originalCallback;
-            // Return final response if requested and we had tool calls, otherwise return all text
-            if (isAnswerOnly && hasSeenToolCall) {
-                return finalResponseText;
-            }
-            return accumulatedText;
+    return this.sessionId;
+  }
+  /**
+   * Send a prompt to the agent and accumulate the text response
+   * @param message - The text prompt to send to the agent
+   * @param isAnswerOnly - If true, returns only the final response after all tool calls complete.
+   *                        If false or undefined, returns all agent message chunks (default: false)
+   * @returns The accumulated text response from the agent
+   */
+  async prompt(message, { isAnswerOnly = false } = {
+    isAnswerOnly: false
+  }) {
+    if (!(this.connection && this.sessionId)) {
+      throw new Error("Not connected or no session. Initialization failed.");
+    }
+    if (this.debug) console.log(`
+Sending prompt: "${message}"`);
+    let accumulatedText = "";
+    let finalResponseText = "";
+    let hasSeenToolCall = false;
+    const originalCallback = this.sessionUpdateCallback;
+    const accumulatorCallback = (update) => {
+      if (update.update.sessionUpdate === "tool_call") {
+        hasSeenToolCall = true;
+        finalResponseText = "";
+      }
+      if (update.update.sessionUpdate === "agent_message_chunk" && update.update.content.type === "text") {
+        const textChunk = update.update.content.text;
+        accumulatedText += textChunk;
+        if (hasSeenToolCall) {
+          finalResponseText += textChunk;
         }
-        catch (error) {
-            console.error("Error during prompt:", error);
-            // Restore original callback before closing
-            this.sessionUpdateCallback = originalCallback;
-            // Kill the process on error
-            await this.close();
-            throw error;
+      }
+      if (originalCallback) {
+        originalCallback(update);
+      }
+    };
+    this.sessionUpdateCallback = accumulatorCallback;
+    try {
+      const content = [
+        {
+          type: "text",
+          text: message
         }
+      ];
+      const response = await this.connection.prompt({
+        sessionId: this.sessionId,
+        prompt: content
+      });
+      if (this.debug)
+        console.log("Prompt completed with stop reason:", response.stopReason);
+      this.sessionUpdateCallback = originalCallback;
+      if (isAnswerOnly && hasSeenToolCall) {
+        return finalResponseText;
+      }
+      return accumulatedText;
+    } catch (error) {
+      console.error("Error during prompt:", error);
+      this.sessionUpdateCallback = originalCallback;
+      await this.close();
+      throw error;
     }
-    /**
-     * Listen for session update events from the agent
-     */
-    onSessionUpdate(callback) {
-        this.sessionUpdateCallback = callback;
+  }
+  /**
+   * Listen for session update events from the agent
+   */
+  onSessionUpdate(callback) {
+    this.sessionUpdateCallback = callback;
+  }
+  /**
+   * Cancel the current request
+   */
+  async cancel() {
+    if (!(this.connection && this.sessionId)) {
+      throw new Error("Not connected or no session.");
     }
-    /**
-     * Cancel the current request
-     */
-    async cancel() {
-        if (!(this.connection && this.sessionId)) {
-            throw new Error("Not connected or no session.");
-        }
-        if (this.debug)
-            console.log(" Cancelling current request...");
-        await this.connection.cancel({
-            sessionId: this.sessionId,
-        });
-        if (this.debug)
-            console.log(" Request cancelled");
+    if (this.debug) console.log(" Cancelling current request...");
+    await this.connection.cancel({
+      sessionId: this.sessionId
+    });
+    if (this.debug) console.log(" Request cancelled");
+  }
+  /**
+   * Close the connection and kill the Auggie process
+   */
+  async close() {
+    if (this.debug) console.log(" Closing connection...");
+    this.killProcess();
+    if (this.mcpServer) {
+      if (this.debug) console.log(" Stopping MCP server...");
+      await Promise.race([
+        this.mcpServer.stop(),
+        new Promise((resolve) => setTimeout(resolve, 100))
+      ]);
+      this.mcpServer = null;
     }
-    /**
-     * Close the connection and kill the Auggie process
-     */
-    async close() {
-        if (this.debug)
-            console.log(" Closing connection...");
-        // Kill the Auggie process first - this will naturally close all MCP connections
-        this.killProcess();
-        // Stop the MCP server (should be fast since Auggie is already killed)
-        if (this.mcpServer) {
-            if (this.debug)
-                console.log(" Stopping MCP server...");
-            // Use a short timeout since the connections are already closed
-            await Promise.race([
-                this.mcpServer.stop(),
-                new Promise((resolve) => setTimeout(resolve, 100)),
-            ]);
-            this.mcpServer = null;
-        }
-        // Clean up connection state
-        if (this.connection) {
-            this.connection = null;
-            this.sessionId = null;
-        }
-        if (this.debug)
-            console.log(" Connection closed");
+    if (this.connection) {
+      this.connection = null;
+      this.sessionId = null;
     }
-    /**
-     * Kill the Auggie process if it's still running
-     */
-    killProcess() {
-        if (this.auggieProcess && !this.auggieProcess.killed) {
-            if (this.debug)
-                console.log(" Killing Auggie process...");
-            // Use SIGKILL for immediate termination
-            this.auggieProcess.kill("SIGKILL");
-        }
+    if (this.debug) console.log(" Connection closed");
+  }
+  /**
+   * Kill the Auggie process if it's still running
+   */
+  killProcess() {
+    if (this.auggieProcess && !this.auggieProcess.killed) {
+      if (this.debug) console.log(" Killing Auggie process...");
+      this.auggieProcess.kill("SIGKILL");
     }
+  }
 }
-Auggie.PATH_SPLIT_REGEX = /\s+/;
-export { Auggie };
-//# sourceMappingURL=sdk-acp-client.js.map
+export {
+  Auggie
+};