@augmentcode/auggie-sdk 0.1.10 → 0.1.12

package/dist/context/internal/api-client.js

@@ -1,252 +1,247 @@
-/**
- * API client for Context operations
- * Handles both indexing endpoints and LLM chat endpoint
- */
 import { v4 as uuidv4 } from "uuid";
-import { getSDKVersion } from "../../version";
-import { retryChat, retryWithBackoff } from "./retry-utils";
-/**
- * Error thrown when an API request fails
- * Includes the HTTP status code to enable retry logic for transient failures
- */
-export class APIError extends Error {
-    constructor(status, statusText, message) {
-        super(message);
-        this.name = "APIError";
-        this.status = status;
-        this.statusText = statusText;
-    }
+import { getSDKVersion } from "../../version.js";
+import { retryChat, retryWithBackoff } from "./retry-utils.js";
+class APIError extends Error {
+  status;
+  statusText;
+  constructor(status, statusText, message) {
+    super(message);
+    this.name = "APIError";
+    this.status = status;
+    this.statusText = statusText;
+  }
 }
-/**
- * Get user agent string for Context API requests
- */
-export function getUserAgent() {
-    return `augment.sdk.context/${getSDKVersion()} (typescript)`;
+function getUserAgent() {
+  return `augment.sdk.context/${getSDKVersion()} (typescript)`;
 }
-/**
- * API client for Context operations
- */
-export class ContextAPIClient {
-    constructor(options) {
-        this.apiKey = options.apiKey;
-        this.apiUrl = options.apiUrl;
-        this.sessionId = uuidv4();
-        this.debug = options.debug ?? false;
-    }
-    log(message) {
-        if (this.debug) {
-            console.log(`[ContextAPI] ${message}`);
-        }
+class ContextAPIClient {
+  apiKey;
+  apiUrl;
+  sessionId;
+  debug;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.apiUrl = options.apiUrl;
+    this.sessionId = uuidv4();
+    this.debug = options.debug ?? false;
+  }
+  log(message) {
+    if (this.debug) {
+      console.log(`[ContextAPI] ${message}`);
     }
-    createRequestId() {
-        return uuidv4();
+  }
+  createRequestId() {
+    return uuidv4();
+  }
+  async callApi(endpoint, payload, requestId) {
+    const baseUrl = this.apiUrl.endsWith("/") ? this.apiUrl.slice(0, -1) : this.apiUrl;
+    const url = `${baseUrl}/${endpoint}`;
+    this.log(`POST ${url}`);
+    this.log(`Request ID: ${requestId}`);
+    this.log(`Request: ${JSON.stringify(payload, null, 2)}`);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+        "X-Request-Session-Id": this.sessionId,
+        "X-Request-Id": requestId,
+        "User-Agent": getUserAgent()
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new APIError(
+        response.status,
+        response.statusText,
+        `API request failed: ${response.status} ${response.statusText} - ${errorText}`
+      );
     }
-    async callApi(endpoint, payload, requestId) {
-        // Remove trailing slash from apiUrl if present
-        const baseUrl = this.apiUrl.endsWith("/")
-            ? this.apiUrl.slice(0, -1)
-            : this.apiUrl;
-        const url = `${baseUrl}/${endpoint}`;
-        this.log(`POST ${url}`);
-        this.log(`Request ID: ${requestId}`);
-        this.log(`Request: ${JSON.stringify(payload, null, 2)}`);
-        const response = await fetch(url, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${this.apiKey}`,
-                "X-Request-Session-Id": this.sessionId,
-                "X-Request-Id": requestId,
-                "User-Agent": getUserAgent(),
-            },
-            body: JSON.stringify(payload),
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new APIError(response.status, response.statusText, `API request failed: ${response.status} ${response.statusText} - ${errorText}`);
+    const json = await response.json();
+    this.log(`Response: ${JSON.stringify(json, null, 2)}`);
+    return json;
+  }
+  /**
+   * Call API with automatic retry logic and stable request ID across retries
+   */
+  async callApiWithRetry(endpoint, payload) {
+    const requestId = this.createRequestId();
+    return await retryWithBackoff(
+      () => this.callApi(endpoint, payload, requestId),
+      this.debug
+    );
+  }
+  async findMissing(blobNames) {
+    const result = await this.callApiWithRetry("find-missing", {
+      mem_object_names: blobNames
+    });
+    return {
+      unknownBlobNames: result.unknown_memory_names || [],
+      nonindexedBlobNames: result.nonindexed_blob_names || []
+    };
+  }
+  async batchUpload(blobs) {
+    const result = await this.callApiWithRetry(
+      "batch-upload",
+      {
+        blobs: blobs.map((blob) => ({
+          blob_name: blob.blobName,
+          path: blob.pathName,
+          content: blob.text
+        }))
+      }
+    );
+    return {
+      blobNames: result.blob_names || []
+    };
+  }
+  async checkpointBlobs(blobs) {
+    const result = await this.callApiWithRetry(
+      "checkpoint-blobs",
+      {
+        blobs: {
+          checkpoint_id: blobs.checkpointId ?? null,
+          added_blobs: blobs.addedBlobs,
+          deleted_blobs: blobs.deletedBlobs
         }
-        const json = (await response.json());
-        this.log(`Response: ${JSON.stringify(json, null, 2)}`);
-        return json;
-    }
-    /**
-     * Call API with automatic retry logic and stable request ID across retries
-     */
-    async callApiWithRetry(endpoint, payload) {
-        const requestId = this.createRequestId();
-        return await retryWithBackoff(() => this.callApi(endpoint, payload, requestId), this.debug);
+      }
+    );
+    return {
+      newCheckpointId: result.new_checkpoint_id
+    };
+  }
+  async agentCodebaseRetrieval(query, blobs, maxOutputLength) {
+    const requestBody = {
+      information_request: query,
+      blobs: {
+        checkpoint_id: blobs.checkpointId ?? null,
+        added_blobs: blobs.addedBlobs,
+        deleted_blobs: blobs.deletedBlobs
+      },
+      dialog: []
+    };
+    if (maxOutputLength !== void 0) {
+      requestBody.max_output_length = maxOutputLength;
     }
-    async findMissing(blobNames) {
-        const result = await this.callApiWithRetry("find-missing", {
-            mem_object_names: blobNames,
-        });
-        return {
-            unknownBlobNames: result.unknown_memory_names || [],
-            nonindexedBlobNames: result.nonindexed_blob_names || [],
-        };
-    }
-    async batchUpload(blobs) {
-        const result = await this.callApiWithRetry("batch-upload", {
-            blobs: blobs.map((blob) => ({
-                blob_name: blob.blobName,
-                path: blob.pathName,
-                content: blob.text,
-            })),
-        });
-        return {
-            blobNames: result.blob_names || [],
-        };
-    }
-    async checkpointBlobs(blobs) {
-        const result = await this.callApiWithRetry("checkpoint-blobs", {
-            blobs: {
-                checkpoint_id: blobs.checkpointId ?? null,
-                added_blobs: blobs.addedBlobs,
-                deleted_blobs: blobs.deletedBlobs,
-            },
-        });
-        return {
-            newCheckpointId: result.new_checkpoint_id,
-        };
-    }
-    async agentCodebaseRetrieval(query, blobs, maxOutputLength) {
-        const requestBody = {
-            information_request: query,
-            blobs: {
-                checkpoint_id: blobs.checkpointId ?? null,
-                added_blobs: blobs.addedBlobs,
-                deleted_blobs: blobs.deletedBlobs,
-            },
-            dialog: [],
-        };
-        if (maxOutputLength !== undefined) {
-            requestBody.max_output_length = maxOutputLength;
-        }
-        const result = await this.callApiWithRetry("agents/codebase-retrieval", requestBody);
-        return {
-            formattedRetrieval: result.formatted_retrieval,
-        };
-    }
-    /**
-     * Parse streaming response and accumulate text chunks
-     * Uses a buffer to handle JSON objects that span multiple lines or chunks
-     */
-    async parseSSEStream(body) {
-        const reader = body.getReader();
-        const decoder = new TextDecoder();
-        let accumulatedText = "";
-        let textBuffer = "";
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                // Accumulate decoded text into buffer
-                textBuffer += decoder.decode(value, { stream: true });
-                // Parse Newline Delimited JSON - only process complete lines
-                while (textBuffer.includes("\n")) {
-                    const newLineIndex = textBuffer.indexOf("\n");
-                    const line = textBuffer.substring(0, newLineIndex);
-                    textBuffer = textBuffer.substring(newLineIndex + 1);
-                    // Parse the complete line
-                    const trimmed = line.trim();
-                    if (trimmed) {
-                        try {
-                            const parsed = JSON.parse(trimmed);
-                            if (parsed.text) {
-                                accumulatedText += parsed.text;
-                            }
-                        }
-                        catch (e) {
-                            // Log parsing errors - these indicate malformed responses from the backend
-                            // With buffering, we should only see errors for genuinely invalid JSON
-                            this.log(`JSON parse failed for line: ${trimmed}`);
-                        }
-                    }
-                }
-            }
-            // Flush the decoder to handle any pending multi-byte characters
-            const finalChunk = decoder.decode();
-            if (finalChunk) {
-                textBuffer += finalChunk;
-            }
-            // Process any remaining data in buffer (in case stream doesn't end with newline)
-            if (textBuffer.trim()) {
-                try {
-                    const parsed = JSON.parse(textBuffer.trim());
-                    if (parsed.text) {
-                        accumulatedText += parsed.text;
-                    }
-                }
-                catch (e) {
-                    this.log(`JSON parse failed for remaining buffer: ${textBuffer.trim()}`);
-                }
+    const result = await this.callApiWithRetry(
+      "agents/codebase-retrieval",
+      requestBody
+    );
+    return {
+      formattedRetrieval: result.formatted_retrieval
+    };
+  }
+  /**
+   * Parse streaming response and accumulate text chunks
+   * Uses a buffer to handle JSON objects that span multiple lines or chunks
+   */
+  async parseSSEStream(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let accumulatedText = "";
+    let textBuffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        textBuffer += decoder.decode(value, { stream: true });
+        while (textBuffer.includes("\n")) {
+          const newLineIndex = textBuffer.indexOf("\n");
+          const line = textBuffer.substring(0, newLineIndex);
+          textBuffer = textBuffer.substring(newLineIndex + 1);
+          const trimmed = line.trim();
+          if (trimmed) {
+            try {
+              const parsed = JSON.parse(trimmed);
+              if (parsed.text) {
+                accumulatedText += parsed.text;
+              }
+            } catch (e) {
+              this.log(`JSON parse failed for line: ${trimmed}`);
             }
+          }
         }
-        finally {
-            reader.releaseLock();
+      }
+      const finalChunk = decoder.decode();
+      if (finalChunk) {
+        textBuffer += finalChunk;
+      }
+      if (textBuffer.trim()) {
+        try {
+          const parsed = JSON.parse(textBuffer.trim());
+          if (parsed.text) {
+            accumulatedText += parsed.text;
+          }
+        } catch (e) {
+          this.log(`JSON parse failed for remaining buffer: ${textBuffer.trim()}`);
         }
-        return accumulatedText;
+      }
+    } finally {
+      reader.releaseLock();
     }
-    /**
-     * Call the LLM chat streaming API with a formatted prompt
-     *
-     * @param prompt - The formatted prompt to send to the LLM
-     * @returns The LLM's response text
-     */
-    async chat(prompt) {
-        const requestId = this.createRequestId();
-        return await retryChat(async () => {
-            // Remove trailing slash from apiUrl if present
-            const baseUrl = this.apiUrl.endsWith("/")
-                ? this.apiUrl.slice(0, -1)
-                : this.apiUrl;
-            const url = `${baseUrl}/chat-stream`;
-            this.log(`POST ${url}`);
-            this.log(`Request ID: ${requestId}`);
-            // Use nodes array format for chat-stream (newer API format)
-            // This avoids potential bugs from using the deprecated message field
-            // Note: type is an integer enum where 0 = TEXT node
-            // The structure matches ChatRequestNode from the backend
-            const payload = {
-                nodes: [
-                    {
-                        id: 0,
-                        type: 0, // ChatRequestNodeType.TEXT = 0
-                        text_node: {
-                            content: prompt,
-                        },
-                    },
-                ],
-                chat_history: [],
-                conversation_id: this.sessionId,
-            };
-            this.log(`Request: ${JSON.stringify(payload, null, 2)}`);
-            const response = await fetch(url, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${this.apiKey}`,
-                    "X-Request-Session-Id": this.sessionId,
-                    "X-Request-Id": requestId,
-                    "conversation-id": this.sessionId,
-                    "X-Mode": "sdk",
-                    "User-Agent": getUserAgent(),
-                },
-                body: JSON.stringify(payload),
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new APIError(response.status, response.statusText, `API request failed: ${response.status} ${response.statusText} - ${errorText}`);
-            }
-            // Handle streaming response
-            if (!response.body) {
-                throw new Error("Response body is null");
+    return accumulatedText;
+  }
+  /**
+   * Call the LLM chat streaming API with a formatted prompt
+   *
+   * @param prompt - The formatted prompt to send to the LLM
+   * @returns The LLM's response text
+   */
+  async chat(prompt) {
+    const requestId = this.createRequestId();
+    return await retryChat(async () => {
+      const baseUrl = this.apiUrl.endsWith("/") ? this.apiUrl.slice(0, -1) : this.apiUrl;
+      const url = `${baseUrl}/chat-stream`;
+      this.log(`POST ${url}`);
+      this.log(`Request ID: ${requestId}`);
+      const payload = {
+        nodes: [
+          {
+            id: 0,
+            type: 0,
+            // ChatRequestNodeType.TEXT = 0
+            text_node: {
+              content: prompt
             }
-            const accumulatedText = await this.parseSSEStream(response.body);
-            this.log(`Response: ${accumulatedText}`);
-            return accumulatedText;
-        }, this.debug);
-    }
+          }
+        ],
+        chat_history: [],
+        conversation_id: this.sessionId
+      };
+      this.log(`Request: ${JSON.stringify(payload, null, 2)}`);
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`,
+          "X-Request-Session-Id": this.sessionId,
+          "X-Request-Id": requestId,
+          "conversation-id": this.sessionId,
+          "X-Mode": "sdk",
+          "User-Agent": getUserAgent()
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new APIError(
+          response.status,
+          response.statusText,
+          `API request failed: ${response.status} ${response.statusText} - ${errorText}`
+        );
+      }
+      if (!response.body) {
+        throw new Error("Response body is null");
+      }
+      const accumulatedText = await this.parseSSEStream(response.body);
+      this.log(`Response: ${accumulatedText}`);
+      return accumulatedText;
+    }, this.debug);
+  }
 }
-//# sourceMappingURL=api-client.js.map
+export {
+  APIError,
+  ContextAPIClient,
+  getUserAgent
+};

package/dist/context/internal/blob-name-calculator.d.ts

@@ -1,8 +1,8 @@
-export declare const blobNamingVersion = 2023102300;
-export declare class BlobTooLargeError extends Error {
+declare const blobNamingVersion = 2023102300;
+declare class BlobTooLargeError extends Error {
     constructor(maxBlobSize: number);
 }
-export declare class BlobNameCalculator {
+declare class BlobNameCalculator {
     private readonly _textEncoder;
     readonly maxBlobSize: number;
     constructor(maxBlobSize: number);
@@ -11,4 +11,5 @@ export declare class BlobNameCalculator {
     calculate(path: string, contents: string | Uint8Array): string | undefined;
     calculateNoThrow(path: string, contents: string | Uint8Array): string;
 }
-//# sourceMappingURL=blob-name-calculator.d.ts.map
+
+export { BlobNameCalculator, BlobTooLargeError, blobNamingVersion };

package/dist/context/internal/blob-name-calculator.js

@@ -1,44 +1,47 @@
 import { createHash } from "node:crypto";
-export const blobNamingVersion = 2023102300;
-export class BlobTooLargeError extends Error {
-    constructor(maxBlobSize) {
-        super(`content exceeds maximum size of ${maxBlobSize}`);
-    }
+const blobNamingVersion = 2023102300;
+class BlobTooLargeError extends Error {
+  constructor(maxBlobSize) {
+    super(`content exceeds maximum size of ${maxBlobSize}`);
+  }
 }
-export class BlobNameCalculator {
-    constructor(maxBlobSize) {
-        this._textEncoder = new TextEncoder();
-        this.maxBlobSize = maxBlobSize;
-    }
-    _hash(path, contents) {
-        const hash = createHash("sha256");
-        hash.update(path);
-        hash.update(contents);
-        return hash.digest("hex");
-    }
-    calculateOrThrow(path, contents, checkFileSize = true) {
-        let contentsBytes;
-        if (typeof contents === "string") {
-            contentsBytes = this._textEncoder.encode(contents);
-        }
-        else {
-            contentsBytes = contents;
-        }
-        if (checkFileSize && contentsBytes.length > this.maxBlobSize) {
-            throw new BlobTooLargeError(this.maxBlobSize);
-        }
-        return this._hash(path, contentsBytes);
+class BlobNameCalculator {
+  _textEncoder = new TextEncoder();
+  maxBlobSize;
+  constructor(maxBlobSize) {
+    this.maxBlobSize = maxBlobSize;
+  }
+  _hash(path, contents) {
+    const hash = createHash("sha256");
+    hash.update(path);
+    hash.update(contents);
+    return hash.digest("hex");
+  }
+  calculateOrThrow(path, contents, checkFileSize = true) {
+    let contentsBytes;
+    if (typeof contents === "string") {
+      contentsBytes = this._textEncoder.encode(contents);
+    } else {
+      contentsBytes = contents;
     }
-    calculate(path, contents) {
-        try {
-            return this.calculateOrThrow(path, contents, true);
-        }
-        catch {
-            return;
-        }
+    if (checkFileSize && contentsBytes.length > this.maxBlobSize) {
+      throw new BlobTooLargeError(this.maxBlobSize);
     }
-    calculateNoThrow(path, contents) {
-        return this.calculateOrThrow(path, contents, false);
+    return this._hash(path, contentsBytes);
+  }
+  calculate(path, contents) {
+    try {
+      return this.calculateOrThrow(path, contents, true);
+    } catch {
+      return;
     }
+  }
+  calculateNoThrow(path, contents) {
+    return this.calculateOrThrow(path, contents, false);
+  }
 }
-//# sourceMappingURL=blob-name-calculator.js.map
+export {
+  BlobNameCalculator,
+  BlobTooLargeError,
+  blobNamingVersion
+};

package/dist/context/internal/chat-utils.d.ts

@@ -1,4 +1,6 @@
-import type { ContextAPIClient } from "./api-client";
+import { ContextAPIClient } from './api-client.js';
+import '../types.js';
+
 /**
  * Call the chat API with retry logic for transient failures
  *
@@ -14,5 +16,6 @@ import type { ContextAPIClient } from "./api-client";
  * @param _debug - Whether to log debug messages (unused, kept for compatibility)
  * @returns The LLM's response text
  */
-export declare function chatWithRetry(apiClient: ContextAPIClient, prompt: string, _debug?: boolean): Promise<string>;
-//# sourceMappingURL=chat-utils.d.ts.map
+declare function chatWithRetry(apiClient: ContextAPIClient, prompt: string, _debug?: boolean): Promise<string>;
+
+export { chatWithRetry };

package/dist/context/internal/chat-utils.js

@@ -1,19 +1,6 @@
-/**
- * Call the chat API with retry logic for transient failures
- *
- * This function wraps the ContextAPIClient.chat() method with automatic
- * retry logic for transient failures, including chat-specific status codes
- * like 429 (rate limit) and 529 (overloaded).
- *
- * Note: The retry logic is now handled internally by the chat() method,
- * so this function is just a simple wrapper for backwards compatibility.
- *
- * @param apiClient - The API client to use for the chat request
- * @param prompt - The formatted prompt to send to the LLM
- * @param _debug - Whether to log debug messages (unused, kept for compatibility)
- * @returns The LLM's response text
- */
-export async function chatWithRetry(apiClient, prompt, _debug = false) {
-    return await apiClient.chat(prompt);
+async function chatWithRetry(apiClient, prompt, _debug = false) {
+  return await apiClient.chat(prompt);
 }
-//# sourceMappingURL=chat-utils.js.map
+export {
+  chatWithRetry
+};

package/dist/context/internal/credentials.d.ts

@@ -1,14 +1,14 @@
 /**
  * Options for credential resolution
  */
-export type CredentialOptions = {
+type CredentialOptions = {
     apiKey?: string;
     apiUrl?: string;
 };
 /**
  * Resolved credentials
  */
-export type ResolvedCredentials = {
+type ResolvedCredentials = {
     apiKey: string;
     apiUrl: string;
 };
@@ -24,5 +24,6 @@ export type ResolvedCredentials = {
  * @returns Resolved credentials
  * @throws Error if credentials cannot be resolved
  */
-export declare function resolveCredentials(options?: CredentialOptions): Promise<ResolvedCredentials>;
-//# sourceMappingURL=credentials.d.ts.map
+declare function resolveCredentials(options?: CredentialOptions): Promise<ResolvedCredentials>;
+
+export { type CredentialOptions, type ResolvedCredentials, resolveCredentials };