@augmentcode/auggie-sdk 0.1.9 → 0.1.11

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, IndexingResult } from './types.js';
+
 /**
  * Direct Context - API-based indexing with import/export state
  *
@@ -58,7 +59,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 +71,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,6 +95,7 @@ export declare class DirectContext {
      *       both, or neither.
      */
     private readonly blobMap;
+    private readonly clientBlobMap;
     private checkpointId?;
     private pendingAdded;
     private pendingDeleted;
@@ -157,16 +164,16 @@ export declare class DirectContext {
         waitForIndexing?: boolean;
     }): 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,10 +189,6 @@ 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
      */
@@ -280,4 +283,5 @@ export declare class DirectContext {
      */
     exportToFile(filePath: string): Promise<void>;
 }
-//# sourceMappingURL=direct-context.d.ts.map
+
+export { DirectContext };