@augmentcode/auggie-sdk 0.1.9 → 0.1.11

package/dist/context/filesystem-context.d.ts

@@ -1,4 +1,5 @@
-import type { FileSystemContextOptions } from "./types";
+import { FileSystemContextOptions } from './types.js';
+
 /**
  * FileSystem Context - Local directory retrieval via MCP protocol
  *
@@ -9,7 +10,7 @@ import type { FileSystemContextOptions } from "./types";
  * This class spawns `auggie --mcp` and communicates with it via the MCP protocol
  * to provide codebase retrieval from a local directory.
  */
-export declare class FileSystemContext {
+declare class FileSystemContext {
     private readonly auggiePath;
     private readonly directory;
     private readonly debug;
@@ -84,4 +85,5 @@ export declare class FileSystemContext {
      */
     close(): Promise<void>;
 }
-//# sourceMappingURL=filesystem-context.d.ts.map
+
+export { FileSystemContext };

package/dist/context/filesystem-context.js

@@ -1,220 +1,198 @@
 import { MCPClient } from "@mastra/mcp";
-import { ContextAPIClient } from "./internal/api-client";
-import { chatWithRetry } from "./internal/chat-utils";
-import { resolveCredentials } from "./internal/credentials";
-import { formatSearchPrompt } from "./internal/search-utils";
-/**
- * FileSystem Context - Local directory retrieval via MCP protocol
- *
- * ⚠️ **EXPERIMENTAL API** - This API is experimental and may change without notice.
- *
- * @experimental
- *
- * This class spawns `auggie --mcp` and communicates with it via the MCP protocol
- * to provide codebase retrieval from a local directory.
- */
-export class FileSystemContext {
-    /**
-     * Create a new FileSystemContext instance
-     * @param options Configuration options
-     * @param apiKey API key for authentication
-     * @param apiUrl API URL for the tenant
-     */
-    constructor(options, apiKey, apiUrl) {
-        this.mcpClient = null;
-        this.apiClient = null;
-        this.auggiePath = options.auggiePath || "auggie";
-        this.directory = options.directory;
-        this.debug = options.debug ?? false;
-        this.apiKey = apiKey;
-        this.apiUrl = apiUrl;
+import { ContextAPIClient } from "./internal/api-client.js";
+import { chatWithRetry } from "./internal/chat-utils.js";
+import { resolveCredentials } from "./internal/credentials.js";
+import { formatSearchPrompt } from "./internal/search-utils.js";
+class FileSystemContext {
+  auggiePath;
+  directory;
+  debug;
+  apiKey;
+  apiUrl;
+  mcpClient = null;
+  apiClient = null;
+  /**
+   * Create a new FileSystemContext instance
+   * @param options Configuration options
+   * @param apiKey API key for authentication
+   * @param apiUrl API URL for the tenant
+   */
+  constructor(options, apiKey, apiUrl) {
+    this.auggiePath = options.auggiePath || "auggie";
+    this.directory = options.directory;
+    this.debug = options.debug ?? false;
+    this.apiKey = apiKey;
+    this.apiUrl = apiUrl;
+  }
+  /**
+   * Create and initialize a new FileSystemContext instance
+   */
+  static async create(options) {
+    let apiKey;
+    let apiUrl;
+    try {
+      const credentials = await resolveCredentials({});
+      apiKey = credentials.apiKey;
+      apiUrl = credentials.apiUrl;
+    } catch {
     }
-    /**
-     * Create and initialize a new FileSystemContext instance
-     */
-    static async create(options) {
-        // Resolve credentials, but allow them to be undefined for FileSystemContext
-        // since searchAndAsk is optional functionality
-        let apiKey;
-        let apiUrl;
-        try {
-            const credentials = await resolveCredentials({});
-            apiKey = credentials.apiKey;
-            apiUrl = credentials.apiUrl;
-        }
-        catch {
-            // Credentials are optional for FileSystemContext
-            // They're only required if searchAndAsk() is called
-        }
-        const instance = new FileSystemContext(options, apiKey, apiUrl);
-        await Promise.resolve(instance.connect());
-        return instance;
+    const instance = new FileSystemContext(options, apiKey, apiUrl);
+    await Promise.resolve(instance.connect());
+    return instance;
+  }
+  /**
+   * Log a debug message if debug mode is enabled
+   */
+  log(message) {
+    if (this.debug) {
+      console.log(`[FileSystemContext] ${message}`);
     }
-    /**
-     * Log a debug message if debug mode is enabled
-     */
-    log(message) {
-        if (this.debug) {
-            console.log(`[FileSystemContext] ${message}`);
-        }
+  }
+  /**
+   * Connect to Auggie MCP server
+   */
+  connect() {
+    this.log(`Starting MCP server for directory: ${this.directory}`);
+    const command = this.auggiePath.trim();
+    if (!command) {
+      throw new Error("Invalid auggiePath: cannot be empty");
     }
-    /**
-     * Connect to Auggie MCP server
-     */
-    connect() {
-        this.log(`Starting MCP server for directory: ${this.directory}`);
-        const command = this.auggiePath.trim();
-        if (!command) {
-            throw new Error("Invalid auggiePath: cannot be empty");
-        }
-        const args = ["--mcp", "--workspace-root", this.directory];
-        // Build environment variables
-        const env = {};
-        for (const [key, value] of Object.entries(process.env)) {
-            if (value !== undefined) {
-                env[key] = value;
-            }
-        }
-        if (this.apiKey) {
-            env.AUGMENT_API_TOKEN = this.apiKey;
-        }
-        if (this.apiUrl) {
-            env.AUGMENT_API_URL = this.apiUrl;
-        }
-        // Create MCP client using MCPClient
-        this.mcpClient = new MCPClient({
-            servers: {
-                auggie: {
-                    command,
-                    args,
-                    env,
-                    logger: this.debug
-                        ? (logMessage) => {
-                            console.log(`[MCP ${logMessage.level}] ${logMessage.message}`, logMessage.details);
-                        }
-                        : undefined,
-                },
-            },
-        });
-        this.log("Connected to Auggie MCP server");
+    const args = ["--mcp", "--workspace-root", this.directory];
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value !== void 0) {
+        env[key] = value;
+      }
     }
-    /**
-     * Search the codebase using natural language and return formatted results.
-     *
-     * The results are returned as a formatted string designed for use in LLM prompts.
-     * The format includes file paths, line numbers, and code content in a structured,
-     * readable format that can be passed directly to LLM APIs like `generate()`.
-     *
-     * @param query - The search query describing what code you're looking for
-     * @returns A formatted string containing the search results, ready for LLM consumption
-     *
-     * @example
-     * ```typescript
-     * const context = await FileSystemContext.create({ directory: "./my-project" });
-     * const results = await context.search("authentication logic");
-     * console.log(results); // Formatted string with file paths, line numbers, and code
-     *
-     * // Use directly with generate API
-     * const response = await generate(
-     *   `Based on this code:\n\n${results}\n\nHow does authentication work?`,
-     *   { model: "sonnet4.5" }
-     * );
-     * ```
-     */
-    async search(query) {
-        if (!this.mcpClient) {
-            throw new Error("MCP client not initialized. Call create() first.");
-        }
-        this.log(`Searching for: "${query}"`);
-        try {
-            // Get the tools from the MCP client
-            // getTools() returns tools with server name prefix (auggie_codebase-retrieval)
-            const tools = await this.mcpClient.getTools();
-            const codebaseRetrievalTool = tools["auggie_codebase-retrieval"];
-            if (!codebaseRetrievalTool) {
-                throw new Error(`codebase-retrieval tool not found. Available tools: ${Object.keys(tools).join(", ")}`);
-            }
-            // Execute the MCP tool
-            //
-            // MCP Tool Input Format:
-            // Mastra MCP wraps tool parameters in a 'context' property:
-            //   { context: { param1: value1, param2: value2, ... } }
-            //
-            // MCP Tool Output Format:
-            // MCP tools return results in the Model Context Protocol format:
-            //   { content: [{ type: "text", text: "..." }, ...] }
-            // This allows tools to return multiple content blocks of different types.
-            const result = await codebaseRetrievalTool.execute({
-                context: {
-                    information_request: query,
-                },
-            });
-            // Extract text from MCP result (standard MCP format)
-            if (!(result?.content && Array.isArray(result.content))) {
-                throw new Error(`Unexpected MCP response format: expected { content: [...] }, got ${JSON.stringify(result)}`);
-            }
-            const text = result.content
-                .filter((item) => item.type === "text")
-                .map((item) => item.text || "")
-                .join("\n");
-            this.log(`Search completed (${text.length} characters)`);
-            return text;
-        }
-        catch (error) {
-            throw new Error(`Codebase retrieval failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
+    if (this.apiKey) {
+      env.AUGMENT_API_TOKEN = this.apiKey;
     }
-    /**
-     * Search the indexed codebase and ask an LLM a question about the results.
-     *
-     * This is a convenience method that combines search() with an LLM call to answer
-     * questions about your codebase.
-     *
-     * @param searchQuery - The semantic search query to find relevant code (also used as the prompt if no separate prompt is provided)
-     * @param prompt - Optional prompt to ask the LLM about the search results. If not provided, searchQuery is used as the prompt.
-     * @returns The LLM's answer to your question
-     *
-     * @example
-     * ```typescript
-     * const answer = await context.searchAndAsk(
-     *   "How does the authentication flow work?"
-     * );
-     * console.log(answer);
-     * ```
-     */
-    async searchAndAsk(searchQuery, prompt) {
-        const results = await this.search(searchQuery);
-        const llmPrompt = formatSearchPrompt(prompt ?? searchQuery, results);
-        // Lazy initialization of API client
-        if (!this.apiClient) {
-            if (!(this.apiKey && this.apiUrl)) {
-                throw new Error("API credentials are required for searchAndAsk(). Provide them via:\n" +
-                    "1. AUGMENT_API_TOKEN and AUGMENT_API_URL environment variables\n" +
-                    "2. Run 'auggie login' to create ~/.augment/session.json");
-            }
-            this.apiClient = new ContextAPIClient({
-                apiKey: this.apiKey,
-                apiUrl: this.apiUrl,
-                debug: this.debug,
-            });
+    if (this.apiUrl) {
+      env.AUGMENT_API_URL = this.apiUrl;
+    }
+    this.mcpClient = new MCPClient({
+      servers: {
+        auggie: {
+          command,
+          args,
+          env,
+          logger: this.debug ? (logMessage) => {
+            console.log(
+              `[MCP ${logMessage.level}] ${logMessage.message}`,
+              logMessage.details
+            );
+          } : void 0
         }
-        return await chatWithRetry(this.apiClient, llmPrompt, this.debug);
+      }
+    });
+    this.log("Connected to Auggie MCP server");
+  }
+  /**
+   * Search the codebase using natural language and return formatted results.
+   *
+   * The results are returned as a formatted string designed for use in LLM prompts.
+   * The format includes file paths, line numbers, and code content in a structured,
+   * readable format that can be passed directly to LLM APIs like `generate()`.
+   *
+   * @param query - The search query describing what code you're looking for
+   * @returns A formatted string containing the search results, ready for LLM consumption
+   *
+   * @example
+   * ```typescript
+   * const context = await FileSystemContext.create({ directory: "./my-project" });
+   * const results = await context.search("authentication logic");
+   * console.log(results); // Formatted string with file paths, line numbers, and code
+   *
+   * // Use directly with generate API
+   * const response = await generate(
+   *   `Based on this code:\n\n${results}\n\nHow does authentication work?`,
+   *   { model: "sonnet4.5" }
+   * );
+   * ```
+   */
+  async search(query) {
+    if (!this.mcpClient) {
+      throw new Error("MCP client not initialized. Call create() first.");
     }
-    /**
-     * Close the MCP connection and cleanup resources
-     */
-    async close() {
-        this.log("Closing MCP connection");
-        if (this.mcpClient) {
-            try {
-                await this.mcpClient.disconnect();
-            }
-            catch (error) {
-                console.error("Error closing MCP client:", error);
-            }
-            this.mcpClient = null;
+    this.log(`Searching for: "${query}"`);
+    try {
+      const tools = await this.mcpClient.getTools();
+      const codebaseRetrievalTool = tools["auggie_codebase-retrieval"];
+      if (!codebaseRetrievalTool) {
+        throw new Error(
+          `codebase-retrieval tool not found. Available tools: ${Object.keys(tools).join(", ")}`
+        );
+      }
+      const result = await codebaseRetrievalTool.execute({
+        context: {
+          information_request: query
         }
-        this.log("MCP connection closed");
+      });
+      if (!(result?.content && Array.isArray(result.content))) {
+        throw new Error(
+          `Unexpected MCP response format: expected { content: [...] }, got ${JSON.stringify(result)}`
+        );
+      }
+      const text = result.content.filter((item) => item.type === "text").map((item) => item.text || "").join("\n");
+      this.log(`Search completed (${text.length} characters)`);
+      return text;
+    } catch (error) {
+      throw new Error(
+        `Codebase retrieval failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Search the indexed codebase and ask an LLM a question about the results.
+   *
+   * This is a convenience method that combines search() with an LLM call to answer
+   * questions about your codebase.
+   *
+   * @param searchQuery - The semantic search query to find relevant code (also used as the prompt if no separate prompt is provided)
+   * @param prompt - Optional prompt to ask the LLM about the search results. If not provided, searchQuery is used as the prompt.
+   * @returns The LLM's answer to your question
+   *
+   * @example
+   * ```typescript
+   * const answer = await context.searchAndAsk(
+   *   "How does the authentication flow work?"
+   * );
+   * console.log(answer);
+   * ```
+   */
+  async searchAndAsk(searchQuery, prompt) {
+    const results = await this.search(searchQuery);
+    const llmPrompt = formatSearchPrompt(prompt ?? searchQuery, results);
+    if (!this.apiClient) {
+      if (!(this.apiKey && this.apiUrl)) {
+        throw new Error(
+          "API credentials are required for searchAndAsk(). Provide them via:\n1. AUGMENT_API_TOKEN and AUGMENT_API_URL environment variables\n2. Run 'auggie login' to create ~/.augment/session.json"
+        );
+      }
+      this.apiClient = new ContextAPIClient({
+        apiKey: this.apiKey,
+        apiUrl: this.apiUrl,
+        debug: this.debug
+      });
+    }
+    return await chatWithRetry(this.apiClient, llmPrompt, this.debug);
+  }
+  /**
+   * Close the MCP connection and cleanup resources
+   */
+  async close() {
+    this.log("Closing MCP connection");
+    if (this.mcpClient) {
+      try {
+        await this.mcpClient.disconnect();
+      } catch (error) {
+        console.error("Error closing MCP client:", error);
+      }
+      this.mcpClient = null;
     }
+    this.log("MCP connection closed");
+  }
 }
-//# sourceMappingURL=filesystem-context.js.map
+export {
+  FileSystemContext
+};

package/dist/context/internal/__mocks__/api-client.d.ts

@@ -1,9 +1,11 @@
+import { Blobs } from '../../types.js';
+import { ContextAPIClient, UploadBlob, FindMissingResult, BatchUploadResult, CheckpointBlobsResult, AgentCodebaseRetrievalResult } from '../api-client.js';
+
 /**
  * Mock implementation of ContextAPIClient for testing
  */
-import type { Blobs } from "../../types";
-import { type AgentCodebaseRetrievalResult, type BatchUploadResult, type CheckpointBlobsResult, ContextAPIClient, type FindMissingResult, type UploadBlob } from "../api-client";
-export type MockAPIClientConfig = {
+
+type MockAPIClientConfig = {
     /** Blobs that the server knows about (uploaded) */
     knownBlobs?: Set<string>;
     /** Blobs that are indexed (subset of knownBlobs) */
@@ -16,14 +18,17 @@ export type MockAPIClientConfig = {
     shouldFailBatchUpload?: boolean;
     /** Should checkpointBlobs throw an error? */
     shouldFailCheckpoint?: boolean;
+    /** Function to transform blob IDs (simulates backend computing different IDs) */
+    blobIdTransform?: (blobId: string) => string;
 };
-export declare class MockContextAPIClient extends ContextAPIClient {
-    private knownBlobs;
-    private indexedBlobs;
-    private delay;
-    private shouldFailFindMissing;
-    private shouldFailBatchUpload;
-    private shouldFailCheckpoint;
+declare class MockContextAPIClient extends ContextAPIClient {
+    private readonly knownBlobs;
+    private readonly indexedBlobs;
+    private readonly delay;
+    private readonly shouldFailFindMissing;
+    private readonly shouldFailBatchUpload;
+    private readonly shouldFailCheckpoint;
+    private readonly blobIdTransform?;
     findMissingCalls: string[][];
     batchUploadCalls: UploadBlob[][];
     checkpointBlobsCalls: Blobs[];
@@ -46,4 +51,5 @@ export declare class MockContextAPIClient extends ContextAPIClient {
     /** Reset all call tracking */
     resetCalls(): void;
 }
-//# sourceMappingURL=api-client.d.ts.map
+
+export { type MockAPIClientConfig, MockContextAPIClient };