@augmentcode/auggie-sdk 0.1.10 → 0.1.12

package/dist/auggie/sdk-mcp-server.d.ts

@@ -1,5 +1,6 @@
-import type { Tool } from "ai";
-export declare class AuggieMCPServer {
+import { Tool } from 'ai';
+
+declare class AuggieMCPServer {
     private readonly server;
     private httpServer;
     private PORT;
@@ -9,4 +10,5 @@ export declare class AuggieMCPServer {
     start(): Promise<string>;
     stop(): Promise<void>;
 }
-//# sourceMappingURL=sdk-mcp-server.d.ts.map
+
+export { AuggieMCPServer };

package/dist/auggie/sdk-mcp-server.js

@@ -1,123 +1,113 @@
-import { createServer as createHTTPServer, } from "node:http";
+import {
+  createServer as createHTTPServer
+} from "node:http";
 import { createServer } from "node:net";
 import { MCPServer } from "@mastra/mcp";
-/**
- * Find a free port by creating a temporary server on port 0
- * and getting the assigned port number
- */
 function findFreePort() {
-    return new Promise((resolve, reject) => {
-        const server = createServer();
-        server.unref();
-        server.on("error", reject);
-        server.listen(0, () => {
-            const address = server.address();
-            if (address && typeof address !== "string") {
-                const port = address.port;
-                server.close(() => {
-                    resolve(port);
-                });
-            }
-            else {
-                reject(new Error("Failed to get port from server address"));
-            }
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.unref();
+    server.on("error", reject);
+    server.listen(0, () => {
+      const address = server.address();
+      if (address && typeof address !== "string") {
+        const port = address.port;
+        server.close(() => {
+          resolve(port);
         });
+      } else {
+        reject(new Error("Failed to get port from server address"));
+      }
     });
+  });
 }
-export class AuggieMCPServer {
-    constructor(tools, PORT) {
-        this.httpServer = null;
-        this.serverPATH = "/mcp";
-        this.activeSockets = new Set();
-        // Wrap AI SDK tools to match Mastra's expected signature
-        // Mastra wraps the actual tool parameters in a 'context' property
-        // AI SDK tools expect: execute({ param1, param2 })
-        // Mastra passes: execute({ context: { param1, param2 }, runtimeContext, ... }, mcpContext)
-        const wrappedTools = {};
-        for (const [name, tool] of Object.entries(tools)) {
-            wrappedTools[name] = {
-                ...tool,
-                execute: async (args, mcpContext) => {
-                    // Extract the actual tool parameters from the 'context' property
-                    const toolParams = args?.context || args;
-                    // Call the original AI SDK tool's execute with the unwrapped parameters
-                    // AI SDK tools may expect (params, options) signature
-                    if (tool.execute) {
-                        return await tool.execute(toolParams, mcpContext);
-                    }
-                    throw new Error(`Tool ${name} does not have an execute function`);
-                },
-            };
+class AuggieMCPServer {
+  server;
+  httpServer = null;
+  PORT;
+  serverPATH = "/mcp";
+  activeSockets = /* @__PURE__ */ new Set();
+  constructor(tools, PORT) {
+    const wrappedTools = {};
+    for (const [name, tool] of Object.entries(tools)) {
+      wrappedTools[name] = {
+        ...tool,
+        execute: async (args, mcpContext) => {
+          const toolParams = args?.context || args;
+          if (tool.execute) {
+            return await tool.execute(
+              toolParams,
+              mcpContext
+            );
+          }
+          throw new Error(`Tool ${name} does not have an execute function`);
         }
-        this.server = new MCPServer({
-            name: "auggie-mcp",
-            version: "1.0.0",
-            tools: wrappedTools,
-        });
-        this.PORT = PORT;
+      };
     }
-    async start() {
-        // If PORT is undefined, find a free port
-        if (this.PORT === undefined) {
-            this.PORT = await findFreePort();
-        }
-        const httpServer = createHTTPServer(async (req, res) => {
-            await this.server.startHTTP({
-                url: new URL(req.url || "", `http://localhost:${this.PORT}`),
-                httpPath: this.serverPATH,
-                req,
-                res,
-                options: {
-                    sessionIdGenerator: undefined,
-                },
-            });
-        });
-        // Store the server instance
-        this.httpServer = httpServer;
-        // Track active connections for faster shutdown
-        httpServer.on("connection", (socket) => {
-            this.activeSockets.add(socket);
-            socket.on("close", () => {
-                this.activeSockets.delete(socket);
-            });
-        });
-        // Wait for the server to start listening before returning
-        await new Promise((resolve, reject) => {
-            httpServer.listen(this.PORT, () => {
-                resolve();
-            });
-            httpServer.on("error", reject);
-        });
-        const serverURL = new URL(this.serverPATH, `http://localhost:${this.PORT}`);
-        return serverURL.toString();
+    this.server = new MCPServer({
+      name: "auggie-mcp",
+      version: "1.0.0",
+      tools: wrappedTools
+    });
+    this.PORT = PORT;
+  }
+  async start() {
+    if (this.PORT === void 0) {
+      this.PORT = await findFreePort();
     }
-    async stop() {
-        // Close the HTTP server first with a timeout
-        if (this.httpServer) {
-            await Promise.race([
-                new Promise((resolve, reject) => {
-                    this.httpServer?.close((err) => {
-                        if (err)
-                            reject(err);
-                        else
-                            resolve();
-                    });
-                }),
-                // Timeout after 1 second
-                new Promise((resolve) => setTimeout(resolve, 1000)),
-            ]);
-            // Force close by destroying all connections if still open
-            if (this.httpServer.listening) {
-                this.httpServer.closeAllConnections?.();
-            }
-            this.httpServer = null;
-        }
-        // Then close the MCP server with a timeout
-        await Promise.race([
-            this.server.close(),
-            // Timeout after 1 second
-            new Promise((resolve) => setTimeout(resolve, 1000)),
-        ]);
+    const httpServer = createHTTPServer(
+      async (req, res) => {
+        await this.server.startHTTP({
+          url: new URL(req.url || "", `http://localhost:${this.PORT}`),
+          httpPath: this.serverPATH,
+          req,
+          res,
+          options: {
+            sessionIdGenerator: void 0
+          }
+        });
+      }
+    );
+    this.httpServer = httpServer;
+    httpServer.on("connection", (socket) => {
+      this.activeSockets.add(socket);
+      socket.on("close", () => {
+        this.activeSockets.delete(socket);
+      });
+    });
+    await new Promise((resolve, reject) => {
+      httpServer.listen(this.PORT, () => {
+        resolve();
+      });
+      httpServer.on("error", reject);
+    });
+    const serverURL = new URL(this.serverPATH, `http://localhost:${this.PORT}`);
+    return serverURL.toString();
+  }
+  async stop() {
+    if (this.httpServer) {
+      await Promise.race([
+        new Promise((resolve, reject) => {
+          this.httpServer?.close((err) => {
+            if (err) reject(err);
+            else resolve();
+          });
+        }),
+        // Timeout after 1 second
+        new Promise((resolve) => setTimeout(resolve, 1e3))
+      ]);
+      if (this.httpServer.listening) {
+        this.httpServer.closeAllConnections?.();
+      }
+      this.httpServer = null;
     }
+    await Promise.race([
+      this.server.close(),
+      // Timeout after 1 second
+      new Promise((resolve) => setTimeout(resolve, 1e3))
+    ]);
+  }
 }
-//# sourceMappingURL=sdk-mcp-server.js.map
+export {
+  AuggieMCPServer
+};

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

@@ -1,4 +1,5 @@
-import type { DirectContextOptions, DirectContextState, File, IndexingResult } from "./types";
+import { DirectContextOptions, DirectContextState, File, AddToIndexOptions, IndexingResult, IndexingProgress, ExportOptions } from './types.js';
+
 /**
  * Direct Context - API-based indexing with import/export state
  *
@@ -42,6 +43,26 @@ import type { DirectContextOptions, DirectContextState, File, IndexingResult } f
  * await context.search("query");   // files are now indexed
  * ```
  *
+ * **Option 3: Set a timeout**
+ * ```typescript
+ * // By default, waits indefinitely. Set a timeout if needed:
+ * await context.addToIndex(files, { timeout: 10 * 60 * 1000 }); // 10 minutes
+ * // or
+ * await context.waitForIndexing(10 * 60 * 1000);
+ * ```
+ *
+ * **Option 4: Track progress during indexing**
+ * ```typescript
+ * await context.addToIndex(files, {
+ *   onProgress: (progress) => {
+ *     console.log(`[${progress.stage}] Uploaded: ${progress.uploaded}/${progress.total}, Indexed: ${progress.indexed}/${progress.total}`);
+ *     if (progress.stage === 'uploading') {
+ *       console.log(`  Bytes uploaded: ${progress.bytesUploaded}`);
+ *     }
+ *   }
+ * });
+ * ```
+ *
  * Note: `search()` and `searchAndAsk()` do not wait for indexing automatically.
  *
  * ## State Persistence
@@ -58,7 +79,7 @@ import type { DirectContextOptions, DirectContextState, File, IndexingResult } f
  * const context = await DirectContext.importFromFile("state.json");
  * ```
  */
-export declare class DirectContext {
+declare class DirectContext {
     private static readonly MAX_FILE_SIZE_BYTES;
     private static readonly MAX_BATCH_UPLOAD_SIZE;
     private static readonly MAX_BATCH_CONTENT_BYTES;
@@ -70,18 +91,23 @@ export declare class DirectContext {
     /**
      * State management:
      *
-     * blobMap: Tracks all files that have been uploaded (path -> blobName).
+     * blobMap: Tracks all files that have been uploaded (path -> serverBlobId).
      *          This includes both indexed and non-indexed blobs.
      *          Also, includes both checkpointed and non-checkpointed blobs.
+     *          The server blob ID is the authoritative identifier.
+     *
+     * clientBlobMap: Tracks client-computed blob IDs (path -> clientBlobId).
+     *                Used for detecting unchanged files on the client side.
+     *                May differ from serverBlobId due to encoding differences.
      *
      * checkpointId: The current checkpoint ID from the backend.
      *               Checkpoints are named snapshots of the blob set for performance.
      *               Updated after each successful checkpoint operation.
      *
-     * pendingAdded: Blob names that have been uploaded but not yet checkpointed.
+     * pendingAdded: Blob IDs that have been uploaded but not yet checkpointed.
      *               Accumulated until CHECKPOINT_THRESHOLD is reached.
      *
-     * pendingDeleted: Blob names that have been removed but not yet checkpointed.
+     * pendingDeleted: Blob IDs that have been removed but not yet checkpointed.
      *                 Accumulated until CHECKPOINT_THRESHOLD is reached.
      *
      * Note: Checkpointing and indexing are independent operations.
@@ -89,9 +115,11 @@ export declare class DirectContext {
      *       both, or neither.
      */
     private readonly blobMap;
+    private readonly clientBlobMap;
     private checkpointId?;
     private pendingAdded;
     private pendingDeleted;
+    private isSearchOnly;
     private readonly mutex;
     private readonly pollingMutex;
     /**
@@ -133,12 +161,18 @@ export declare class DirectContext {
      * Log a debug message if debug mode is enabled
      */
     private log;
+    /**
+     * Create a progress context for an operation
+     */
+    private createProgressContext;
     /**
      * Create a checkpoint if threshold is reached
      */
     private maybeCheckpoint;
     /**
      * Get the list of indexed file paths
+     *
+     * @throws Error if the context was imported from search-only state
      */
     getIndexedPaths(): string[];
     /**
@@ -151,22 +185,23 @@ export declare class DirectContext {
      * @param files - Array of files to add to the index
      * @param options - Optional configuration
      * @param options.waitForIndexing - If true (default), waits for the newly added files to be indexed before returning
+     * @param options.timeout - Timeout in milliseconds for indexing operation (default: undefined = no timeout)
+     * @param options.onProgress - Optional callback to receive progress updates
      * @returns Result indicating which files were newly uploaded vs already uploaded
+     * @throws Error if the context was imported from search-only state
      */
-    addToIndex(files: File[], options?: {
-        waitForIndexing?: boolean;
-    }): Promise<IndexingResult>;
+    addToIndex(files: File[], options?: AddToIndexOptions): Promise<IndexingResult>;
     /**
-     * Check which blobs are missing or not yet indexed on the server
+     * Find blobs that are missing or not yet indexed on the backend (detailed result)
+     * Batches requests in chunks of 1000
      *
      * @param blobNames - Array of blob names to check
-     * @param includeNonIndexed - If true, includes blobs that are uploaded but not yet indexed.
-     *                            If false, only returns blobs that need to be uploaded.
-     * @returns Array of blob names that are either missing or not indexed (depending on flag)
+     * @returns Object with unknownBlobNames and nonindexedBlobNames arrays
      */
-    private findMissingBlobs;
+    private findMissingBlobsDetailed;
     /**
      * Upload files in batches respecting backend limits
+     * Returns a map of client-computed blob IDs to backend-returned blob IDs
      */
     private batchUploadFiles;
     /**
@@ -182,16 +217,14 @@ export declare class DirectContext {
      * Handle replacing an existing blob (track deletion of old blob)
      */
     private handleBlobReplacement;
-    /**
-     * Categorize files into newly uploaded vs already on server based on server response
-     */
-    private categorizeFiles;
     /**
      * Internal implementation of addToIndex
      */
     private doAddToIndex;
     /**
      * Remove paths from the index
+     *
+     * @throws Error if the context was imported from search-only state
      */
     removeFromIndex(paths: string[]): Promise<void>;
     /**
@@ -211,6 +244,10 @@ export declare class DirectContext {
      *
      * This method is serialized via pollingMutex to prevent unbounded concurrent
      * polling requests to the backend.
+     *
+     * @param blobNames - Array of blob names to wait for
+     * @param timeoutMs - Timeout in milliseconds (default: undefined = no timeout)
+     * @param ctx - Progress context for reporting
      */
     private waitForSpecificBlobs;
     /**
@@ -219,10 +256,12 @@ export declare class DirectContext {
      * This method polls the backend until all files that have been added to the index
      * are confirmed to be indexed and searchable.
      *
+     * @param timeout - Timeout in milliseconds (default: undefined = no timeout)
+     * @param onProgress - Optional callback to receive progress updates
      * @returns Promise that resolves when all files are indexed
-     * @throws Error if indexing times out (default: 10 minutes)
+     * @throws Error if indexing times out (only when timeout is specified)
      */
-    waitForIndexing(): Promise<void>;
+    waitForIndexing(timeout?: number, onProgress?: (progress: IndexingProgress) => void): Promise<void>;
     /**
      * Search the codebase using natural language and return formatted results.
      *
@@ -269,15 +308,36 @@ export declare class DirectContext {
     searchAndAsk(searchQuery: string, prompt?: string): Promise<string>;
     /**
      * Export the current state to a JSON object
+     *
+     * @param options Export options
+     * @param options.mode Export mode - 'full' (default) includes all blob information,
+     *                     'search-only' excludes blobs array for minimal storage
+     * @returns The exported state object
+     *
+     * @example
+     * ```typescript
+     * // Full export (default) - supports all operations
+     * const fullState = context.export();
+     * const fullState = context.export({ mode: 'full' });
+     *
+     * // Search-only export - much smaller, only supports search operations
+     * const searchState = context.export({ mode: 'search-only' });
+     * ```
      */
-    export(): DirectContextState;
+    export(options?: ExportOptions): DirectContextState;
     /**
      * Internal method to import state from a JSON object
      */
     private doImport;
     /**
      * Export state to a file (Node.js only)
+     *
+     * @param filePath Path to save the state file
+     * @param options Export options
+     * @param options.mode Export mode - 'full' (default) includes all blob information,
+     *                     'search-only' excludes blobs array for minimal storage
      */
-    exportToFile(filePath: string): Promise<void>;
+    exportToFile(filePath: string, options?: ExportOptions): Promise<void>;
 }
-//# sourceMappingURL=direct-context.d.ts.map
+
+export { DirectContext };