@augmentcode/auggie-sdk 0.1.10 → 0.1.12

package/dist/context/direct-context.js

@@ -1,594 +1,707 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { Mutex } from "async-mutex";
-import { ContextAPIClient } from "./internal/api-client";
-import { BlobNameCalculator } from "./internal/blob-name-calculator";
-import { chatWithRetry } from "./internal/chat-utils";
-import { resolveCredentials } from "./internal/credentials";
-import { formatSearchPrompt } from "./internal/search-utils";
-/**
- * Direct Context - API-based indexing with import/export state
- *
- * ⚠️ **EXPERIMENTAL API** - This API is experimental and may change without notice.
- *
- * @experimental
- *
- * This class provides explicit file indexing via API calls with the ability
- * to export and restore state to avoid re-indexing between sessions.
- *
- * ## Creating a Context
- *
- * **Start fresh:**
- * ```typescript
- * const context = await DirectContext.create();
- * ```
- *
- * **Restore from saved state:**
- * ```typescript
- * const context = await DirectContext.importFromFile("state.json");
- * // or
- * const context = await DirectContext.import(stateObject);
- * ```
- *
- * ## Indexing Flow
- *
- * Files are uploaded to the backend and then indexed asynchronously. You have
- * explicit control over when to wait for indexing:
- *
- * **Option 1: Wait after each upload**
- * ```typescript
- * await context.addToIndex(files); // waits for indexing by default
- * await context.search("query");   // files are already indexed
- * ```
- *
- * **Option 2: Batch uploads then wait**
- * ```typescript
- * await context.addToIndex(files1, { waitForIndexing: false });
- * await context.addToIndex(files2, { waitForIndexing: false });
- * await context.waitForIndexing(); // wait for all files to be indexed
- * await context.search("query");   // files are now indexed
- * ```
- *
- * Note: `search()` and `searchAndAsk()` do not wait for indexing automatically.
- *
- * ## State Persistence
- *
- * **Export state:**
- * ```typescript
- * const state = context.export();
- * // or save to file
- * await context.exportToFile("state.json");
- * ```
- *
- * **Import state:**
- * ```typescript
- * const context = await DirectContext.importFromFile("state.json");
- * ```
- */
-export class DirectContext {
-    /**
-     * Create and initialize a new DirectContext instance
-     *
-     * Authentication priority:
-     * 1. options.apiKey / options.apiUrl
-     * 2. AUGMENT_API_TOKEN / AUGMENT_API_URL environment variables
-     * 3. ~/.augment/session.json (created by `auggie login`)
-     *
-     * @param options Configuration options
-     * @returns Promise that resolves to a DirectContext instance
-     */
-    static async create(options = {}) {
-        const { apiKey, apiUrl } = await resolveCredentials(options);
-        return new DirectContext(apiKey, apiUrl, options.debug ?? false);
+import { ContextAPIClient } from "./internal/api-client.js";
+import { BlobNameCalculator } from "./internal/blob-name-calculator.js";
+import { chatWithRetry } from "./internal/chat-utils.js";
+import { resolveCredentials } from "./internal/credentials.js";
+import { formatSearchPrompt } from "./internal/search-utils.js";
+class DirectContext {
+  static MAX_FILE_SIZE_BYTES = 1048576;
+  // 1MB
+  static MAX_BATCH_UPLOAD_SIZE = 1e3;
+  static MAX_BATCH_CONTENT_BYTES = 2 * 1024 * 1024;
+  // 2MB
+  static MAX_FIND_MISSING_SIZE = 1e3;
+  static CHECKPOINT_THRESHOLD = 1e3;
+  apiClient;
+  blobCalculator;
+  debug;
+  /**
+   * State management:
+   *
+   * 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 IDs that have been uploaded but not yet checkpointed.
+   *               Accumulated until CHECKPOINT_THRESHOLD is reached.
+   *
+   * pendingDeleted: Blob IDs that have been removed but not yet checkpointed.
+   *                 Accumulated until CHECKPOINT_THRESHOLD is reached.
+   *
+   * Note: Checkpointing and indexing are independent operations.
+   *       A blob can be checkpointed but not indexed, indexed but not checkpointed,
+   *       both, or neither.
+   */
+  blobMap = /* @__PURE__ */ new Map();
+  clientBlobMap = /* @__PURE__ */ new Map();
+  checkpointId;
+  pendingAdded = /* @__PURE__ */ new Set();
+  pendingDeleted = /* @__PURE__ */ new Set();
+  // Track if this instance was imported from search-only state
+  isSearchOnly = false;
+  // Mutex for serializing state-modifying operations (upload, checkpoint, etc.)
+  mutex = new Mutex();
+  // Mutex for serializing polling operations to prevent unbounded concurrent requests
+  // to the backend's findMissing endpoint. Without this, concurrent addToIndex() calls
+  // could result in many simultaneous polling loops hitting the backend.
+  pollingMutex = new Mutex();
+  /**
+   * Create and initialize a new DirectContext instance
+   *
+   * Authentication priority:
+   * 1. options.apiKey / options.apiUrl
+   * 2. AUGMENT_API_TOKEN / AUGMENT_API_URL environment variables
+   * 3. ~/.augment/session.json (created by `auggie login`)
+   *
+   * @param options Configuration options
+   * @returns Promise that resolves to a DirectContext instance
+   */
+  static async create(options = {}) {
+    const { apiKey, apiUrl } = await resolveCredentials(options);
+    return new DirectContext(apiKey, apiUrl, options.debug ?? false);
+  }
+  /**
+   * Import a DirectContext instance from a saved state object
+   *
+   * @param state The state object to restore from
+   * @param options Configuration options
+   * @returns Promise that resolves to a DirectContext instance with restored state
+   */
+  static async import(state, options = {}) {
+    const { apiKey, apiUrl } = await resolveCredentials(options);
+    const instance = new DirectContext(apiKey, apiUrl, options.debug ?? false);
+    await instance.doImport(state);
+    return instance;
+  }
+  /**
+   * Import a DirectContext instance from a saved state file (Node.js only)
+   *
+   * @param filePath Path to the state file
+   * @param options Configuration options
+   * @returns Promise that resolves to a DirectContext instance with restored state
+   */
+  static async importFromFile(filePath, options = {}) {
+    const content = await readFile(filePath, "utf-8");
+    const state = JSON.parse(content);
+    return DirectContext.import(state, options);
+  }
+  /**
+   * Private constructor - use DirectContext.create() instead
+   * @param apiKey API key for authentication
+   * @param apiUrl API URL for the tenant
+   * @param debug Enable debug logging
+   */
+  constructor(apiKey, apiUrl, debug) {
+    this.debug = debug;
+    this.apiClient = new ContextAPIClient({
+      apiKey,
+      apiUrl,
+      debug
+    });
+    this.blobCalculator = new BlobNameCalculator(
+      DirectContext.MAX_FILE_SIZE_BYTES
+    );
+  }
+  /**
+   * Log a debug message if debug mode is enabled
+   */
+  log(message) {
+    if (this.debug) {
+      console.log(`[DirectContext] ${message}`);
     }
-    /**
-     * Import a DirectContext instance from a saved state object
-     *
-     * @param state The state object to restore from
-     * @param options Configuration options
-     * @returns Promise that resolves to a DirectContext instance with restored state
-     */
-    static async import(state, options = {}) {
-        const { apiKey, apiUrl } = await resolveCredentials(options);
-        const instance = new DirectContext(apiKey, apiUrl, options.debug ?? false);
-        await instance.doImport(state);
-        return instance;
+  }
+  /**
+   * Create a progress context for an operation
+   */
+  createProgressContext(onProgress, total, startedAt) {
+    return { onProgress, total, startedAt, uploaded: 0, indexed: 0 };
+  }
+  /**
+   * Create a checkpoint if threshold is reached
+   */
+  async maybeCheckpoint() {
+    const pendingChanges = this.pendingAdded.size + this.pendingDeleted.size;
+    if (pendingChanges < DirectContext.CHECKPOINT_THRESHOLD) {
+      this.log(
+        `Skipping checkpoint: ${pendingChanges} pending changes (threshold: ${DirectContext.CHECKPOINT_THRESHOLD})`
+      );
+      return;
     }
-    /**
-     * Import a DirectContext instance from a saved state file (Node.js only)
-     *
-     * @param filePath Path to the state file
-     * @param options Configuration options
-     * @returns Promise that resolves to a DirectContext instance with restored state
-     */
-    static async importFromFile(filePath, options = {}) {
-        const content = await readFile(filePath, "utf-8");
-        const state = JSON.parse(content);
-        return DirectContext.import(state, options);
+    const addedBlobs = Array.from(this.pendingAdded);
+    const deletedBlobs = Array.from(this.pendingDeleted);
+    this.log(
+      `Creating checkpoint: ${addedBlobs.length} added, ${deletedBlobs.length} deleted blobs`
+    );
+    const blobs = {
+      checkpointId: this.checkpointId,
+      addedBlobs: addedBlobs.sort(),
+      deletedBlobs: deletedBlobs.sort()
+    };
+    const result = await this.apiClient.checkpointBlobs(blobs);
+    this.checkpointId = result.newCheckpointId;
+    this.log(`Checkpoint created: ${this.checkpointId}`);
+    this.pendingAdded.clear();
+    this.pendingDeleted.clear();
+  }
+  /**
+   * Get the list of indexed file paths
+   *
+   * @throws Error if the context was imported from search-only state
+   */
+  getIndexedPaths() {
+    if (this.isSearchOnly) {
+      throw new Error(
+        "Cannot call getIndexedPaths() on a context imported from search-only state. This operation requires full state with blob information. Import from a full state export instead."
+      );
     }
-    /**
-     * Private constructor - use DirectContext.create() instead
-     * @param apiKey API key for authentication
-     * @param apiUrl API URL for the tenant
-     * @param debug Enable debug logging
-     */
-    constructor(apiKey, apiUrl, debug) {
-        /**
-         * State management:
-         *
-         * blobMap: Tracks all files that have been uploaded (path -> blobName).
-         *          This includes both indexed and non-indexed blobs.
-         *          Also, includes both checkpointed and non-checkpointed blobs.
-         *
-         * 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.
-         *               Accumulated until CHECKPOINT_THRESHOLD is reached.
-         *
-         * pendingDeleted: Blob names that have been removed but not yet checkpointed.
-         *                 Accumulated until CHECKPOINT_THRESHOLD is reached.
-         *
-         * Note: Checkpointing and indexing are independent operations.
-         *       A blob can be checkpointed but not indexed, indexed but not checkpointed,
-         *       both, or neither.
-         */
-        this.blobMap = new Map();
-        this.pendingAdded = new Set();
-        this.pendingDeleted = new Set();
-        // Mutex for serializing state-modifying operations (upload, checkpoint, etc.)
-        this.mutex = new Mutex();
-        // Mutex for serializing polling operations to prevent unbounded concurrent requests
-        // to the backend's findMissing endpoint. Without this, concurrent addToIndex() calls
-        // could result in many simultaneous polling loops hitting the backend.
-        this.pollingMutex = new Mutex();
-        this.debug = debug;
-        // Initialize API client
-        this.apiClient = new ContextAPIClient({
-            apiKey,
-            apiUrl,
-            debug,
-        });
-        // Initialize blob calculator
-        this.blobCalculator = new BlobNameCalculator(DirectContext.MAX_FILE_SIZE_BYTES);
+    return Array.from(this.blobMap.keys());
+  }
+  /**
+   * Add files to the index by uploading them to the backend.
+   *
+   * By default, this method waits for the uploaded files to be fully indexed
+   * on the backend before returning. Set `waitForIndexing: false` to return
+   * immediately after upload completes (indexing will continue asynchronously).
+   *
+   * @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
+   */
+  async addToIndex(files, options) {
+    if (this.isSearchOnly) {
+      throw new Error(
+        "Cannot call addToIndex() on a context imported from search-only state. This operation requires full state with blob information for deduplication. Import from a full state export instead, or create a new context with DirectContext.create()."
+      );
     }
-    /**
-     * Log a debug message if debug mode is enabled
-     */
-    log(message) {
-        if (this.debug) {
-            console.log(`[DirectContext] ${message}`);
-        }
+    const waitForIndexing = options?.waitForIndexing ?? true;
+    const timeout = options?.timeout;
+    const ctx = this.createProgressContext(
+      options?.onProgress,
+      files.length,
+      /* @__PURE__ */ new Date()
+    );
+    const result = await this.mutex.runExclusive(
+      () => this.doAddToIndex(files, ctx)
+    );
+    if (waitForIndexing && result.newlyUploaded.length > 0) {
+      const newlyUploadedBlobNames = result.newlyUploaded.map((path) => this.blobMap.get(path)).filter((blobName) => blobName !== void 0);
+      await this.waitForSpecificBlobs(newlyUploadedBlobNames, timeout, ctx);
     }
-    /**
-     * Create a checkpoint if threshold is reached
-     */
-    async maybeCheckpoint() {
-        const pendingChanges = this.pendingAdded.size + this.pendingDeleted.size;
-        if (pendingChanges < DirectContext.CHECKPOINT_THRESHOLD) {
-            this.log(`Skipping checkpoint: ${pendingChanges} pending changes (threshold: ${DirectContext.CHECKPOINT_THRESHOLD})`);
-            return;
+    return result;
+  }
+  /**
+   * 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
+   * @returns Object with unknownBlobNames and nonindexedBlobNames arrays
+   */
+  async findMissingBlobsDetailed(blobNames) {
+    const allUnknown = [];
+    const allNonIndexed = [];
+    for (let i = 0; i < blobNames.length; i += DirectContext.MAX_FIND_MISSING_SIZE) {
+      const batch = blobNames.slice(i, i + DirectContext.MAX_FIND_MISSING_SIZE);
+      const result = await this.apiClient.findMissing(batch);
+      allUnknown.push(...result.unknownBlobNames);
+      allNonIndexed.push(...result.nonindexedBlobNames);
+    }
+    return {
+      unknownBlobNames: allUnknown,
+      nonindexedBlobNames: allNonIndexed
+    };
+  }
+  /**
+   * Upload files in batches respecting backend limits
+   * Returns a map of client-computed blob IDs to backend-returned blob IDs
+   */
+  async batchUploadFiles(filesToUpload, ctx) {
+    const batches = [];
+    let currentBatch = [];
+    let currentBatchSize = 0;
+    for (const file of filesToUpload) {
+      const fileSize = Buffer.byteLength(file.text, "utf-8");
+      const wouldExceedCount = currentBatch.length >= DirectContext.MAX_BATCH_UPLOAD_SIZE;
+      const wouldExceedSize = currentBatchSize + fileSize > DirectContext.MAX_BATCH_CONTENT_BYTES;
+      if (wouldExceedCount || wouldExceedSize) {
+        if (currentBatch.length > 0) {
+          batches.push(currentBatch);
         }
-        // Get blob names for checkpoint (both sets already contain blob names)
-        const addedBlobs = Array.from(this.pendingAdded);
-        const deletedBlobs = Array.from(this.pendingDeleted);
-        this.log(`Creating checkpoint: ${addedBlobs.length} added, ${deletedBlobs.length} deleted blobs`);
-        const blobs = {
-            checkpointId: this.checkpointId,
-            addedBlobs: addedBlobs.sort(),
-            deletedBlobs: deletedBlobs.sort(),
-        };
-        const result = await this.apiClient.checkpointBlobs(blobs);
-        this.checkpointId = result.newCheckpointId;
-        this.log(`Checkpoint created: ${this.checkpointId}`);
-        // Clear pending changes after successful checkpoint
-        this.pendingAdded.clear();
-        this.pendingDeleted.clear();
+        currentBatch = [file];
+        currentBatchSize = fileSize;
+      } else {
+        currentBatch.push(file);
+        currentBatchSize += fileSize;
+      }
     }
-    /**
-     * Get the list of indexed file paths
-     */
-    getIndexedPaths() {
-        return Array.from(this.blobMap.keys());
+    if (currentBatch.length > 0) {
+      batches.push(currentBatch);
     }
-    /**
-     * Add files to the index by uploading them to the backend.
-     *
-     * By default, this method waits for the uploaded files to be fully indexed
-     * on the backend before returning. Set `waitForIndexing: false` to return
-     * immediately after upload completes (indexing will continue asynchronously).
-     *
-     * @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
-     * @returns Result indicating which files were newly uploaded vs already uploaded
-     */
-    async addToIndex(files, options) {
-        const waitForIndexing = options?.waitForIndexing ?? true;
-        const result = await this.mutex.runExclusive(() => this.doAddToIndex(files));
-        if (waitForIndexing && result.newlyUploaded.length > 0) {
-            // Wait for the newly uploaded files to be indexed
-            // These paths are guaranteed to be in blobMap since they were just added in doAddToIndex
-            const newlyUploadedBlobNames = result.newlyUploaded
-                .map((path) => this.blobMap.get(path))
-                .filter((blobName) => blobName !== undefined);
-            await this.waitForSpecificBlobs(newlyUploadedBlobNames);
+    const blobIdMap = /* @__PURE__ */ new Map();
+    let filesProcessed = 0;
+    let bytesUploaded = 0;
+    for (const batch of batches) {
+      const result = await this.apiClient.batchUpload(batch);
+      for (const [i, batchItem] of batch.entries()) {
+        const clientBlobId = batchItem.blobName;
+        const backendBlobId = result.blobNames[i];
+        if (backendBlobId) {
+          blobIdMap.set(clientBlobId, backendBlobId);
         }
-        return result;
+      }
+      filesProcessed += batch.length;
+      ctx.uploaded = filesProcessed;
+      bytesUploaded += batch.reduce(
+        (sum, file) => sum + Buffer.byteLength(file.text, "utf-8"),
+        0
+      );
+      if (ctx.onProgress) {
+        ctx.onProgress({
+          stage: "uploading",
+          uploaded: ctx.uploaded,
+          indexed: ctx.indexed,
+          total: ctx.total,
+          currentFile: batch.at(-1)?.pathName,
+          bytesUploaded,
+          startedAt: ctx.startedAt
+        });
+      }
     }
-    /**
-     * Check which blobs are missing or not yet indexed on the server
-     *
-     * @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)
-     */
-    async findMissingBlobs(blobNames, includeNonIndexed = false) {
-        const allMissing = [];
-        for (let i = 0; i < blobNames.length; i += DirectContext.MAX_FIND_MISSING_SIZE) {
-            const batch = blobNames.slice(i, i + DirectContext.MAX_FIND_MISSING_SIZE);
-            const result = await this.apiClient.findMissing(batch);
-            allMissing.push(...result.unknownBlobNames);
-            if (includeNonIndexed) {
-                allMissing.push(...result.nonindexedBlobNames);
-            }
-        }
-        return allMissing;
+    return blobIdMap;
+  }
+  /**
+   * Validate that all files are within size limits
+   */
+  validateFileSizes(files) {
+    for (const file of files) {
+      const sizeBytes = Buffer.byteLength(file.contents, "utf-8");
+      if (sizeBytes > DirectContext.MAX_FILE_SIZE_BYTES) {
+        throw new Error(
+          `File ${file.path} is too large (${sizeBytes} bytes). Maximum size is ${DirectContext.MAX_FILE_SIZE_BYTES} bytes (1MB).`
+        );
+      }
     }
-    /**
-     * Upload files in batches respecting backend limits
-     */
-    async batchUploadFiles(filesToUpload) {
-        const batches = [];
-        let currentBatch = [];
-        let currentBatchSize = 0;
-        for (const file of filesToUpload) {
-            const fileSize = Buffer.byteLength(file.text, "utf-8");
-            const wouldExceedCount = currentBatch.length >= DirectContext.MAX_BATCH_UPLOAD_SIZE;
-            const wouldExceedSize = currentBatchSize + fileSize > DirectContext.MAX_BATCH_CONTENT_BYTES;
-            if (wouldExceedCount || wouldExceedSize) {
-                if (currentBatch.length > 0) {
-                    batches.push(currentBatch);
-                }
-                currentBatch = [file];
-                currentBatchSize = fileSize;
-            }
-            else {
-                currentBatch.push(file);
-                currentBatchSize += fileSize;
-            }
+  }
+  /**
+   * Calculate blob names and prepare upload data for files
+   * Returns files that need uploading, new blob entries, and already uploaded files
+   */
+  prepareBlobsForUpload(files) {
+    const filesToUpload = [];
+    const newBlobEntries = [];
+    const alreadyUploaded = [];
+    for (const file of files) {
+      const clientBlobId = this.blobCalculator.calculate(
+        file.path,
+        file.contents
+      );
+      if (clientBlobId) {
+        const existingClientBlobId = this.clientBlobMap.get(file.path);
+        if (existingClientBlobId && existingClientBlobId === clientBlobId) {
+          alreadyUploaded.push(file.path);
+          continue;
         }
-        if (currentBatch.length > 0) {
-            batches.push(currentBatch);
-        }
-        for (const batch of batches) {
-            await this.apiClient.batchUpload(batch);
+        const existingServerBlobId = this.blobMap.get(file.path);
+        if (existingServerBlobId) {
+          this.handleBlobReplacement(existingServerBlobId);
         }
+        newBlobEntries.push([file.path, clientBlobId]);
+        filesToUpload.push({
+          blobName: clientBlobId,
+          // API expects 'blobName' field
+          pathName: file.path,
+          text: file.contents,
+          metadata: []
+        });
+      }
     }
-    /**
-     * Validate that all files are within size limits
-     */
-    validateFileSizes(files) {
-        for (const file of files) {
-            const sizeBytes = Buffer.byteLength(file.contents, "utf-8");
-            if (sizeBytes > DirectContext.MAX_FILE_SIZE_BYTES) {
-                throw new Error(`File ${file.path} is too large (${sizeBytes} bytes). Maximum size is ${DirectContext.MAX_FILE_SIZE_BYTES} bytes (1MB).`);
-            }
-        }
+    return { filesToUpload, newBlobEntries, alreadyUploaded };
+  }
+  /**
+   * Handle replacing an existing blob (track deletion of old blob)
+   */
+  handleBlobReplacement(oldBlobName) {
+    if (this.pendingAdded.has(oldBlobName)) {
+      this.pendingAdded.delete(oldBlobName);
+    } else {
+      this.pendingDeleted.add(oldBlobName);
     }
-    /**
-     * Calculate blob names and prepare upload data for files
-     * Returns files that need uploading, new blob entries, and already uploaded files
-     */
-    prepareBlobsForUpload(files) {
-        const filesToUpload = [];
-        const newBlobEntries = [];
-        const alreadyUploaded = [];
-        for (const file of files) {
-            const blobName = this.blobCalculator.calculate(file.path, file.contents);
-            if (blobName) {
-                const existingBlobName = this.blobMap.get(file.path);
-                if (existingBlobName && existingBlobName === blobName) {
-                    // File content hasn't changed
-                    alreadyUploaded.push(file.path);
-                    continue;
-                }
-                // Handle file replacement: if a file with this path already exists
-                if (existingBlobName) {
-                    this.handleBlobReplacement(existingBlobName);
-                }
-                newBlobEntries.push([file.path, blobName]);
-                filesToUpload.push({
-                    blobName,
-                    pathName: file.path,
-                    text: file.contents,
-                    metadata: [],
-                });
-            }
-        }
-        return { filesToUpload, newBlobEntries, alreadyUploaded };
+  }
+  /**
+   * Internal implementation of addToIndex
+   */
+  async doAddToIndex(files, ctx) {
+    this.log(`Adding ${files.length} files to index`);
+    this.validateFileSizes(files);
+    const { filesToUpload, newBlobEntries, alreadyUploaded } = this.prepareBlobsForUpload(files);
+    if (newBlobEntries.length === 0) {
+      return { newlyUploaded: [], alreadyUploaded };
     }
-    /**
-     * Handle replacing an existing blob (track deletion of old blob)
-     */
-    handleBlobReplacement(oldBlobName) {
-        // Check if the old blob is in pendingAdded
-        if (this.pendingAdded.has(oldBlobName)) {
-            // Old blob was added in this session, just remove it from pendingAdded
-            this.pendingAdded.delete(oldBlobName);
-        }
-        else {
-            // Old blob was from a previous checkpoint, add to deletedBlobs
-            this.pendingDeleted.add(oldBlobName);
-        }
+    const blobNamesToCheck = newBlobEntries.map(
+      ([_, clientBlobId]) => clientBlobId
+    );
+    this.log(`Checking ${blobNamesToCheck.length} blobs with server`);
+    const result = await this.findMissingBlobsDetailed(blobNamesToCheck);
+    const missingBlobSet = /* @__PURE__ */ new Set([
+      ...result.unknownBlobNames,
+      ...result.nonindexedBlobNames
+    ]);
+    this.log(`Server is missing ${missingBlobSet.size} blobs`);
+    const filesToActuallyUpload = filesToUpload.filter(
+      (file) => missingBlobSet.has(file.blobName)
+    );
+    const blobIdMap = /* @__PURE__ */ new Map();
+    if (filesToActuallyUpload.length > 0) {
+      this.log(`Uploading ${filesToActuallyUpload.length} files to backend`);
+      const uploadedBlobIdMap = await this.batchUploadFiles(
+        filesToActuallyUpload,
+        ctx
+      );
+      this.log("Upload complete");
+      for (const [clientId, serverId] of uploadedBlobIdMap) {
+        blobIdMap.set(clientId, serverId);
+      }
     }
-    /**
-     * Categorize files into newly uploaded vs already on server based on server response
-     */
-    categorizeFiles(newBlobEntries, // [path, blobName]
-    missingBlobSet) {
-        const newlyUploaded = [];
-        const alreadyOnServer = [];
-        for (const [path, blobName] of newBlobEntries) {
-            if (missingBlobSet.has(blobName)) {
-                newlyUploaded.push(path);
-            }
-            else {
-                alreadyOnServer.push(path);
-            }
+    const newlyUploaded = [];
+    const alreadyOnServer = [];
+    for (const [path, clientBlobId] of newBlobEntries) {
+      const serverBlobId = blobIdMap.get(clientBlobId) ?? clientBlobId;
+      this.pendingAdded.add(serverBlobId);
+      this.pendingDeleted.delete(serverBlobId);
+      this.blobMap.set(path, serverBlobId);
+      this.clientBlobMap.set(path, clientBlobId);
+      if (missingBlobSet.has(clientBlobId)) {
+        newlyUploaded.push(path);
+      } else {
+        alreadyOnServer.push(path);
+      }
+    }
+    await this.maybeCheckpoint();
+    return {
+      newlyUploaded,
+      alreadyUploaded: [...alreadyUploaded, ...alreadyOnServer]
+    };
+  }
+  /**
+   * Remove paths from the index
+   *
+   * @throws Error if the context was imported from search-only state
+   */
+  async removeFromIndex(paths) {
+    if (this.isSearchOnly) {
+      throw new Error(
+        "Cannot call removeFromIndex() on a context imported from search-only state. This operation requires full state with blob information. Import from a full state export instead."
+      );
+    }
+    return await this.mutex.runExclusive(() => this.doRemoveFromIndex(paths));
+  }
+  /**
+   * Internal implementation of removeFromIndex
+   */
+  async doRemoveFromIndex(paths) {
+    for (const path of paths) {
+      const serverBlobId = this.blobMap.get(path);
+      if (serverBlobId) {
+        if (this.pendingAdded.has(serverBlobId)) {
+          this.pendingAdded.delete(serverBlobId);
+        } else {
+          this.pendingDeleted.add(serverBlobId);
         }
-        return { newlyUploaded, alreadyOnServer };
+        this.blobMap.delete(path);
+        this.clientBlobMap.delete(path);
+      }
     }
-    /**
-     * Internal implementation of addToIndex
-     */
-    async doAddToIndex(files) {
-        this.log(`Adding ${files.length} files to index`);
-        // Validate file sizes
-        this.validateFileSizes(files);
-        // Calculate blob names and prepare uploads
-        const { filesToUpload, newBlobEntries, alreadyUploaded } = this.prepareBlobsForUpload(files);
-        if (newBlobEntries.length === 0) {
-            return { newlyUploaded: [], alreadyUploaded };
+    await this.maybeCheckpoint();
+  }
+  /**
+   * Clear the entire index
+   */
+  async clearIndex() {
+    return await this.mutex.runExclusive(() => this.doClearIndex());
+  }
+  /**
+   * Internal implementation of clearIndex
+   */
+  doClearIndex() {
+    this.log(`Clearing index (${this.blobMap.size} files)`);
+    this.checkpointId = void 0;
+    this.blobMap.clear();
+    this.clientBlobMap.clear();
+    this.pendingAdded.clear();
+    this.pendingDeleted.clear();
+    this.log("Index cleared");
+    return Promise.resolve();
+  }
+  /**
+   * Wait for specific blobs to be indexed on the backend
+   *
+   * 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
+   */
+  waitForSpecificBlobs(blobNames, timeoutMs, ctx) {
+    return this.pollingMutex.runExclusive(async () => {
+      if (blobNames.length === 0) {
+        this.log("No blobs to wait for");
+        return;
+      }
+      const timeoutMsg = timeoutMs ? `timeout: ${timeoutMs / 1e3}s` : "no timeout";
+      this.log(
+        `Waiting for ${blobNames.length} blobs to be indexed on backend (${timeoutMsg})`
+      );
+      const initialPollIntervalMs = 3e3;
+      const backoffThresholdMs = 6e4;
+      const backoffPollIntervalMs = 6e4;
+      const startTime = Date.now();
+      while (true) {
+        const result = await this.findMissingBlobsDetailed(blobNames);
+        const unknownBlobs = result.unknownBlobNames.filter(
+          (id) => this.pendingAdded.has(id)
+        );
+        if (unknownBlobs.length > 0) {
+          this.log(
+            `WARNING: Backend doesn't recognize ${unknownBlobs.length} blob IDs. This may indicate a blob ID mismatch.`
+          );
+          this.log(`Unknown blob IDs: ${unknownBlobs.join(", ")}`);
+          this.log(
+            "This is unexpected but not necessarily an error. Continuing to poll..."
+          );
         }
-        // Check which blobs the server already has
-        const blobNamesToCheck = newBlobEntries.map(([_, blobName]) => blobName);
-        this.log(`Checking ${blobNamesToCheck.length} blobs with server`);
-        const missingBlobNames = await this.findMissingBlobs(blobNamesToCheck);
-        const missingBlobSet = new Set(missingBlobNames);
-        this.log(`Server is missing ${missingBlobNames.length} blobs`);
-        // Categorize files
-        const { newlyUploaded, alreadyOnServer } = this.categorizeFiles(newBlobEntries, missingBlobSet);
-        // Upload only missing files
-        const filesToActuallyUpload = filesToUpload.filter((file) => missingBlobSet.has(file.blobName));
-        if (filesToActuallyUpload.length > 0) {
-            this.log(`Uploading ${filesToActuallyUpload.length} files to backend`);
-            await this.batchUploadFiles(filesToActuallyUpload);
-            this.log("Upload complete");
+        const stillPending = [
+          ...result.unknownBlobNames,
+          ...result.nonindexedBlobNames
+        ];
+        ctx.indexed = blobNames.length - stillPending.length;
+        if (ctx.onProgress) {
+          ctx.onProgress({
+            stage: "indexing",
+            uploaded: ctx.uploaded,
+            indexed: ctx.indexed,
+            total: ctx.total,
+            startedAt: ctx.startedAt
+          });
         }
-        // Update blob tracking state
-        for (const [path, blobName] of newBlobEntries) {
-            this.pendingAdded.add(blobName);
-            this.pendingDeleted.delete(blobName);
-            this.blobMap.set(path, blobName);
+        if (stillPending.length === 0) {
+          this.log("All blobs indexed successfully");
+          return;
         }
-        await this.maybeCheckpoint();
-        return {
-            newlyUploaded,
-            alreadyUploaded: [...alreadyUploaded, ...alreadyOnServer],
-        };
-    }
-    /**
-     * Remove paths from the index
-     */
-    async removeFromIndex(paths) {
-        return await this.mutex.runExclusive(() => this.doRemoveFromIndex(paths));
-    }
-    /**
-     * Internal implementation of removeFromIndex
-     */
-    async doRemoveFromIndex(paths) {
-        for (const path of paths) {
-            const blobName = this.blobMap.get(path);
-            if (blobName) {
-                if (this.pendingAdded.has(blobName)) {
-                    this.pendingAdded.delete(blobName);
-                }
-                else {
-                    this.pendingDeleted.add(blobName);
-                }
-                this.blobMap.delete(path);
-            }
+        const elapsedMs = Date.now() - startTime;
+        this.log(
+          `Still waiting for ${stillPending.length} blobs to be indexed (elapsed: ${Math.round(elapsedMs / 1e3)}s)`
+        );
+        if (timeoutMs !== void 0 && elapsedMs >= timeoutMs) {
+          throw new Error(
+            `Indexing timeout: Backend did not finish indexing within ${timeoutMs / 1e3} seconds. You can increase the timeout by passing a 'timeout' option to addToIndex() or waitForIndexing().`
+          );
         }
-        await this.maybeCheckpoint();
-    }
-    /**
-     * Clear the entire index
-     */
-    async clearIndex() {
-        return await this.mutex.runExclusive(() => this.doClearIndex());
-    }
-    /**
-     * Internal implementation of clearIndex
-     */
-    doClearIndex() {
-        this.log(`Clearing index (${this.blobMap.size} files)`);
-        this.checkpointId = undefined;
-        this.blobMap.clear();
-        this.pendingAdded.clear();
-        this.pendingDeleted.clear();
-        this.log("Index cleared");
-        return Promise.resolve();
+        const pollIntervalMs = elapsedMs < backoffThresholdMs ? initialPollIntervalMs : backoffPollIntervalMs;
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+      }
+    });
+  }
+  /**
+   * Wait for all indexed files to be fully indexed on the backend.
+   *
+   * 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 (only when timeout is specified)
+   */
+  async waitForIndexing(timeout, onProgress) {
+    const blobNames = Array.from(this.blobMap.values());
+    const ctx = this.createProgressContext(onProgress, blobNames.length, /* @__PURE__ */ new Date());
+    await this.waitForSpecificBlobs(blobNames, timeout, ctx);
+  }
+  /**
+   * 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()`.
+   *
+   * Note: This method does not wait for indexing. Ensure files are indexed before
+   * searching by either:
+   * - Using `addToIndex()` with `waitForIndexing: true` (default)
+   * - Calling `waitForIndexing()` explicitly before searching
+   *
+   * @param query - The search query describing what code you're looking for
+   * @param options - Optional search options
+   * @param options.maxOutputLength - Maximum character length of the formatted output (default: 20000, max: 80000)
+   * @returns A formatted string containing the search results, ready for LLM consumption
+   */
+  async search(query, options) {
+    this.log(`Searching for: "${query}"`);
+    if (!this.isSearchOnly && this.blobMap.size === 0) {
+      throw new Error(
+        "Index not initialized. Add files to index first using addToIndex()."
+      );
     }
-    /**
-     * Wait for specific blobs to be indexed on the backend
-     *
-     * This method is serialized via pollingMutex to prevent unbounded concurrent
-     * polling requests to the backend.
-     */
-    waitForSpecificBlobs(blobNames) {
-        return this.pollingMutex.runExclusive(async () => {
-            if (blobNames.length === 0) {
-                this.log("No blobs to wait for");
-                return;
-            }
-            this.log(`Waiting for ${blobNames.length} blobs to be indexed on backend`);
-            const initialPollIntervalMs = 3000;
-            const backoffThresholdMs = 60000;
-            const backoffPollIntervalMs = 60000;
-            const maxWaitTimeMs = 600000;
-            const startTime = Date.now();
-            while (true) {
-                // Check for blobs that are not yet indexed (either not uploaded or uploaded but not indexed)
-                const stillPending = await this.findMissingBlobs(blobNames, true);
-                if (stillPending.length === 0) {
-                    this.log("All blobs indexed successfully");
-                    return;
-                }
-                const elapsedMs = Date.now() - startTime;
-                this.log(`Still waiting for ${stillPending.length} blobs to be indexed (elapsed: ${Math.round(elapsedMs / 1000)}s)`);
-                if (elapsedMs >= maxWaitTimeMs) {
-                    throw new Error(`Indexing timeout: Backend did not finish indexing within ${maxWaitTimeMs / 1000} seconds`);
-                }
-                const pollIntervalMs = elapsedMs < backoffThresholdMs
-                    ? initialPollIntervalMs
-                    : backoffPollIntervalMs;
-                await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-            }
-        });
+    if (this.isSearchOnly && !this.checkpointId && this.pendingAdded.size === 0) {
+      throw new Error(
+        "Index not initialized. This search-only context has no checkpoint or pending changes."
+      );
     }
-    /**
-     * Wait for all indexed files to be fully indexed on the backend.
-     *
-     * This method polls the backend until all files that have been added to the index
-     * are confirmed to be indexed and searchable.
-     *
-     * @returns Promise that resolves when all files are indexed
-     * @throws Error if indexing times out (default: 10 minutes)
-     */
-    async waitForIndexing() {
-        const blobNames = Array.from(this.blobMap.values());
-        await this.waitForSpecificBlobs(blobNames);
+    const blobs = {
+      checkpointId: this.checkpointId,
+      addedBlobs: Array.from(this.pendingAdded).sort(),
+      deletedBlobs: Array.from(this.pendingDeleted).sort()
+    };
+    this.log(
+      `Executing search with checkpoint ${this.checkpointId || "(none)"}, ${this.blobMap.size} indexed files`
+    );
+    const result = await this.apiClient.agentCodebaseRetrieval(
+      query,
+      blobs,
+      options?.maxOutputLength
+    );
+    this.log("Search completed successfully");
+    return result.formattedRetrieval;
+  }
+  /**
+   * 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.
+   *
+   * Note: This method does not wait for indexing. Ensure files are indexed before
+   * searching by either:
+   * - Using `addToIndex()` with `waitForIndexing: true` (default)
+   * - Calling `waitForIndexing()` explicitly before searching
+   *
+   * @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);
+    return await chatWithRetry(this.apiClient, llmPrompt, this.debug);
+  }
+  /**
+   * 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(options) {
+    const mode = options?.mode ?? "full";
+    if (mode === "full" && this.isSearchOnly) {
+      throw new Error(
+        "Cannot export as 'full' from a context imported from search-only state. The blob information required for full state is not available. Use export({ mode: 'search-only' }) instead."
+      );
     }
-    /**
-     * 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()`.
-     *
-     * Note: This method does not wait for indexing. Ensure files are indexed before
-     * searching by either:
-     * - Using `addToIndex()` with `waitForIndexing: true` (default)
-     * - Calling `waitForIndexing()` explicitly before searching
-     *
-     * @param query - The search query describing what code you're looking for
-     * @param options - Optional search options
-     * @param options.maxOutputLength - Maximum character length of the formatted output (default: 20000, max: 80000)
-     * @returns A formatted string containing the search results, ready for LLM consumption
-     */
-    async search(query, options) {
-        this.log(`Searching for: "${query}"`);
-        if (this.blobMap.size === 0) {
-            throw new Error("Index not initialized. Add files to index first using addToIndex().");
-        }
-        const blobs = {
-            checkpointId: this.checkpointId,
-            addedBlobs: Array.from(this.pendingAdded).sort(),
-            deletedBlobs: Array.from(this.pendingDeleted).sort(),
-        };
-        this.log(`Executing search with checkpoint ${this.checkpointId || "(none)"}, ${this.blobMap.size} indexed files`);
-        const result = await this.apiClient.agentCodebaseRetrieval(query, blobs, options?.maxOutputLength);
-        this.log("Search completed successfully");
-        return result.formattedRetrieval;
+    const addedBlobs = Array.from(this.pendingAdded);
+    const deletedBlobs = Array.from(this.pendingDeleted);
+    if (mode === "search-only") {
+      const state2 = {
+        mode: "search-only",
+        checkpointId: this.checkpointId,
+        addedBlobs,
+        deletedBlobs
+      };
+      return state2;
     }
-    /**
-     * 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.
-     *
-     * Note: This method does not wait for indexing. Ensure files are indexed before
-     * searching by either:
-     * - Using `addToIndex()` with `waitForIndexing: true` (default)
-     * - Calling `waitForIndexing()` explicitly before searching
-     *
-     * @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);
-        return await chatWithRetry(this.apiClient, llmPrompt, this.debug);
+    const blobs = [];
+    for (const [path, serverBlobId] of this.blobMap.entries()) {
+      const clientBlobId = this.clientBlobMap.get(path);
+      if (clientBlobId && clientBlobId !== serverBlobId) {
+        blobs.push([serverBlobId, path, clientBlobId]);
+      } else {
+        blobs.push([serverBlobId, path]);
+      }
     }
-    /**
-     * Export the current state to a JSON object
-     */
-    export() {
-        // Convert blobMap to array of [blobName, path] tuples
-        const blobs = [];
-        for (const [path, blobName] of this.blobMap.entries()) {
-            blobs.push([blobName, path]);
+    const state = {
+      mode: "full",
+      checkpointId: this.checkpointId,
+      addedBlobs,
+      deletedBlobs,
+      blobs
+    };
+    return state;
+  }
+  /**
+   * Internal method to import state from a JSON object
+   */
+  async doImport(state) {
+    return await this.mutex.runExclusive(() => {
+      const mode = "mode" in state ? state.mode : "full";
+      this.isSearchOnly = mode === "search-only";
+      this.checkpointId = state.checkpointId;
+      this.blobMap.clear();
+      this.clientBlobMap.clear();
+      this.pendingAdded.clear();
+      this.pendingDeleted.clear();
+      if ("blobs" in state && state.blobs) {
+        for (const entry of state.blobs) {
+          const [serverBlobId, path, clientBlobId] = entry;
+          this.blobMap.set(path, serverBlobId);
+          this.clientBlobMap.set(path, clientBlobId ?? serverBlobId);
         }
-        // Export pending added blobs (blobs added since last checkpoint)
-        const addedBlobs = Array.from(this.pendingAdded);
-        // Export pending deleted blobs (blobs deleted since last checkpoint)
-        const deletedBlobs = Array.from(this.pendingDeleted);
-        return {
-            checkpointId: this.checkpointId,
-            addedBlobs,
-            deletedBlobs,
-            blobs,
-        };
-    }
-    /**
-     * Internal method to import state from a JSON object
-     */
-    async doImport(state) {
-        return await this.mutex.runExclusive(() => {
-            this.checkpointId = state.checkpointId;
-            this.blobMap.clear();
-            this.pendingAdded.clear();
-            this.pendingDeleted.clear();
-            // Restore blobMap from blobs array [blobName, path]
-            if (state.blobs) {
-                for (const [blobName, path] of state.blobs) {
-                    this.blobMap.set(path, blobName);
-                }
-            }
-            // Restore pending added blobs - directly copy the array to set
-            if (state.addedBlobs && state.addedBlobs.length > 0) {
-                this.pendingAdded = new Set(state.addedBlobs);
-            }
-            // Restore pending deleted blobs - directly copy the array to set
-            if (state.deletedBlobs && state.deletedBlobs.length > 0) {
-                this.pendingDeleted = new Set(state.deletedBlobs);
-            }
-            this.log(`State imported: checkpoint ${this.checkpointId}, ${this.blobMap.size} files, ${this.pendingAdded.size} pending added, ${this.pendingDeleted.size} pending deleted`);
-        });
-    }
-    /**
-     * Export state to a file (Node.js only)
-     */
-    async exportToFile(filePath) {
-        const state = this.export();
-        await writeFile(filePath, JSON.stringify(state, null, 2), "utf-8");
-        this.log(`State saved to ${filePath}`);
-    }
+      }
+      if (state.addedBlobs && state.addedBlobs.length > 0) {
+        this.pendingAdded = new Set(state.addedBlobs);
+      }
+      if (state.deletedBlobs && state.deletedBlobs.length > 0) {
+        this.pendingDeleted = new Set(state.deletedBlobs);
+      }
+      this.log(
+        `State imported (mode: ${mode}): checkpoint ${this.checkpointId}, ${this.blobMap.size} files, ${this.pendingAdded.size} pending added, ${this.pendingDeleted.size} pending deleted`
+      );
+    });
+  }
+  /**
+   * 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
+   */
+  async exportToFile(filePath, options) {
+    const state = this.export(options);
+    await writeFile(filePath, JSON.stringify(state, null, 2), "utf-8");
+    this.log(`State saved to ${filePath}`);
+  }
 }
-DirectContext.MAX_FILE_SIZE_BYTES = 1048576; // 1MB
-DirectContext.MAX_BATCH_UPLOAD_SIZE = 1000;
-DirectContext.MAX_BATCH_CONTENT_BYTES = 2 * 1024 * 1024; // 2MB
-DirectContext.MAX_FIND_MISSING_SIZE = 1000;
-DirectContext.CHECKPOINT_THRESHOLD = 1000;
-//# sourceMappingURL=direct-context.js.map
+export {
+  DirectContext
+};