@coderule/clients 1.0.0 → 1.1.0

package/dist/index.cjs

@@ -0,0 +1,780 @@
+'use strict';
+
+var crypto = require('crypto');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+  }
+});
+
+// src/polyfills/fetch-polyfill.ts
+var fetch_polyfill_exports = {};
+__export(fetch_polyfill_exports, {
+  AbortController: () => AbortController,
+  FormData: () => FormData,
+  Headers: () => Headers,
+  Request: () => Request,
+  Response: () => Response,
+  fetch: () => fetch
+});
+var nodeFetch, NodeHeaders, NodeRequest, NodeResponse, NodeFormData, NodeAbortController, fetch, Headers, Request, Response, FormData, AbortController;
+var init_fetch_polyfill = __esm({
+  "src/polyfills/fetch-polyfill.ts"() {
+    init_cjs_shims();
+    try {
+      const module = __require("node-fetch");
+      nodeFetch = module.default || module;
+      NodeHeaders = module.Headers;
+      NodeRequest = module.Request;
+      NodeResponse = module.Response;
+      try {
+        NodeFormData = // eslint-disable-next-line @typescript-eslint/no-require-imports
+        module.FormData || __require("formdata-polyfill/esm.min.js").FormData;
+      } catch {
+        NodeFormData = class FormData {
+          constructor() {
+            throw new Error(
+              "FormData is not available. Install formdata-polyfill if needed."
+            );
+          }
+        };
+      }
+      NodeAbortController = globalThis.AbortController || module.AbortController;
+    } catch {
+      throw new Error(
+        "For Node.js < 18, please install node-fetch: npm install node-fetch@2"
+      );
+    }
+    fetch = nodeFetch;
+    Headers = NodeHeaders;
+    Request = NodeRequest;
+    Response = NodeResponse;
+    FormData = NodeFormData;
+    AbortController = NodeAbortController;
+  }
+});
+
+// src/index.ts
+init_cjs_shims();
+
+// src/clients/auth-client.ts
+init_cjs_shims();
+
+// src/utils/fetch-wrapper.ts
+init_cjs_shims();
+var hasNativeFetch = typeof globalThis.fetch !== "undefined";
+var fetchModule;
+if (hasNativeFetch) {
+  fetchModule = {
+    fetch: globalThis.fetch,
+    Headers: globalThis.Headers,
+    Request: globalThis.Request,
+    Response: globalThis.Response,
+    FormData: globalThis.FormData,
+    AbortController: globalThis.AbortController
+  };
+} else {
+  try {
+    fetchModule = (init_fetch_polyfill(), __toCommonJS(fetch_polyfill_exports));
+  } catch {
+    throw new Error(
+      `This library requires Node.js 18+ or the node-fetch package.
+Please either:
+1. Upgrade to Node.js 18 or later, or
+2. Install node-fetch: npm install node-fetch@2`
+    );
+  }
+}
+var fetch2 = fetchModule.fetch;
+fetchModule.Headers;
+fetchModule.Request;
+fetchModule.Response;
+var FormData2 = fetchModule.FormData;
+var AbortController2 = fetchModule.AbortController;
+var fetch_wrapper_default = fetch2;
+
+// src/clients/auth-client.ts
+var AuthHttpClient = class {
+  /**
+   * Initialize the Auth HTTP client
+   * @param baseUrl - Base URL of the Auth service (e.g., "http://localhost:8001")
+   * @param timeout - Request timeout in milliseconds (default: 30000)
+   */
+  constructor(baseUrl, timeout = 3e4) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.timeout = timeout;
+  }
+  /**
+   * Authenticate a token and receive a JWT
+   * @param token - Authentication token
+   * @returns Response containing JWT and expiration
+   * @throws Error on HTTP errors or connection errors
+   */
+  async authenticate(token) {
+    const url = `${this.baseUrl}/api/auth/authenticate`;
+    try {
+      const controller = new AbortController2();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch_wrapper_default(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ token }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Authentication failed with status ${response.status}: ${errorText}`
+        );
+      }
+      const data = await response.json();
+      console.debug(
+        `Authentication successful, JWT expires at ${data.expires_at}`
+      );
+      return data;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      console.error(`Authentication request failed: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * Check the health status of the Auth service
+   * @returns Health status information
+   * @throws Error on HTTP errors or connection errors
+   */
+  async health() {
+    const url = `${this.baseUrl}/api/auth/health`;
+    try {
+      const controller = new AbortController2();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch_wrapper_default(url, {
+        method: "GET",
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Health check failed with status ${response.status}: ${errorText}`
+        );
+      }
+      const data = await response.json();
+      console.debug(`Health check: ${data.status}`);
+      return data;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      console.error(`Health check request failed: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * Close the HTTP client connection (no-op for fetch)
+   */
+  close() {
+  }
+};
+function decodeJWT(jwtToken) {
+  try {
+    const parts = jwtToken.split(".");
+    if (parts.length !== 3) {
+      return null;
+    }
+    const payload = parts[1];
+    const paddedPayload = payload + "=".repeat((4 - payload.length % 4) % 4);
+    const base64 = paddedPayload.replace(/-/g, "+").replace(/_/g, "/");
+    const jsonString = Buffer.from(base64, "base64").toString("utf8");
+    const payloadObj = JSON.parse(jsonString);
+    if (payloadObj.exp) {
+      const now = Math.floor(Date.now() / 1e3);
+      if (payloadObj.exp < now) {
+        console.debug("JWT token is expired");
+        return null;
+      }
+    }
+    return payloadObj;
+  } catch (error) {
+    console.error("Failed to decode JWT:", error);
+    return null;
+  }
+}
+
+// src/clients/sync-client.ts
+init_cjs_shims();
+var SyncHttpClient = class {
+  /**
+   * Initialize the Sync HTTP client
+   * @param baseUrl - Base URL of the Sync service (e.g., "http://localhost:8002")
+   * @param jwtToken - JWT token for authentication
+   * @param timeout - Request timeout in milliseconds (default: 60000)
+   */
+  constructor(baseUrl, jwtToken, timeout = 6e4) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.jwtToken = jwtToken;
+    this.timeout = timeout;
+    this.headers = {
+      Authorization: `Bearer ${jwtToken}`,
+      "Content-Type": "application/json"
+    };
+  }
+  /**
+   * Check the status of a snapshot
+   * @param snapshotHash - SHA256 hash of the snapshot
+   * @returns Snapshot status information
+   * @throws Error on HTTP errors or connection errors
+   */
+  async checkSnapshotStatus(snapshotHash) {
+    const url = `${this.baseUrl}/sync/v1/snapshots`;
+    try {
+      const controller = new AbortController2();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch_wrapper_default(url, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({ snapshot_hash: snapshotHash }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.status === 404) {
+        return { status: "NOT_FOUND" };
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Failed to check snapshot with status ${response.status}: ${errorText}`
+        );
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      console.error(`Request failed: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * Create a new snapshot or get its status if it exists
+   * @param snapshotHash - SHA256 hash of the snapshot
+   * @param files - List of file information with 'file_path' and 'file_hash'
+   * @returns Snapshot creation result or status
+   * @throws Error on HTTP errors or connection errors
+   */
+  async createSnapshot(snapshotHash, files) {
+    const url = `${this.baseUrl}/sync/v1/snapshots`;
+    try {
+      const controller = new AbortController2();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch_wrapper_default(url, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({
+          snapshot_hash: snapshotHash,
+          files
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.status === 422) {
+        const data2 = await response.json();
+        console.info(
+          `Snapshot ${snapshotHash.substring(0, 8)}... missing ${data2.missing_files?.length || 0} files`
+        );
+        return data2;
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Failed to create snapshot with status ${response.status}: ${errorText}`
+        );
+      }
+      const data = await response.json();
+      console.info(
+        `Snapshot ${snapshotHash.substring(0, 8)}... status: ${data.status}`
+      );
+      return data;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      console.error(`Request failed: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * Upload file content to the service
+   * @param filesContent - Map of file_hash to object with 'path' and 'content'
+   * @returns Upload result with counts
+   * @throws Error on HTTP errors or connection errors
+   */
+  async uploadFileContent(filesContent) {
+    const url = `${this.baseUrl}/sync/v1/files/content`;
+    try {
+      const controller = new AbortController2();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const formData = new FormData2();
+      for (const [fileHash, fileData] of filesContent.entries()) {
+        const content = typeof fileData.content === "string" ? Buffer.from(fileData.content) : fileData.content;
+        const blob = new Blob([content], { type: "application/octet-stream" });
+        formData.append(fileHash, blob, fileData.path);
+      }
+      const uploadHeaders = { ...this.headers };
+      delete uploadHeaders["Content-Type"];
+      const response = await fetch_wrapper_default(url, {
+        method: "POST",
+        headers: uploadHeaders,
+        body: formData,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Failed to upload files with status ${response.status}: ${errorText}`
+        );
+      }
+      const data = await response.json();
+      console.info(
+        `Uploaded ${data.uploaded_count || 0} files, ${data.failed_count || 0} failed`
+      );
+      return data;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      console.error(`Request failed: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * Calculate file hash from path and content
+   * @param filePath - Relative file path
+   * @param content - File content as Buffer or string
+   * @returns SHA256 hash of the file
+   */
+  static calculateFileHash(filePath, content) {
+    const contentBuffer = typeof content === "string" ? Buffer.from(content) : content;
+    const fileData = Buffer.concat([
+      Buffer.from(`${filePath}
+`, "utf-8"),
+      contentBuffer
+    ]);
+    return crypto__namespace.createHash("sha256").update(fileData).digest("hex");
+  }
+  /**
+   * Calculate snapshot hash from file hashes
+   * @param fileHashes - Array of file SHA256 hashes
+   * @returns SHA256 hash of the snapshot
+   */
+  static calculateSnapshotHash(fileHashes) {
+    const snapshotData = fileHashes.sort().join("\n");
+    return crypto__namespace.createHash("sha256").update(snapshotData, "utf-8").digest("hex");
+  }
+  /**
+   * Check the health status of the Sync service
+   * @returns Health status information
+   * @throws Error on HTTP errors or connection errors
+   */
+  async health() {
+    const url = `${this.baseUrl}/sync/v1/health`;
+    try {
+      const controller = new AbortController2();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch_wrapper_default(url, {
+        method: "GET",
+        headers: { Authorization: `Bearer ${this.jwtToken}` },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Health check failed with status ${response.status}: ${errorText}`
+        );
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      console.error(`Request failed: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * Close the HTTP client connection (no-op for fetch)
+   */
+  close() {
+  }
+};
+
+// src/clients/retrieval-client.ts
+init_cjs_shims();
+var RetrievalHttpClient = class {
+  /**
+   * Initialize the Retrieval HTTP client
+   * @param uri - URI/URL for connecting to the HTTP server (e.g., "http://localhost:8004")
+   * @param timeout - Request timeout in milliseconds (default: 60000)
+   */
+  constructor(uri = "http://localhost:8004", timeout = 6e4) {
+    let processedUri = uri;
+    if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
+      processedUri = `http://${uri}`;
+    }
+    const url = new URL(processedUri);
+    if (url.pathname && url.pathname !== "/") {
+      this.baseUrl = `${url.protocol}//${url.host}${url.pathname}`;
+    } else {
+      this.baseUrl = `${url.protocol}//${url.host}`;
+    }
+    this.timeout = timeout;
+    if (this.baseUrl.endsWith("/")) {
+      this.apiBase = `${this.baseUrl}api/retrieval/`;
+    } else {
+      this.apiBase = `${this.baseUrl}/api/retrieval/`;
+    }
+    console.debug(`Initialized HTTP client for ${this.baseUrl}`);
+    console.debug(`API base: ${this.apiBase}`);
+  }
+  /**
+   * Check the health status of the Retrieval service
+   * @returns Health status information
+   * @throws Error on connection errors
+   */
+  async healthCheck() {
+    const healthEndpoint = `${this.apiBase}health`;
+    console.debug(`Checking server health: ${healthEndpoint}`);
+    try {
+      const controller = new AbortController2();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch_wrapper_default(healthEndpoint, {
+        method: "GET",
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Health check failed with status ${response.status}: ${errorText}`
+        );
+      }
+      const healthInfo = await response.json();
+      console.debug(`HTTP retrieval server status:`, healthInfo);
+      return {
+        status: healthInfo.status || "UNKNOWN",
+        database: healthInfo.database || "UNKNOWN",
+        embedder: healthInfo.embedder || "UNKNOWN",
+        cache_size: healthInfo.cache_size || 0,
+        cache_ttl: healthInfo.cache_ttl || 0,
+        version: healthInfo.version || "unknown"
+      };
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      console.error(`Error checking HTTP server health: ${error.message}`);
+      throw new Error(
+        `Unable to connect to HTTP server ${this.baseUrl}: ${error.message}`
+      );
+    }
+  }
+  /**
+   * Execute a retrieval query on a snapshot
+   * @param snapshotHash - SHA256 hash of the codebase snapshot
+   * @param queryText - Natural language query for retrieval
+   * @param budgetTokens - Maximum token budget for results (default: 3000)
+   * @param jwt - JWT token for authorization (required)
+   * @param options - Optional retrieval parameters
+   * @returns Retrieval results with formatted output
+   * @throws Error on query failures
+   */
+  async query(snapshotHash, queryText, budgetTokens = 3e3, jwt, options) {
+    if (!snapshotHash) {
+      throw new Error("Snapshot hash must be provided");
+    }
+    if (!queryText) {
+      throw new Error("Query text must be provided");
+    }
+    if (!jwt) {
+      throw new Error("JWT must be provided");
+    }
+    if (budgetTokens < 100) {
+      throw new Error("Budget tokens must be at least 100");
+    }
+    const startTime = Date.now();
+    const queryEndpoint = `${this.apiBase}query`;
+    try {
+      const controller = new AbortController2();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const requestBody = {
+        snapshot_hash: snapshotHash,
+        query: queryText,
+        budget_tokens: budgetTokens
+      };
+      if (options) {
+        requestBody.options = options;
+      }
+      const response = await fetch_wrapper_default(queryEndpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${jwt}`
+        },
+        body: JSON.stringify(requestBody),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.status === 404) {
+        const errorData = await response.json();
+        throw new Error(
+          errorData.detail || "Snapshot not found or access denied"
+        );
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Query failed with status ${response.status}: ${errorText}`
+        );
+      }
+      const result = await response.json();
+      const elapsedTime = (Date.now() - startTime) / 1e3;
+      const formatter = options?.formatter || "standard";
+      console.debug(
+        `Retrieval query completed for snapshot ${snapshotHash.substring(0, 8)}... Formatter: ${formatter}. Total time: ${elapsedTime.toFixed(2)}s`
+      );
+      return result;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      console.error(`Error executing retrieval query: ${error.message}`);
+      throw new Error(`Failed to execute retrieval query: ${error.message}`);
+    }
+  }
+  /**
+   * Check if a snapshot is indexed and ready for retrieval
+   * @param snapshotHash - SHA256 hash of the snapshot to check
+   * @param jwt - JWT token for authorization (required)
+   * @returns Snapshot status information
+   * @throws Error on status check failures
+   */
+  async checkSnapshotStatus(snapshotHash, jwt) {
+    if (!snapshotHash) {
+      throw new Error("Snapshot hash must be provided");
+    }
+    if (!jwt) {
+      throw new Error("JWT must be provided");
+    }
+    const statusEndpoint = `${this.apiBase}snapshots/${snapshotHash}/status`;
+    try {
+      const controller = new AbortController2();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch_wrapper_default(statusEndpoint, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${jwt}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.status === 404) {
+        return {
+          snapshot_hash: snapshotHash,
+          status: "NOT_FOUND",
+          message: "Snapshot not found or access denied"
+        };
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Status check failed with status ${response.status}: ${errorText}`
+        );
+      }
+      const statusInfo = await response.json();
+      console.debug(
+        `Snapshot ${snapshotHash.substring(0, 8)}... status: ${statusInfo.status}`
+      );
+      return statusInfo;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      console.error(`Error checking snapshot status: ${error.message}`);
+      throw new Error(`Failed to check snapshot status: ${error.message}`);
+    }
+  }
+  /**
+   * Clear the graph cache (admin operation)
+   * @param jwt - JWT token for authorization (required)
+   * @returns true if cache cleared successfully
+   * @throws Error on cache clear failures
+   */
+  async clearCache(jwt) {
+    if (!jwt) {
+      throw new Error("JWT must be provided");
+    }
+    const cacheEndpoint = `${this.apiBase}cache`;
+    try {
+      const controller = new AbortController2();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch_wrapper_default(cacheEndpoint, {
+        method: "DELETE",
+        headers: {
+          Authorization: `Bearer ${jwt}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Cache clear failed with status ${response.status}: ${errorText}`
+        );
+      }
+      console.info("Graph cache cleared successfully");
+      return true;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      console.error(`Error clearing cache: ${error.message}`);
+      throw new Error(`Failed to clear cache: ${error.message}`);
+    }
+  }
+  /**
+   * Get cache statistics
+   * @param jwt - JWT token for authorization (required)
+   * @returns Cache statistics
+   * @throws Error on stats retrieval failures
+   */
+  async getCacheStats(jwt) {
+    if (!jwt) {
+      throw new Error("JWT must be provided");
+    }
+    const statsEndpoint = `${this.apiBase}cache/stats`;
+    try {
+      const controller = new AbortController2();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch_wrapper_default(statsEndpoint, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${jwt}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Stats retrieval failed with status ${response.status}: ${errorText}`
+        );
+      }
+      const stats = await response.json();
+      console.debug(
+        `Cache stats: ${stats.cached_snapshots || 0} snapshots cached`
+      );
+      return stats;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      console.error(`Error getting cache stats: ${error.message}`);
+      throw new Error(`Failed to get cache stats: ${error.message}`);
+    }
+  }
+  /**
+   * Convenience method for querying with specific options
+   * @param snapshotHash - SHA256 hash of the codebase snapshot
+   * @param queryText - Natural language query for retrieval
+   * @param jwt - JWT token for authorization (required)
+   * @param budgetTokens - Maximum token budget for results
+   * @param flowStrength - Flow intensity multiplier
+   * @param blendAlpha - Blending factor for scores
+   * @param hopDepth - Depth of local neighborhood
+   * @param maxIterations - Maximum flood-walk iterations
+   * @param split - Fraction of budget for full chunks
+   * @param formatter - Output format "standard" or "compact"
+   * @returns Retrieval results
+   */
+  async queryWithOptions(snapshotHash, queryText, jwt, budgetTokens = 3e3, flowStrength = 1.5, blendAlpha = 0.8, hopDepth = 2, maxIterations = 12, split = 0.8, formatter = "standard") {
+    const options = {
+      flow_strength: flowStrength,
+      blend_alpha: blendAlpha,
+      hop_depth: hopDepth,
+      max_iterations: maxIterations,
+      split,
+      formatter
+    };
+    return this.query(snapshotHash, queryText, budgetTokens, jwt, options);
+  }
+  /**
+   * Close the HTTP client connection (no-op for fetch)
+   */
+  close() {
+  }
+};
+
+exports.AuthHttpClient = AuthHttpClient;
+exports.RetrievalHttpClient = RetrievalHttpClient;
+exports.SyncHttpClient = SyncHttpClient;
+exports.decodeJWT = decodeJWT;
+exports.fetch = fetch_wrapper_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map