@prosdevlab/dev-agent 0.8.5 → 0.9.0

package/dist/mcp.js

@@ -1048,11 +1048,11 @@ var init_change_frequency = __esm({
 
 // ../core/src/metrics/collector.ts
 async function countFileLines(repositoryPath2, filePath) {
-  const fs13 = await import("fs/promises");
+  const fs12 = await import("fs/promises");
   const path16 = await import("path");
   try {
     const fullPath = path16.join(repositoryPath2, filePath);
-    const content3 = await fs13.readFile(fullPath, "utf-8");
+    const content3 = await fs12.readFile(fullPath, "utf-8");
     return content3.split("\n").length;
   } catch {
     return 0;
@@ -9585,8 +9585,8 @@ var init_is_plain_obj = __esm({
 // ../../node_modules/.pnpm/trough@2.2.0/node_modules/trough/lib/index.js
 function trough() {
   const fns = [];
-  const pipeline2 = { run, use };
-  return pipeline2;
+  const pipeline = { run, use };
+  return pipeline;
   function run(...values) {
     let middlewareIndex = -1;
     const callback = values.pop();
@@ -9621,7 +9621,7 @@ function trough() {
       );
     }
     fns.push(middelware);
-    return pipeline2;
+    return pipeline;
   }
 }
 function wrap(middleware, callback) {
@@ -14758,8 +14758,8 @@ var require_utils3 = __commonJS({
     exports2.array = array2;
     var errno = require_errno();
     exports2.errno = errno;
-    var fs13 = require_fs();
-    exports2.fs = fs13;
+    var fs12 = require_fs();
+    exports2.fs = fs12;
     var path16 = require_path();
     exports2.path = path16;
     var pattern = require_pattern();
@@ -14883,7 +14883,7 @@ var require_async = __commonJS({
           callSuccessCallback(callback, lstat);
           return;
         }
-        settings.fs.stat(path16, (statError, stat4) => {
+        settings.fs.stat(path16, (statError, stat3) => {
           if (statError !== null) {
             if (settings.throwErrorOnBrokenSymbolicLink) {
               callFailureCallback(callback, statError);
@@ -14893,9 +14893,9 @@ var require_async = __commonJS({
             return;
           }
           if (settings.markSymbolicLink) {
-            stat4.isSymbolicLink = () => true;
+            stat3.isSymbolicLink = () => true;
           }
-          callSuccessCallback(callback, stat4);
+          callSuccessCallback(callback, stat3);
         });
       });
     }
@@ -14921,11 +14921,11 @@ var require_sync = __commonJS({
         return lstat;
       }
       try {
-        const stat4 = settings.fs.statSync(path16);
+        const stat3 = settings.fs.statSync(path16);
         if (settings.markSymbolicLink) {
-          stat4.isSymbolicLink = () => true;
+          stat3.isSymbolicLink = () => true;
         }
-        return stat4;
+        return stat3;
       } catch (error46) {
         if (!settings.throwErrorOnBrokenSymbolicLink) {
           return lstat;
@@ -14943,12 +14943,12 @@ var require_fs2 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createFileSystemAdapter = exports2.FILE_SYSTEM_ADAPTER = void 0;
-    var fs13 = require("fs");
+    var fs12 = require("fs");
     exports2.FILE_SYSTEM_ADAPTER = {
-      lstat: fs13.lstat,
-      stat: fs13.stat,
-      lstatSync: fs13.lstatSync,
-      statSync: fs13.statSync
+      lstat: fs12.lstat,
+      stat: fs12.stat,
+      lstatSync: fs12.lstatSync,
+      statSync: fs12.statSync
     };
     function createFileSystemAdapter(fsMethods) {
       if (fsMethods === void 0) {
@@ -14965,12 +14965,12 @@ var require_settings = __commonJS({
   "../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/settings.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var fs13 = require_fs2();
+    var fs12 = require_fs2();
     var Settings = class {
       constructor(_options = {}) {
         this._options = _options;
         this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
-        this.fs = fs13.createFileSystemAdapter(this._options.fs);
+        this.fs = fs12.createFileSystemAdapter(this._options.fs);
         this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
       }
@@ -14992,14 +14992,14 @@ var require_out = __commonJS({
     var sync = require_sync();
     var settings_1 = require_settings();
     exports2.Settings = settings_1.default;
-    function stat4(path16, optionsOrSettingsOrCallback, callback) {
+    function stat3(path16, optionsOrSettingsOrCallback, callback) {
       if (typeof optionsOrSettingsOrCallback === "function") {
         async.read(path16, getSettings(), optionsOrSettingsOrCallback);
         return;
       }
       async.read(path16, getSettings(optionsOrSettingsOrCallback), callback);
     }
-    exports2.stat = stat4;
+    exports2.stat = stat3;
     function statSync(path16, optionsOrSettings) {
       const settings = getSettings(optionsOrSettings);
       return sync.read(path16, settings);
@@ -15127,8 +15127,8 @@ var require_utils4 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.fs = void 0;
-    var fs13 = require_fs3();
-    exports2.fs = fs13;
+    var fs12 = require_fs3();
+    exports2.fs = fs12;
   }
 });
 
@@ -15323,14 +15323,14 @@ var require_fs4 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createFileSystemAdapter = exports2.FILE_SYSTEM_ADAPTER = void 0;
-    var fs13 = require("fs");
+    var fs12 = require("fs");
     exports2.FILE_SYSTEM_ADAPTER = {
-      lstat: fs13.lstat,
-      stat: fs13.stat,
-      lstatSync: fs13.lstatSync,
-      statSync: fs13.statSync,
-      readdir: fs13.readdir,
-      readdirSync: fs13.readdirSync
+      lstat: fs12.lstat,
+      stat: fs12.stat,
+      lstatSync: fs12.lstatSync,
+      statSync: fs12.statSync,
+      readdir: fs12.readdir,
+      readdirSync: fs12.readdirSync
     };
     function createFileSystemAdapter(fsMethods) {
       if (fsMethods === void 0) {
@@ -15349,12 +15349,12 @@ var require_settings2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     var path16 = require("path");
     var fsStat = require_out();
-    var fs13 = require_fs4();
+    var fs12 = require_fs4();
     var Settings = class {
       constructor(_options = {}) {
         this._options = _options;
         this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
-        this.fs = fs13.createFileSystemAdapter(this._options.fs);
+        this.fs = fs12.createFileSystemAdapter(this._options.fs);
         this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path16.sep);
         this.stats = this._getValue(this._options.stats, false);
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
@@ -16712,16 +16712,16 @@ var require_settings4 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
-    var fs13 = require("fs");
+    var fs12 = require("fs");
     var os2 = require("os");
     var CPU_COUNT = Math.max(os2.cpus().length, 1);
     exports2.DEFAULT_FILE_SYSTEM_ADAPTER = {
-      lstat: fs13.lstat,
-      lstatSync: fs13.lstatSync,
-      stat: fs13.stat,
-      statSync: fs13.statSync,
-      readdir: fs13.readdir,
-      readdirSync: fs13.readdirSync
+      lstat: fs12.lstat,
+      lstatSync: fs12.lstatSync,
+      stat: fs12.stat,
+      statSync: fs12.statSync,
+      readdir: fs12.readdir,
+      readdirSync: fs12.readdirSync
     };
     var Settings = class {
       constructor(_options = {}) {
@@ -19153,363 +19153,1472 @@ var init_scanner = __esm({
   }
 });
 
-// ../core/src/vector/embedder.ts
-var import_transformers, TransformersEmbedder;
-var init_embedder = __esm({
-  "../core/src/vector/embedder.ts"() {
-    "use strict";
-    import_transformers = require("@xenova/transformers");
-    TransformersEmbedder = class {
-      modelName;
-      dimension;
-      pipeline = null;
-      batchSize = 32;
-      constructor(modelName = "Xenova/all-MiniLM-L6-v2", dimension = 384) {
-        this.modelName = modelName;
-        this.dimension = dimension;
+// ../../node_modules/.pnpm/openapi-fetch@0.17.0/node_modules/openapi-fetch/dist/index.mjs
+function randomID() {
+  return Math.random().toString(36).slice(2, 11);
+}
+function createClient(clientOptions) {
+  let {
+    baseUrl = "",
+    Request: CustomRequest = globalThis.Request,
+    fetch: baseFetch = globalThis.fetch,
+    querySerializer: globalQuerySerializer,
+    bodySerializer: globalBodySerializer,
+    pathSerializer: globalPathSerializer,
+    headers: baseHeaders,
+    requestInitExt = void 0,
+    ...baseOptions
+  } = { ...clientOptions };
+  requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
+  baseUrl = removeTrailingSlash(baseUrl);
+  const globalMiddlewares = [];
+  async function coreFetch(schemaPath, fetchOptions) {
+    const {
+      baseUrl: localBaseUrl,
+      fetch: fetch2 = baseFetch,
+      Request = CustomRequest,
+      headers,
+      params = {},
+      parseAs = "json",
+      querySerializer: requestQuerySerializer,
+      bodySerializer = globalBodySerializer ?? defaultBodySerializer,
+      pathSerializer: requestPathSerializer,
+      body,
+      middleware: requestMiddlewares = [],
+      ...init
+    } = fetchOptions || {};
+    let finalBaseUrl = baseUrl;
+    if (localBaseUrl) {
+      finalBaseUrl = removeTrailingSlash(localBaseUrl) ?? baseUrl;
+    }
+    let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
+    if (requestQuerySerializer) {
+      querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer({
+        ...typeof globalQuerySerializer === "object" ? globalQuerySerializer : {},
+        ...requestQuerySerializer
+      });
+    }
+    const pathSerializer = requestPathSerializer || globalPathSerializer || defaultPathSerializer;
+    const serializedBody = body === void 0 ? void 0 : bodySerializer(
+      body,
+      // Note: we declare mergeHeaders() both here and below because it’s a bit of a chicken-or-egg situation:
+      // bodySerializer() needs all headers so we aren’t dropping ones set by the user, however,
+      // the result of this ALSO sets the lowest-priority content-type header. So we re-merge below,
+      // setting the content-type at the very beginning to be overwritten.
+      // Lastly, based on the way headers work, it’s not a simple “present-or-not” check becauase null intentionally un-sets headers.
+      mergeHeaders(baseHeaders, headers, params.header)
+    );
+    const finalHeaders = mergeHeaders(
+      // with no body, we should not to set Content-Type
+      serializedBody === void 0 || // if serialized body is FormData; browser will correctly set Content-Type & boundary expression
+      serializedBody instanceof FormData ? {} : {
+        "Content-Type": "application/json"
+      },
+      baseHeaders,
+      headers,
+      params.header
+    );
+    const finalMiddlewares = [...globalMiddlewares, ...requestMiddlewares];
+    const requestInit = {
+      redirect: "follow",
+      ...baseOptions,
+      ...init,
+      body: serializedBody,
+      headers: finalHeaders
+    };
+    let id;
+    let options;
+    let request = new Request(
+      createFinalURL(schemaPath, { baseUrl: finalBaseUrl, params, querySerializer, pathSerializer }),
+      requestInit
+    );
+    let response;
+    for (const key in init) {
+      if (!(key in request)) {
+        request[key] = init[key];
+      }
+    }
+    if (finalMiddlewares.length) {
+      id = randomID();
+      options = Object.freeze({
+        baseUrl: finalBaseUrl,
+        fetch: fetch2,
+        parseAs,
+        querySerializer,
+        bodySerializer,
+        pathSerializer
+      });
+      for (const m of finalMiddlewares) {
+        if (m && typeof m === "object" && typeof m.onRequest === "function") {
+          const result = await m.onRequest({
+            request,
+            schemaPath,
+            params,
+            options,
+            id
+          });
+          if (result) {
+            if (result instanceof Request) {
+              request = result;
+            } else if (result instanceof Response) {
+              response = result;
+              break;
+            } else {
+              throw new Error("onRequest: must return new Request() or Response() when modifying the request");
+            }
+          }
+        }
       }
-      /**
-       * Initialize the embedding model
-       * Downloads and caches the model on first run
-       */
-      async initialize() {
-        if (this.pipeline) {
-          return;
+    }
+    if (!response) {
+      try {
+        response = await fetch2(request, requestInitExt);
+      } catch (error210) {
+        let errorAfterMiddleware = error210;
+        if (finalMiddlewares.length) {
+          for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
+            const m = finalMiddlewares[i];
+            if (m && typeof m === "object" && typeof m.onError === "function") {
+              const result = await m.onError({
+                request,
+                error: errorAfterMiddleware,
+                schemaPath,
+                params,
+                options,
+                id
+              });
+              if (result) {
+                if (result instanceof Response) {
+                  errorAfterMiddleware = void 0;
+                  response = result;
+                  break;
+                }
+                if (result instanceof Error) {
+                  errorAfterMiddleware = result;
+                  continue;
+                }
+                throw new Error("onError: must return new Response() or instance of Error");
+              }
+            }
+          }
         }
-        try {
-          this.pipeline = await (0, import_transformers.pipeline)(
-            "feature-extraction",
-            this.modelName
+        if (errorAfterMiddleware) {
+          throw errorAfterMiddleware;
+        }
+      }
+      if (finalMiddlewares.length) {
+        for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
+          const m = finalMiddlewares[i];
+          if (m && typeof m === "object" && typeof m.onResponse === "function") {
+            const result = await m.onResponse({
+              request,
+              response,
+              schemaPath,
+              params,
+              options,
+              id
+            });
+            if (result) {
+              if (!(result instanceof Response)) {
+                throw new Error("onResponse: must return new Response() when modifying the response");
+              }
+              response = result;
+            }
+          }
+        }
+      }
+    }
+    const contentLength = response.headers.get("Content-Length");
+    if (response.status === 204 || request.method === "HEAD" || contentLength === "0" && !response.headers.get("Transfer-Encoding")?.includes("chunked")) {
+      return response.ok ? { data: void 0, response } : { error: void 0, response };
+    }
+    if (response.ok) {
+      const getResponseData = async () => {
+        if (parseAs === "stream") {
+          return response.body;
+        }
+        if (parseAs === "json" && !contentLength) {
+          const raw = await response.text();
+          return raw ? JSON.parse(raw) : void 0;
+        }
+        return await response[parseAs]();
+      };
+      return { data: await getResponseData(), response };
+    }
+    let error46 = await response.text();
+    try {
+      error46 = JSON.parse(error46);
+    } catch {
+    }
+    return { error: error46, response };
+  }
+  return {
+    request(method, url2, init) {
+      return coreFetch(url2, { ...init, method: method.toUpperCase() });
+    },
+    /** Call a GET endpoint */
+    GET(url2, init) {
+      return coreFetch(url2, { ...init, method: "GET" });
+    },
+    /** Call a PUT endpoint */
+    PUT(url2, init) {
+      return coreFetch(url2, { ...init, method: "PUT" });
+    },
+    /** Call a POST endpoint */
+    POST(url2, init) {
+      return coreFetch(url2, { ...init, method: "POST" });
+    },
+    /** Call a DELETE endpoint */
+    DELETE(url2, init) {
+      return coreFetch(url2, { ...init, method: "DELETE" });
+    },
+    /** Call a OPTIONS endpoint */
+    OPTIONS(url2, init) {
+      return coreFetch(url2, { ...init, method: "OPTIONS" });
+    },
+    /** Call a HEAD endpoint */
+    HEAD(url2, init) {
+      return coreFetch(url2, { ...init, method: "HEAD" });
+    },
+    /** Call a PATCH endpoint */
+    PATCH(url2, init) {
+      return coreFetch(url2, { ...init, method: "PATCH" });
+    },
+    /** Call a TRACE endpoint */
+    TRACE(url2, init) {
+      return coreFetch(url2, { ...init, method: "TRACE" });
+    },
+    /** Register middleware */
+    use(...middleware) {
+      for (const m of middleware) {
+        if (!m) {
+          continue;
+        }
+        if (typeof m !== "object" || !("onRequest" in m || "onResponse" in m || "onError" in m)) {
+          throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
+        }
+        globalMiddlewares.push(m);
+      }
+    },
+    /** Unregister middleware */
+    eject(...middleware) {
+      for (const m of middleware) {
+        const i = globalMiddlewares.indexOf(m);
+        if (i !== -1) {
+          globalMiddlewares.splice(i, 1);
+        }
+      }
+    }
+  };
+}
+function serializePrimitiveParam(name, value, options) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error(
+      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
+    );
+  }
+  return `${name}=${options?.allowReserved === true ? value : encodeURIComponent(value)}`;
+}
+function serializeObjectParam(name, value, options) {
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  const values = [];
+  const joiner = {
+    simple: ",",
+    label: ".",
+    matrix: ";"
+  }[options.style] || "&";
+  if (options.style !== "deepObject" && options.explode === false) {
+    for (const k in value) {
+      values.push(k, options.allowReserved === true ? value[k] : encodeURIComponent(value[k]));
+    }
+    const final2 = values.join(",");
+    switch (options.style) {
+      case "form": {
+        return `${name}=${final2}`;
+      }
+      case "label": {
+        return `.${final2}`;
+      }
+      case "matrix": {
+        return `;${name}=${final2}`;
+      }
+      default: {
+        return final2;
+      }
+    }
+  }
+  for (const k in value) {
+    const finalName = options.style === "deepObject" ? `${name}[${k}]` : k;
+    values.push(serializePrimitiveParam(finalName, value[k], options));
+  }
+  const final = values.join(joiner);
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${final}` : final;
+}
+function serializeArrayParam(name, value, options) {
+  if (!Array.isArray(value)) {
+    return "";
+  }
+  if (options.explode === false) {
+    const joiner2 = { form: ",", spaceDelimited: "%20", pipeDelimited: "|" }[options.style] || ",";
+    const final = (options.allowReserved === true ? value : value.map((v) => encodeURIComponent(v))).join(joiner2);
+    switch (options.style) {
+      case "simple": {
+        return final;
+      }
+      case "label": {
+        return `.${final}`;
+      }
+      case "matrix": {
+        return `;${name}=${final}`;
+      }
+      // case "spaceDelimited":
+      // case "pipeDelimited":
+      default: {
+        return `${name}=${final}`;
+      }
+    }
+  }
+  const joiner = { simple: ",", label: ".", matrix: ";" }[options.style] || "&";
+  const values = [];
+  for (const v of value) {
+    if (options.style === "simple" || options.style === "label") {
+      values.push(options.allowReserved === true ? v : encodeURIComponent(v));
+    } else {
+      values.push(serializePrimitiveParam(name, v, options));
+    }
+  }
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${values.join(joiner)}` : values.join(joiner);
+}
+function createQuerySerializer(options) {
+  return function querySerializer(queryParams) {
+    const search2 = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        if (Array.isArray(value)) {
+          if (value.length === 0) {
+            continue;
+          }
+          search2.push(
+            serializeArrayParam(name, value, {
+              style: "form",
+              explode: true,
+              ...options?.array,
+              allowReserved: options?.allowReserved || false
+            })
           );
-        } catch (error46) {
-          throw new Error(
-            `Failed to initialize embedding model ${this.modelName}: ${error46 instanceof Error ? error46.message : String(error46)}`
+          continue;
+        }
+        if (typeof value === "object") {
+          search2.push(
+            serializeObjectParam(name, value, {
+              style: "deepObject",
+              explode: true,
+              ...options?.object,
+              allowReserved: options?.allowReserved || false
+            })
           );
+          continue;
+        }
+        search2.push(serializePrimitiveParam(name, value, options));
+      }
+    }
+    return search2.join("&");
+  };
+}
+function defaultPathSerializer(pathname, pathParams) {
+  let nextURL = pathname;
+  for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
+    let name = match.substring(1, match.length - 1);
+    let explode = false;
+    let style = "simple";
+    if (name.endsWith("*")) {
+      explode = true;
+      name = name.substring(0, name.length - 1);
+    }
+    if (name.startsWith(".")) {
+      style = "label";
+      name = name.substring(1);
+    } else if (name.startsWith(";")) {
+      style = "matrix";
+      name = name.substring(1);
+    }
+    if (!pathParams || pathParams[name] === void 0 || pathParams[name] === null) {
+      continue;
+    }
+    const value = pathParams[name];
+    if (Array.isArray(value)) {
+      nextURL = nextURL.replace(match, serializeArrayParam(name, value, { style, explode }));
+      continue;
+    }
+    if (typeof value === "object") {
+      nextURL = nextURL.replace(match, serializeObjectParam(name, value, { style, explode }));
+      continue;
+    }
+    if (style === "matrix") {
+      nextURL = nextURL.replace(match, `;${serializePrimitiveParam(name, value)}`);
+      continue;
+    }
+    nextURL = nextURL.replace(match, style === "label" ? `.${encodeURIComponent(value)}` : encodeURIComponent(value));
+  }
+  return nextURL;
+}
+function defaultBodySerializer(body, headers) {
+  if (body instanceof FormData) {
+    return body;
+  }
+  if (headers) {
+    const contentType = headers.get instanceof Function ? headers.get("Content-Type") ?? headers.get("content-type") : headers["Content-Type"] ?? headers["content-type"];
+    if (contentType === "application/x-www-form-urlencoded") {
+      return new URLSearchParams(body).toString();
+    }
+  }
+  return JSON.stringify(body);
+}
+function createFinalURL(pathname, options) {
+  let finalURL = `${options.baseUrl}${pathname}`;
+  if (options.params?.path) {
+    finalURL = options.pathSerializer(finalURL, options.params.path);
+  }
+  let search2 = options.querySerializer(options.params.query ?? {});
+  if (search2.startsWith("?")) {
+    search2 = search2.substring(1);
+  }
+  if (search2) {
+    finalURL += `?${search2}`;
+  }
+  return finalURL;
+}
+function mergeHeaders(...allHeaders) {
+  const finalHeaders = new Headers();
+  for (const h of allHeaders) {
+    if (!h || typeof h !== "object") {
+      continue;
+    }
+    const iterator = h instanceof Headers ? h.entries() : Object.entries(h);
+    for (const [k, v] of iterator) {
+      if (v === null) {
+        finalHeaders.delete(k);
+      } else if (Array.isArray(v)) {
+        for (const v2 of v) {
+          finalHeaders.append(k, v2);
         }
+      } else if (v !== void 0) {
+        finalHeaders.set(k, v);
+      }
+    }
+  }
+  return finalHeaders;
+}
+function removeTrailingSlash(url2) {
+  if (url2.endsWith("/")) {
+    return url2.substring(0, url2.length - 1);
+  }
+  return url2;
+}
+var PATH_PARAM_RE, supportsRequestInitExt;
+var init_dist = __esm({
+  "../../node_modules/.pnpm/openapi-fetch@0.17.0/node_modules/openapi-fetch/dist/index.mjs"() {
+    "use strict";
+    PATH_PARAM_RE = /\{[^{}]+\}/g;
+    supportsRequestInitExt = () => {
+      return typeof process === "object" && Number.parseInt(process?.versions?.node?.substring(0, 2)) >= 18 && process.versions.undici;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@antfly+sdk@0.0.14/node_modules/@antfly/sdk/dist/index.js
+var AntflyClient;
+var init_dist2 = __esm({
+  "../../node_modules/.pnpm/@antfly+sdk@0.0.14/node_modules/@antfly/sdk/dist/index.js"() {
+    "use strict";
+    init_dist();
+    AntflyClient = class {
+      constructor(config2) {
+        this.tables = {
+          /**
+           * List all tables
+           */
+          list: async (params) => {
+            const { data, error: error46 } = await this.client.GET("/tables", {
+              params: params ? { query: params } : void 0
+            });
+            if (error46) throw new Error(`Failed to list tables: ${error46.error}`);
+            return data;
+          },
+          /**
+           * Get table details and status
+           */
+          get: async (tableName) => {
+            const { data, error: error46 } = await this.client.GET("/tables/{tableName}", {
+              params: { path: { tableName } }
+            });
+            if (error46) throw new Error(`Failed to get table: ${error46.error}`);
+            return data;
+          },
+          /**
+           * Create a new table
+           */
+          create: async (tableName, config3 = {}) => {
+            const { data, error: error46 } = await this.client.POST("/tables/{tableName}", {
+              params: { path: { tableName } },
+              body: config3
+            });
+            if (error46) throw new Error(`Failed to create table: ${error46.error}`);
+            return data;
+          },
+          /**
+           * Drop a table
+           */
+          drop: async (tableName) => {
+            const { error: error46 } = await this.client.DELETE("/tables/{tableName}", {
+              params: { path: { tableName } }
+            });
+            if (error46) throw new Error(`Failed to drop table: ${error46.error}`);
+            return true;
+          },
+          /**
+           * Update schema for a table
+           */
+          updateSchema: async (tableName, config3) => {
+            const { data, error: error46 } = await this.client.PUT("/tables/{tableName}/schema", {
+              params: { path: { tableName } },
+              body: config3
+            });
+            if (error46) throw new Error(`Failed to update table schema: ${error46.error}`);
+            return data;
+          },
+          /**
+           * Query a specific table
+           */
+          query: async (tableName, request) => {
+            return this.performQuery("/tables/{tableName}/query", request, tableName);
+          },
+          /**
+           * Execute multiple queries on a specific table
+           */
+          multiquery: async (tableName, requests) => {
+            return this.performMultiquery("/tables/{tableName}/query", requests, tableName);
+          },
+          /**
+           * Perform batch operations on a table
+           */
+          batch: async (tableName, request) => {
+            const { data, error: error46 } = await this.client.POST("/tables/{tableName}/batch", {
+              params: { path: { tableName } },
+              // @ts-expect-error Our BatchRequest type allows any object shape for inserts
+              body: request
+            });
+            if (error46) throw new Error(`Batch operation failed: ${error46.error}`);
+            return data;
+          },
+          /**
+           * Backup a table
+           */
+          backup: async (tableName, request) => {
+            const { data, error: error46 } = await this.client.POST("/tables/{tableName}/backup", {
+              params: { path: { tableName } },
+              body: request
+            });
+            if (error46) throw new Error(`Backup failed: ${error46.error}`);
+            return data;
+          },
+          /**
+           * Restore a table from backup
+           */
+          restore: async (tableName, request) => {
+            const { data, error: error46 } = await this.client.POST("/tables/{tableName}/restore", {
+              params: { path: { tableName } },
+              body: request
+            });
+            if (error46) throw new Error(`Restore failed: ${error46.error}`);
+            return data;
+          },
+          /**
+           * Lookup a specific key in a table
+           * @param tableName - Name of the table
+           * @param key - Key of the record to lookup
+           * @param options - Optional parameters
+           * @param options.fields - Comma-separated list of fields to include (e.g., "title,author,metadata.tags")
+           */
+          lookup: async (tableName, key, options) => {
+            const { data, error: error46 } = await this.client.GET("/tables/{tableName}/lookup/{key}", {
+              params: {
+                path: { tableName, key },
+                query: options?.fields ? { fields: options.fields } : void 0
+              }
+            });
+            if (error46) throw new Error(`Key lookup failed: ${error46.error}`);
+            return data;
+          },
+          /**
+           * Scan keys in a table within a key range
+           * Returns documents as an async iterable, streaming results as NDJSON.
+           * @param tableName - Name of the table
+           * @param request - Scan request with optional key range, field projection, and filtering
+           * @returns AsyncGenerator yielding documents with their keys
+           */
+          scan: (tableName, request) => {
+            const config3 = this.config;
+            const authHeader = this.getAuthHeader();
+            async function* scanGenerator() {
+              const headers = {
+                "Content-Type": "application/json",
+                Accept: "application/x-ndjson"
+              };
+              if (authHeader) {
+                headers.Authorization = authHeader;
+              }
+              Object.assign(headers, config3.headers);
+              const response = await fetch(`${config3.baseUrl}/tables/${tableName}/lookup`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(request || {})
+              });
+              if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Scan failed: ${response.status} ${errorText}`);
+              }
+              if (!response.body) {
+                throw new Error("Response body is null");
+              }
+              const reader = response.body.getReader();
+              const decoder = new TextDecoder();
+              let buffer = "";
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                  if (line.trim()) {
+                    yield JSON.parse(line);
+                  }
+                }
+              }
+              if (buffer.trim()) {
+                yield JSON.parse(buffer);
+              }
+            }
+            return scanGenerator();
+          },
+          /**
+           * Scan keys in a table and collect all results into an array
+           * Convenience method that consumes the scan AsyncGenerator
+           * @param tableName - Name of the table
+           * @param request - Scan request with optional key range, field projection, and filtering
+           * @returns Promise with array of all matching documents
+           */
+          scanAll: async (tableName, request) => {
+            const results = [];
+            for await (const doc of this.tables.scan(tableName, request)) {
+              results.push(doc);
+            }
+            return results;
+          }
+        };
+        this.indexes = {
+          /**
+           * List all indexes for a table
+           */
+          list: async (tableName) => {
+            const { data, error: error46 } = await this.client.GET("/tables/{tableName}/indexes", {
+              params: { path: { tableName } }
+            });
+            if (error46) throw new Error(`Failed to list indexes: ${error46.error}`);
+            return data;
+          },
+          /**
+           * Get index details
+           */
+          get: async (tableName, indexName) => {
+            const { data, error: error46 } = await this.client.GET("/tables/{tableName}/indexes/{indexName}", {
+              params: { path: { tableName, indexName } }
+            });
+            if (error46) throw new Error(`Failed to get index: ${error46.error}`);
+            return data;
+          },
+          /**
+           * Create a new index
+           */
+          create: async (tableName, config3) => {
+            const { error: error46 } = await this.client.POST("/tables/{tableName}/indexes/{indexName}", {
+              params: { path: { tableName, indexName: config3.name } },
+              body: config3
+            });
+            if (error46) throw new Error(`Failed to create index: ${error46.error}`);
+            return true;
+          },
+          /**
+           * Drop an index
+           */
+          drop: async (tableName, indexName) => {
+            const { error: error46 } = await this.client.DELETE("/tables/{tableName}/indexes/{indexName}", {
+              params: { path: { tableName, indexName } }
+            });
+            if (error46) throw new Error(`Failed to drop index: ${error46.error}`);
+            return true;
+          }
+        };
+        this.users = {
+          /**
+           * Get current authenticated user
+           */
+          getCurrentUser: async () => {
+            const { data, error: error46 } = await this.client.GET("/users/me");
+            if (error46) throw new Error(`Failed to get current user: ${error46.error}`);
+            return data;
+          },
+          /**
+           * List all users
+           */
+          list: async () => {
+            const { data, error: error46 } = await this.client.GET("/users");
+            if (error46) throw new Error(`Failed to list users: ${error46.error}`);
+            return data;
+          },
+          /**
+           * Get user details
+           */
+          get: async (userName) => {
+            const { data, error: error46 } = await this.client.GET("/users/{userName}", {
+              params: { path: { userName } }
+            });
+            if (error46) throw new Error(`Failed to get user: ${error46.error}`);
+            return data;
+          },
+          /**
+           * Create a new user
+           */
+          create: async (userName, request) => {
+            const { data, error: error46 } = await this.client.POST("/users/{userName}", {
+              params: { path: { userName } },
+              body: request
+            });
+            if (error46) throw new Error(`Failed to create user: ${error46.error}`);
+            return data;
+          },
+          /**
+           * Delete a user
+           */
+          delete: async (userName) => {
+            const { error: error46 } = await this.client.DELETE("/users/{userName}", {
+              params: { path: { userName } }
+            });
+            if (error46) throw new Error(`Failed to delete user: ${error46.error}`);
+            return true;
+          },
+          /**
+           * Update user password
+           */
+          updatePassword: async (userName, newPassword) => {
+            const { data, error: error46 } = await this.client.PUT("/users/{userName}/password", {
+              params: { path: { userName } },
+              body: { new_password: newPassword }
+            });
+            if (error46) throw new Error(`Failed to update password: ${error46.error}`);
+            return data;
+          },
+          /**
+           * Get user permissions
+           */
+          getPermissions: async (userName) => {
+            const { data, error: error46 } = await this.client.GET("/users/{userName}/permissions", {
+              params: { path: { userName } }
+            });
+            if (error46) throw new Error(`Failed to get permissions: ${error46.error}`);
+            return data;
+          },
+          /**
+           * Add permission to user
+           */
+          addPermission: async (userName, permission) => {
+            const { data, error: error46 } = await this.client.POST("/users/{userName}/permissions", {
+              params: { path: { userName } },
+              body: permission
+            });
+            if (error46) throw new Error(`Failed to add permission: ${error46.error}`);
+            return data;
+          },
+          /**
+           * Remove permission from user
+           */
+          removePermission: async (userName, resource, resourceType) => {
+            const { error: error46 } = await this.client.DELETE("/users/{userName}/permissions", {
+              params: {
+                path: { userName },
+                query: { resource, resourceType }
+              }
+            });
+            if (error46) throw new Error(`Failed to remove permission: ${error46.error}`);
+            return true;
+          }
+        };
+        this.config = config2;
+        this.client = this.buildClient();
       }
       /**
-       * Generate embedding for a single text
+       * Build the Authorization header value from the auth config.
+       * Returns undefined if no auth is configured.
        */
-      async embed(text3) {
-        if (!this.pipeline) {
-          throw new Error("Embedder not initialized. Call initialize() first.");
-        }
-        try {
-          const options = {
-            pooling: "mean",
-            // Mean pooling
-            normalize: true
-            // L2 normalization
-          };
-          const output = await this.pipeline(text3, options);
-          const tensorOutput = output;
-          if (tensorOutput?.data) {
-            return Array.from(tensorOutput.data);
+      getAuthHeader() {
+        const auth = this.config.auth;
+        if (!auth) return void 0;
+        if ("type" in auth) {
+          switch (auth.type) {
+            case "basic":
+              return `Basic ${btoa(`${auth.username}:${auth.password}`)}`;
+            case "apiKey":
+              return `ApiKey ${btoa(`${auth.keyId}:${auth.keySecret}`)}`;
+            case "bearer":
+              return `Bearer ${auth.token}`;
           }
-          throw new Error("Unexpected output format from embedding model");
-        } catch (error46) {
-          throw new Error(
-            `Failed to generate embedding: ${error46 instanceof Error ? error46.message : String(error46)}`
-          );
         }
+        return `Basic ${btoa(`${auth.username}:${auth.password}`)}`;
       }
       /**
-       * Generate embeddings for multiple texts (batched for efficiency)
+       * Build the openapi-fetch client with current config.
        */
-      async embedBatch(texts) {
-        if (!this.pipeline) {
-          throw new Error("Embedder not initialized. Call initialize() first.");
-        }
-        if (texts.length === 0) {
-          return [];
+      buildClient() {
+        const headers = {
+          "Content-Type": "application/json",
+          ...this.config.headers
+        };
+        const authHeader = this.getAuthHeader();
+        if (authHeader) {
+          headers.Authorization = authHeader;
         }
-        try {
-          const embeddings = [];
-          for (let i = 0; i < texts.length; i += this.batchSize) {
-            const batch = texts.slice(i, i + this.batchSize);
-            const batchEmbeddings = await Promise.all(batch.map((text3) => this.embed(text3)));
-            embeddings.push(...batchEmbeddings);
+        return createClient({
+          baseUrl: this.config.baseUrl,
+          headers,
+          bodySerializer: (body) => {
+            if (typeof body === "string") {
+              return body;
+            }
+            return JSON.stringify(body);
           }
-          return embeddings;
-        } catch (error46) {
-          throw new Error(
-            `Failed to generate batch embeddings: ${error46 instanceof Error ? error46.message : String(error46)}`
-          );
+        });
+      }
+      setAuth(authOrUsername, password) {
+        if (typeof authOrUsername === "string" && password !== void 0) {
+          this.config.auth = { username: authOrUsername, password };
+        } else {
+          this.config.auth = authOrUsername;
         }
+        this.client = this.buildClient();
+      }
+      /**
+       * Get cluster status
+       */
+      async getStatus() {
+        const { data, error: error46 } = await this.client.GET("/status");
+        if (error46) throw new Error(`Failed to get status: ${error46.error}`);
+        return data;
       }
       /**
-       * Set batch size for batch processing
+       * Private helper for query requests to avoid code duplication
        */
-      setBatchSize(size) {
-        if (size < 1) {
-          throw new Error("Batch size must be at least 1");
+      async performQuery(path16, request, tableName) {
+        if (path16 === "/tables/{tableName}/query" && tableName) {
+          const { data, error: error46 } = await this.client.POST("/tables/{tableName}/query", {
+            params: { path: { tableName } },
+            body: request
+          });
+          if (error46) throw new Error(`Table query failed: ${error46.error}`);
+          return data;
+        } else {
+          const { data, error: error46 } = await this.client.POST("/query", {
+            body: request
+          });
+          if (error46) throw new Error(`Query failed: ${error46.error}`);
+          return data;
         }
-        this.batchSize = size;
       }
       /**
-       * Get current batch size
+       * Private helper for multiquery requests to avoid code duplication
        */
-      getBatchSize() {
-        return this.batchSize;
+      async performMultiquery(path16, requests, tableName) {
+        const ndjson = `${requests.map((request) => JSON.stringify(request)).join("\n")}
+`;
+        if (path16 === "/tables/{tableName}/query" && tableName) {
+          const { data, error: error46 } = await this.client.POST("/tables/{tableName}/query", {
+            params: { path: { tableName } },
+            body: ndjson,
+            headers: {
+              "Content-Type": "application/x-ndjson"
+            }
+          });
+          if (error46) throw new Error(`Table multi-query failed: ${error46.error}`);
+          return data;
+        } else {
+          const { data, error: error46 } = await this.client.POST("/query", {
+            body: ndjson,
+            headers: {
+              "Content-Type": "application/x-ndjson"
+            }
+          });
+          if (error46) throw new Error(`Multi-query failed: ${error46.error}`);
+          return data;
+        }
       }
-    };
-  }
-});
-
-// ../core/src/vector/store.ts
-var lancedb, LanceDBVectorStore;
-var init_store = __esm({
-  "../core/src/vector/store.ts"() {
-    "use strict";
-    lancedb = __toESM(require("@lancedb/lancedb"));
-    LanceDBVectorStore = class {
-      path;
-      tableName = "documents";
-      connection = null;
-      table = null;
-      constructor(path16, _dimension = 384) {
-        this.path = path16;
+      /**
+       * Global query operations
+       */
+      async query(request) {
+        const data = await this.performQuery("/query", request);
+        return data?.responses?.[0];
       }
       /**
-       * Initialize the vector store
+       * Execute multiple queries in a single request
        */
-      async initialize() {
-        if (this.connection) {
-          return;
-        }
-        try {
-          this.connection = await lancedb.connect(this.path);
-          const tableNames = await this.connection.tableNames();
-          if (tableNames.includes(this.tableName)) {
-            this.table = await this.connection.openTable(this.tableName);
-          }
-        } catch (error46) {
-          throw new Error(
-            `Failed to initialize LanceDB at ${this.path}: ${error46 instanceof Error ? error46.message : String(error46)}`
-          );
-        }
+      async multiquery(requests) {
+        return this.performMultiquery("/query", requests);
       }
       /**
-       * Add documents to the store using upsert (prevents duplicates)
+       * Private helper for Retrieval Agent requests to handle streaming and non-streaming responses
        */
-      async add(documents, embeddings) {
-        if (!this.connection) {
-          throw new Error("Store not initialized. Call initialize() first.");
+      async performRetrievalAgent(request, callbacks) {
+        const headers = {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream, application/json"
+        };
+        const authHeader = this.getAuthHeader();
+        if (authHeader) {
+          headers.Authorization = authHeader;
+        }
+        Object.assign(headers, this.config.headers);
+        const abortController = new AbortController();
+        const response = await fetch(`${this.config.baseUrl}/agents/retrieval`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(request),
+          signal: abortController.signal
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new Error(`Retrieval agent request failed: ${response.status} ${errorText}`);
         }
-        if (documents.length !== embeddings.length) {
-          throw new Error("Number of documents must match number of embeddings");
+        if (!response.body) {
+          throw new Error("Response body is null");
         }
-        if (documents.length === 0) {
-          return;
+        const contentType = response.headers.get("content-type") || "";
+        const isJSON = contentType.includes("application/json");
+        if (isJSON) {
+          const result = await response.json();
+          return result;
         }
-        try {
-          const data = documents.map((doc, i) => ({
-            id: doc.id,
-            text: doc.text,
-            vector: embeddings[i],
-            metadata: JSON.stringify(doc.metadata)
-          }));
-          if (!this.table) {
+        if (callbacks) {
+          const reader = response.body.getReader();
+          const decoder = new TextDecoder();
+          let buffer = "";
+          let currentEvent = "";
+          (async () => {
             try {
-              this.table = await this.connection.createTable(this.tableName, data);
-              await this.ensureIdIndex();
-            } catch (createError) {
-              if (createError instanceof Error && createError.message.includes("already exists")) {
-                this.table = await this.connection.openTable(this.tableName);
-                await this.table.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute(data);
-              } else {
-                throw createError;
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                  if (!line.trim()) {
+                    currentEvent = "";
+                    continue;
+                  }
+                  if (line.startsWith("event: ")) {
+                    currentEvent = line.slice(7).trim();
+                  } else if (line.startsWith("data: ")) {
+                    const data = line.slice(6).trim();
+                    try {
+                      switch (currentEvent) {
+                        case "classification":
+                          if (callbacks.onClassification) {
+                            callbacks.onClassification(JSON.parse(data));
+                          }
+                          break;
+                        case "reasoning":
+                          if (callbacks.onReasoning) {
+                            callbacks.onReasoning(JSON.parse(data));
+                          }
+                          break;
+                        case "clarification_required":
+                          if (callbacks.onClarificationRequired) {
+                            callbacks.onClarificationRequired(JSON.parse(data));
+                          }
+                          break;
+                        case "filter_applied":
+                          if (callbacks.onFilterApplied) {
+                            callbacks.onFilterApplied(JSON.parse(data));
+                          }
+                          break;
+                        case "search_executed":
+                          if (callbacks.onSearchExecuted) {
+                            callbacks.onSearchExecuted(JSON.parse(data));
+                          }
+                          break;
+                        case "hit":
+                          if (callbacks.onHit) {
+                            callbacks.onHit(JSON.parse(data));
+                          }
+                          break;
+                        case "generation":
+                          if (callbacks.onGeneration) {
+                            callbacks.onGeneration(JSON.parse(data));
+                          }
+                          break;
+                        case "step_started":
+                          if (callbacks.onStepStarted) {
+                            callbacks.onStepStarted(JSON.parse(data));
+                          }
+                          break;
+                        case "step_progress":
+                          if (callbacks.onStepProgress) {
+                            callbacks.onStepProgress(JSON.parse(data));
+                          }
+                          break;
+                        case "step_completed":
+                          if (callbacks.onStepCompleted) {
+                            callbacks.onStepCompleted(JSON.parse(data));
+                          }
+                          break;
+                        case "confidence":
+                          if (callbacks.onConfidence) {
+                            callbacks.onConfidence(JSON.parse(data));
+                          }
+                          break;
+                        case "followup":
+                          if (callbacks.onFollowup) {
+                            callbacks.onFollowup(JSON.parse(data));
+                          }
+                          break;
+                        case "eval":
+                          if (callbacks.onEvalResult) {
+                            callbacks.onEvalResult(JSON.parse(data));
+                          }
+                          break;
+                        case "done":
+                          if (callbacks.onDone) {
+                            callbacks.onDone(JSON.parse(data));
+                          }
+                          return;
+                        case "error":
+                          if (callbacks.onError) {
+                            callbacks.onError(JSON.parse(data));
+                          }
+                          throw new Error(data);
+                      }
+                    } catch (e) {
+                      console.warn("Failed to parse SSE data:", currentEvent, data, e);
+                    }
+                  }
+                }
+              }
+            } catch (error46) {
+              if (error46.name !== "AbortError") {
+                console.error("Retrieval agent streaming error:", error46);
               }
             }
-          } else {
-            await this.table.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute(data);
-          }
-        } catch (error46) {
-          throw new Error(
-            `Failed to add documents: ${error46 instanceof Error ? error46.message : String(error46)}`
-          );
+          })();
         }
+        return abortController;
       }
       /**
-       * Search for similar documents
+       * Retrieval Agent - Unified retrieval pipeline with optional classification, generation, and eval
+       * Supports pipeline mode (structured queries) and agentic mode (tool-calling with LLM)
+       * Configure steps.classification, steps.answer, steps.eval to enable additional pipeline stages
+       * @param request - Retrieval agent request with query, mode, and optional step configs
+       * @param callbacks - Optional callbacks for SSE events (classification, reasoning, hit, answer, citation, confidence, followup_question, eval, done, error)
+       * @returns Promise with RetrievalAgentResult (JSON) or AbortController (when streaming)
        */
-      async search(queryEmbedding, options = {}) {
-        if (!this.table) {
-          return [];
-        }
-        const { limit = 10, scoreThreshold = 0 } = options;
-        try {
-          const results = await this.table.search(queryEmbedding).limit(limit).toArray();
-          return results.map((result) => {
-            const distance = result._distance !== void 0 ? result._distance : Number.POSITIVE_INFINITY;
-            const score = Math.exp(-(distance * distance));
-            return {
-              id: result.id,
-              score,
-              metadata: JSON.parse(result.metadata)
-            };
-          }).filter((result) => result.score >= scoreThreshold);
-        } catch (error46) {
-          throw new Error(
-            `Failed to search: ${error46 instanceof Error ? error46.message : String(error46)}`
+      async retrievalAgent(request, callbacks) {
+        return this.performRetrievalAgent(request, callbacks);
+      }
+      /**
+       * Chat Agent - Multi-turn conversational retrieval with message history management.
+       * Wraps the retrieval agent with automatic message accumulation.
+       * @param userMessage - The user's message for this turn
+       * @param config - Chat configuration (generator, table, indexes, etc.)
+       * @param history - Previous conversation messages (pass result.messages from prior turns)
+       * @param callbacks - Optional streaming callbacks including chat-specific events
+       * @returns For streaming: { abortController, messages } where messages is a Promise.
+       *          For non-streaming: { result, messages }
+       */
+      async chatAgent(userMessage, config2, history = [], callbacks) {
+        const request = {
+          query: userMessage,
+          queries: [
+            {
+              table: config2.table,
+              semantic_search: userMessage,
+              indexes: config2.semanticIndexes,
+              limit: config2.limit ?? 10
+            }
+          ],
+          generator: config2.generator,
+          messages: [...history, { role: "user", content: userMessage }],
+          max_iterations: config2.maxIterations ?? 5,
+          stream: !!callbacks,
+          agent_knowledge: config2.agentKnowledge
+        };
+        if (config2.steps) {
+          request.steps = config2.steps;
+        }
+        if (callbacks) {
+          let answerText = "";
+          let resolveMessages;
+          const messagesPromise = new Promise((resolve4) => {
+            resolveMessages = resolve4;
+          });
+          const wrappedCallbacks = {
+            ...callbacks,
+            onGeneration: (chunk) => {
+              answerText += chunk;
+              callbacks.onGeneration?.(chunk);
+            },
+            onDone: (data) => {
+              const updatedMessages2 = [
+                ...history,
+                { role: "user", content: userMessage },
+                { role: "assistant", content: answerText }
+              ];
+              callbacks.onAssistantMessage?.(answerText);
+              callbacks.onMessagesUpdated?.(updatedMessages2);
+              callbacks.onDone?.(data);
+              resolveMessages(updatedMessages2);
+            }
+          };
+          const abortController = await this.performRetrievalAgent(
+            request,
+            wrappedCallbacks
           );
+          return { abortController, messages: messagesPromise };
         }
+        const result = await this.performRetrievalAgent(request);
+        const updatedMessages = result.messages?.length ? result.messages : [
+          ...history,
+          { role: "user", content: userMessage },
+          ...result.generation ? [{ role: "assistant", content: result.generation }] : []
+        ];
+        return { result, messages: updatedMessages };
       }
       /**
-       * Get all documents without semantic search (fast scan)
-       * Use this when you need all documents and don't need relevance ranking
+       * Query Builder Agent - Translates natural language into structured search queries
+       * Uses an LLM to generate optimized Bleve queries from user intent
+       * @param request - Query builder request with intent and optional table/schema context
+       * @returns Promise with QueryBuilderResult containing the generated query, explanation, and confidence
        */
-      async getAll(options = {}) {
-        if (!this.table) {
-          return [];
-        }
-        const { limit = 1e4 } = options;
+      async queryBuilderAgent(request) {
+        const { data, error: error46 } = await this.client.POST("/agents/query-builder", {
+          body: request
+        });
+        if (error46) throw new Error(`Query builder agent failed: ${error46.error}`);
+        return data;
+      }
+      /**
+       * Standalone evaluation for testing evaluators without running a query.
+       * Evaluates a generated output against ground truth using LLM-as-judge metrics.
+       * @param request - Eval request with evaluators, judge config, query, output, and ground truth
+       * @returns Evaluation result with scores for each evaluator
+       */
+      async evaluate(request) {
+        const { data, error: error46 } = await this.client.POST("/eval", {
+          body: request
+        });
+        if (error46) throw new Error(`Evaluation failed: ${error46.error}`);
+        return data;
+      }
+      /**
+       * Get the underlying OpenAPI client for advanced use cases
+       */
+      getRawClient() {
+        return this.client;
+      }
+    };
+  }
+});
+
+// ../core/src/vector/antfly-store.ts
+var MODEL_DIMENSIONS, DEFAULT_MODEL, DEFAULT_BASE_URL, BATCH_SIZE, AntflyVectorStore;
+var init_antfly_store = __esm({
+  "../core/src/vector/antfly-store.ts"() {
+    "use strict";
+    init_dist2();
+    MODEL_DIMENSIONS = {
+      "BAAI/bge-small-en-v1.5": 384,
+      "mxbai-embed-large-v1": 1024,
+      "nomic-ai/nomic-embed-text-v1.5": 768,
+      "openai/clip-vit-base-patch32": 512
+    };
+    DEFAULT_MODEL = "BAAI/bge-small-en-v1.5";
+    DEFAULT_BASE_URL = process.env.ANTFLY_URL ?? "http://localhost:18080/api/v1";
+    BATCH_SIZE = 500;
+    AntflyVectorStore = class {
+      path;
+      cfg;
+      client;
+      initialized = false;
+      constructor(config2) {
+        this.cfg = {
+          baseUrl: config2.baseUrl ?? DEFAULT_BASE_URL,
+          table: config2.table,
+          indexName: config2.indexName ?? "content",
+          template: config2.template ?? "{{text}}",
+          model: config2.model ?? DEFAULT_MODEL
+        };
+        this.path = `${this.cfg.baseUrl}/${this.cfg.table}`;
+        this.client = new AntflyClient({ baseUrl: this.cfg.baseUrl });
+      }
+      async initialize() {
+        if (this.initialized) return;
         try {
-          const results = await this.table.query().select(["id", "text", "metadata"]).limit(limit).toArray();
-          return results.map((result) => ({
-            id: result.id,
-            score: 1,
-            // No relevance score for full scan
-            metadata: JSON.parse(result.metadata)
-          }));
+          const tableNames = await this.listTableNames();
+          if (tableNames.includes(this.cfg.table)) {
+            await this.checkModelMismatch();
+          } else {
+            await this.createTableWithIndex();
+          }
+          this.initialized = true;
         } catch (error46) {
+          if (error46 instanceof Error && error46.message.includes("Model mismatch")) throw error46;
           throw new Error(
-            `Failed to get all documents: ${error46 instanceof Error ? error46.message : String(error46)}`
+            `Failed to initialize Antfly store (${this.cfg.table}): ${error46 instanceof Error ? error46.message : String(error46)}`
           );
         }
       }
       /**
-       * Find similar documents to a given document by ID
-       * Uses the document's existing embedding for efficient similarity search
+       * Add documents. Embeddings param is ignored — Antfly auto-embeds via Termite.
        */
-      async searchByDocumentId(documentId, options = {}) {
-        if (!this.table) {
-          return [];
+      async add(documents, _embeddings) {
+        if (documents.length === 0) return;
+        this.assertReady();
+        for (let i = 0; i < documents.length; i += BATCH_SIZE) {
+          const batch = documents.slice(i, i + BATCH_SIZE);
+          const inserts = {};
+          for (const doc of batch) {
+            inserts[doc.id] = { text: doc.text, metadata: JSON.stringify(doc.metadata) };
+          }
+          try {
+            await this.batchOp({ inserts });
+          } catch (error46) {
+            throw new Error(
+              `Failed to add documents (batch ${Math.floor(i / BATCH_SIZE) + 1}): ${error46 instanceof Error ? error46.message : String(error46)}`
+            );
+          }
         }
+      }
+      /**
+       * VectorStore interface method — throws. Use searchText() instead.
+       */
+      async search(_queryEmbedding, _options) {
+        throw new Error(
+          "AntflyVectorStore.search() does not accept pre-computed embeddings. Use searchText(query, options) instead \u2014 Antfly handles embedding internally."
+        );
+      }
+      /**
+       * Search by text using Antfly's hybrid search (BM25 + vector + RRF).
+       */
+      async searchText(query, options = {}) {
+        this.assertReady();
+        const { limit = 10, scoreThreshold = 0 } = options;
         try {
-          const results = await this.table.query().where(`id = '${documentId}'`).select(["id", "vector"]).limit(1).toArray();
-          if (results.length === 0) {
-            return [];
-          }
-          const documentEmbedding = results[0].vector;
-          return this.search(documentEmbedding, options);
+          const resp = await this.queryTable({
+            semantic_search: query,
+            indexes: [this.cfg.indexName],
+            limit
+          });
+          return this.extractHits(resp).map((hit) => ({
+            id: hit._id,
+            score: hit._score,
+            metadata: this.parseMetadata(hit._source)
+          })).filter((r) => r.score >= scoreThreshold);
         } catch (error46) {
           throw new Error(
-            `Failed to search by document ID: ${error46 instanceof Error ? error46.message : String(error46)}`
+            `Failed to search: ${error46 instanceof Error ? error46.message : String(error46)}`
           );
         }
       }
-      /**
-       * Get a document by ID
-       */
       async get(id) {
-        if (!this.table) {
-          return null;
-        }
+        this.assertReady();
         try {
-          const dummyVector = new Array(384).fill(0);
-          const results = await this.table.search(dummyVector).limit(1e4).toArray();
-          const result = results.find((r) => r.id === id);
-          if (!result) {
-            return null;
-          }
+          const result = await this.client.tables.lookup(this.cfg.table, id);
+          if (!result) return null;
           return {
-            id: result.id,
-            text: result.text,
-            metadata: JSON.parse(result.metadata)
+            id,
+            text: result.text ?? "",
+            metadata: this.parseRawMetadata(result.metadata)
           };
         } catch (error46) {
+          if (String(error46).includes("404") || String(error46).includes("not found")) return null;
           throw new Error(
             `Failed to get document: ${error46 instanceof Error ? error46.message : String(error46)}`
           );
         }
       }
-      /**
-       * Delete documents by ID
-       */
       async delete(ids) {
-        if (!this.table || ids.length === 0) {
-          return;
-        }
+        this.assertReady();
+        if (ids.length === 0) return;
         try {
-          const escapedIds = ids.map((id) => id.replace(/'/g, "''"));
-          const predicate = `id IN ('${escapedIds.join("', '")}')`;
-          await this.table.delete(predicate);
+          await this.batchOp({ deletes: ids });
         } catch (error46) {
           throw new Error(
             `Failed to delete documents: ${error46 instanceof Error ? error46.message : String(error46)}`
           );
         }
       }
-      /**
-       * Clear all documents from the store (destructive operation)
-       */
-      async clear() {
-        if (!this.connection) {
-          return;
+      async count() {
+        this.assertReady();
+        try {
+          const resp = await this.queryTable({ limit: 1 });
+          return resp?.hits?.total ?? 0;
+        } catch {
+          return 0;
         }
+      }
+      async getAll(options = {}) {
+        this.assertReady();
+        const { limit = 1e4 } = options;
         try {
-          if (this.table) {
-            await this.connection.dropTable("documents");
-            this.table = null;
-          }
+          const resp = await this.queryTable({ limit });
+          return this.extractHits(resp).map((hit) => ({
+            id: hit._id,
+            score: 1,
+            metadata: this.parseMetadata(hit._source)
+          }));
         } catch (error46) {
           throw new Error(
-            `Failed to clear vector store: ${error46 instanceof Error ? error46.message : String(error46)}`
+            `Failed to get all documents: ${error46 instanceof Error ? error46.message : String(error46)}`
           );
         }
       }
-      /**
-       * Count total documents
-       */
-      async count() {
-        if (!this.table) {
-          return 0;
-        }
+      async searchByDocumentId(documentId, options = {}) {
+        this.assertReady();
+        const doc = await this.get(documentId);
+        if (!doc) return [];
+        return this.searchText(doc.text, options);
+      }
+      async clear() {
+        this.assertReady();
         try {
-          return await this.table.countRows();
+          await this.client.tables.drop(this.cfg.table);
+          await this.createTableWithIndex();
         } catch (error46) {
           throw new Error(
-            `Failed to count documents: ${error46 instanceof Error ? error46.message : String(error46)}`
+            `Failed to clear store: ${error46 instanceof Error ? error46.message : String(error46)}`
           );
         }
       }
-      /**
-       * Optimize the vector store (compact fragments, update indices)
-       */
       async optimize() {
-        if (!this.table) {
-          return;
-        }
+      }
+      async close() {
+        this.initialized = false;
+      }
+      getModelInfo() {
+        return {
+          dimension: MODEL_DIMENSIONS[this.cfg.model] ?? 384,
+          modelName: this.cfg.model
+        };
+      }
+      async getStorageSize() {
         try {
-          await this.table.optimize();
-        } catch (error46) {
-          throw new Error(
-            `Failed to optimize: ${error46 instanceof Error ? error46.message : String(error46)}`
-          );
+          const info = await this.getTableInfo();
+          return info?.storage_status?.disk_usage ?? 0;
+        } catch {
+          return 0;
         }
       }
-      /**
-       * Ensure scalar index exists on 'id' column for fast upsert operations
-       */
-      async ensureIdIndex() {
-        if (!this.table) {
-          return;
+      // ── SDK boundary layer ──
+      // These methods isolate the SDK's loosely-typed API behind our own types.
+      async listTableNames() {
+        const raw = await this.client.tables.list();
+        const tables = raw;
+        if (!Array.isArray(tables)) return [];
+        return tables.map((t) => typeof t === "string" ? t : t.name);
+      }
+      async createTableWithIndex() {
+        const body = {
+          indexes: {
+            [this.cfg.indexName]: {
+              type: "embeddings",
+              template: this.cfg.template,
+              embedder: { provider: "termite", model: this.cfg.model }
+            }
+          }
+        };
+        await this.client.tables.create(this.cfg.table, body);
+      }
+      async getTableInfo() {
+        const raw = await this.client.tables.get(this.cfg.table);
+        return raw ?? null;
+      }
+      async queryTable(params) {
+        const raw = await this.client.query({
+          table: this.cfg.table,
+          ...params
+        });
+        return raw;
+      }
+      async batchOp(body) {
+        await this.client.tables.batch(this.cfg.table, body);
+      }
+      // ── Helpers ──
+      assertReady() {
+        if (!this.initialized) {
+          throw new Error("Store not initialized. Call initialize() first.");
         }
+      }
+      async checkModelMismatch() {
         try {
-          await this.table.createIndex("id");
+          const info = await this.getTableInfo();
+          const embeddingIndex = info?.indexes?.[this.cfg.indexName];
+          if (embeddingIndex?.embedder?.model && embeddingIndex.embedder.model !== this.cfg.model) {
+            throw new Error(
+              `Model mismatch: table "${this.cfg.table}" uses "${embeddingIndex.embedder.model}" but config specifies "${this.cfg.model}". Run \`dev index . --force\` to re-index with the new model.`
+            );
+          }
         } catch (error46) {
-          console.warn(
-            `Could not create index on 'id' column: ${error46 instanceof Error ? error46.message : String(error46)}`
-          );
+          if (error46 instanceof Error && error46.message.includes("Model mismatch")) throw error46;
         }
       }
-      /**
-       * Close the store
-       */
-      async close() {
-        this.table = null;
-        this.connection = null;
+      extractHits(resp) {
+        return resp?.hits?.hits ?? [];
+      }
+      parseMetadata(source) {
+        if (!source) return {};
+        const metadataField = source.metadata;
+        if (typeof metadataField === "string") {
+          try {
+            return JSON.parse(metadataField);
+          } catch {
+            return {};
+          }
+        }
+        if (metadataField && typeof metadataField === "object") {
+          return metadataField;
+        }
+        const { text: _, metadata: __, _timestamp: ___, ...rest } = source;
+        return rest;
+      }
+      parseRawMetadata(metadata) {
+        if (typeof metadata === "string") {
+          try {
+            return JSON.parse(metadata);
+          } catch {
+            return {};
+          }
+        }
+        if (metadata && typeof metadata === "object") {
+          return metadata;
+        }
+        return {};
       }
     };
   }
@@ -19525,160 +20634,117 @@ var init_types2 = __esm({
 // ../core/src/vector/index.ts
 var vector_exports = {};
 __export(vector_exports, {
-  LanceDBVectorStore: () => LanceDBVectorStore,
-  TransformersEmbedder: () => TransformersEmbedder,
+  AntflyVectorStore: () => AntflyVectorStore,
   VectorStorage: () => VectorStorage
 });
-var fs6, VectorStorage;
+function deriveTableName(storePath) {
+  const parts = storePath.replace(/\/$/, "").split("/");
+  const last = parts.at(-1) ?? "code";
+  const projectDir = parts.at(-2) ?? "default";
+  const project = projectDir.replace(/[^a-zA-Z0-9-]/g, "-").toLowerCase();
+  if (last === "vectors") return `dev-agent-${project}-code`;
+  if (last === "vectors-git") return `dev-agent-${project}-git`;
+  if (last === "vectors-github") return `dev-agent-${project}-github`;
+  return `dev-agent-${project}-${last.replace(/[^a-zA-Z0-9-]/g, "-")}`;
+}
+var VectorStorage;
 var init_vector = __esm({
   "../core/src/vector/index.ts"() {
     "use strict";
-    init_embedder();
-    init_store();
+    init_antfly_store();
     init_types2();
-    fs6 = __toESM(require("fs/promises"));
-    init_embedder();
-    init_store();
+    init_antfly_store();
     VectorStorage = class {
-      embedder;
       store;
       initialized = false;
       constructor(config2) {
-        const { storePath, embeddingModel = "Xenova/all-MiniLM-L6-v2", dimension = 384 } = config2;
-        this.embedder = new TransformersEmbedder(embeddingModel, dimension);
-        this.store = new LanceDBVectorStore(storePath, dimension);
+        const antflyConfig = {
+          table: deriveTableName(config2.storePath),
+          model: config2.embeddingModel
+        };
+        this.store = new AntflyVectorStore(antflyConfig);
       }
       /**
-       * Initialize both embedder and store
-       * @param options Optional initialization options
-       * @param options.skipEmbedder Skip embedder initialization (useful for read-only operations)
+       * Initialize the storage.
+       *
+       * The skipEmbedder option is accepted for backward compatibility but
+       * has no effect — Antfly handles embeddings internally.
        */
-      async initialize(options) {
-        if (this.initialized) {
-          return;
-        }
-        const { skipEmbedder = false } = options || {};
-        if (skipEmbedder) {
-          await this.store.initialize();
-        } else {
-          await Promise.all([this.embedder.initialize(), this.store.initialize()]);
-        }
+      async initialize(_options) {
+        if (this.initialized) return;
+        await this.store.initialize();
         this.initialized = true;
       }
       /**
-       * Ensure embedder is initialized (lazy initialization for search operations)
-       */
-      async ensureEmbedder() {
-        if (!this.embedder) {
-          throw new Error("Embedder not available");
-        }
-        await this.embedder.initialize();
-      }
-      /**
-       * Add documents to the store (automatically generates embeddings)
+       * Add documents (Antfly generates embeddings automatically via Termite)
        */
       async addDocuments(documents) {
-        if (!this.initialized) {
-          throw new Error("VectorStorage not initialized. Call initialize() first.");
-        }
-        if (documents.length === 0) {
-          return;
-        }
-        const texts = documents.map((doc) => doc.text);
-        const embeddings = await this.embedder.embedBatch(texts);
-        await this.store.add(documents, embeddings);
+        this.assertReady();
+        if (documents.length === 0) return;
+        await this.store.add(documents);
       }
       /**
-       * Search for similar documents using natural language query
+       * Search using hybrid search (BM25 + vector + RRF)
        */
       async search(query, options) {
-        if (!this.initialized) {
-          throw new Error("VectorStorage not initialized. Call initialize() first.");
-        }
-        await this.ensureEmbedder();
-        const queryEmbedding = await this.embedder.embed(query);
-        return this.store.search(queryEmbedding, options);
+        this.assertReady();
+        return this.store.searchText(query, options);
       }
       /**
-       * Find similar documents to a given document by ID
-       * More efficient than search() as it reuses the document's existing embedding
+       * Find documents similar to a given document by ID
        */
       async searchByDocumentId(documentId, options) {
-        if (!this.initialized) {
-          throw new Error("VectorStorage not initialized. Call initialize() first.");
-        }
+        this.assertReady();
         return this.store.searchByDocumentId(documentId, options);
       }
       /**
-       * Get all documents without semantic search (fast scan)
-       * Use this when you need all documents and don't need relevance ranking
-       * This is 10-20x faster than search() as it skips embedding generation
+       * Get all documents without semantic search (full scan)
        */
       async getAll(options) {
-        if (!this.initialized) {
-          throw new Error("VectorStorage not initialized. Call initialize() first.");
-        }
+        this.assertReady();
         return this.store.getAll(options);
       }
       /**
        * Get a document by ID
        */
       async getDocument(id) {
-        if (!this.initialized) {
-          throw new Error("VectorStorage not initialized. Call initialize() first.");
-        }
+        this.assertReady();
         return this.store.get(id);
       }
       /**
        * Delete documents by ID
        */
       async deleteDocuments(ids) {
-        if (!this.initialized) {
-          throw new Error("VectorStorage not initialized. Call initialize() first.");
-        }
+        this.assertReady();
         await this.store.delete(ids);
       }
       /**
-       * Clear all documents from the store (destructive operation)
-       * Used for force re-indexing
+       * Clear all documents (destructive — used for force re-indexing)
        */
       async clear() {
-        if (!this.initialized) {
-          throw new Error("VectorStorage not initialized. Call initialize() first.");
-        }
+        this.assertReady();
         await this.store.clear();
       }
       /**
        * Get statistics about the vector store
        */
       async getStats() {
-        if (!this.initialized) {
-          throw new Error("VectorStorage not initialized. Call initialize() first.");
-        }
+        this.assertReady();
+        const modelInfo = this.store.getModelInfo();
         const totalDocuments = await this.store.count();
-        let storageSize = 0;
-        try {
-          const storePath = this.store.path;
-          const stats = await fs6.stat(storePath);
-          storageSize = stats.size;
-        } catch {
-          storageSize = 0;
-        }
+        const storageSize = await this.store.getStorageSize();
         return {
           totalDocuments,
           storageSize,
-          dimension: this.embedder.dimension,
-          modelName: this.embedder.modelName
+          dimension: modelInfo.dimension,
+          modelName: modelInfo.modelName
         };
       }
       /**
-       * Optimize the vector store (compact fragments, update indices)
-       * Call this after bulk indexing operations for better performance
+       * Optimize the store (no-op for Antfly — manages compaction internally)
        */
       async optimize() {
-        if (!this.initialized) {
-          throw new Error("VectorStorage not initialized. Call initialize() first.");
-        }
+        this.assertReady();
         await this.store.optimize();
       }
       /**
@@ -19688,6 +20754,11 @@ var init_vector = __esm({
         await this.store.close();
         this.initialized = false;
       }
+      assertReady() {
+        if (!this.initialized) {
+          throw new Error("VectorStorage not initialized. Call initialize() first.");
+        }
+      }
     };
   }
 });
@@ -33755,12 +34826,12 @@ var indexer_exports = {};
 __export(indexer_exports, {
   RepositoryIndexer: () => RepositoryIndexer
 });
-var crypto, fs7, path9, INDEXER_VERSION, DEFAULT_STATE_PATH, RepositoryIndexer;
+var crypto, fs6, path9, INDEXER_VERSION, DEFAULT_STATE_PATH, RepositoryIndexer;
 var init_indexer2 = __esm({
   "../core/src/indexer/index.ts"() {
     "use strict";
     crypto = __toESM(require("crypto"));
-    fs7 = __toESM(require("fs/promises"));
+    fs6 = __toESM(require("fs/promises"));
     path9 = __toESM(require("path"));
     init_collector();
     init_scanner();
@@ -34379,7 +35450,7 @@ var init_indexer2 = __esm({
        */
       async loadState() {
         try {
-          const stateContent = await fs7.readFile(this.config.statePath, "utf-8");
+          const stateContent = await fs6.readFile(this.config.statePath, "utf-8");
           const data = JSON.parse(stateContent);
           const validation = validateIndexerState(data);
           if (!validation.success) {
@@ -34408,8 +35479,8 @@ var init_indexer2 = __esm({
         if (!validation.success) {
           console.warn(`Indexer state validation warning: ${validation.error}`);
         }
-        await fs7.mkdir(path9.dirname(this.config.statePath), { recursive: true });
-        await fs7.writeFile(this.config.statePath, JSON.stringify(this.state, null, 2), "utf-8");
+        await fs6.mkdir(path9.dirname(this.config.statePath), { recursive: true });
+        await fs6.writeFile(this.config.statePath, JSON.stringify(this.state, null, 2), "utf-8");
       }
       /**
        * Update state with newly indexed documents
@@ -34439,11 +35510,11 @@ var init_indexer2 = __esm({
         }
         for (const [filePath, docs] of fileMap) {
           const fullPath = path9.join(this.config.repositoryPath, filePath);
-          let stat4;
+          let stat3;
           let hash2 = "";
           try {
-            stat4 = await fs7.stat(fullPath);
-            const content3 = await fs7.readFile(fullPath, "utf-8");
+            stat3 = await fs6.stat(fullPath);
+            const content3 = await fs6.readFile(fullPath, "utf-8");
             hash2 = crypto.createHash("sha256").update(content3).digest("hex");
           } catch {
             continue;
@@ -34451,10 +35522,10 @@ var init_indexer2 = __esm({
           const metadata = {
             path: filePath,
             hash: hash2,
-            lastModified: stat4.mtime,
+            lastModified: stat3.mtime,
             lastIndexed: /* @__PURE__ */ new Date(),
             documentIds: docs.map((d) => d.id),
-            size: stat4.size,
+            size: stat3.size,
             language: docs[0]?.language || "unknown"
           };
           this.state.files[filePath] = metadata;
@@ -34489,11 +35560,11 @@ var init_indexer2 = __esm({
         for (const [filePath, metadata] of Object.entries(this.state.files)) {
           const fullPath = path9.join(this.config.repositoryPath, filePath);
           try {
-            const stat4 = await fs7.stat(fullPath);
-            if (since && stat4.mtime <= since) {
+            const stat3 = await fs6.stat(fullPath);
+            if (since && stat3.mtime <= since) {
               continue;
             }
-            const content3 = await fs7.readFile(fullPath, "utf-8");
+            const content3 = await fs6.readFile(fullPath, "utf-8");
             const currentHash = crypto.createHash("sha256").update(content3).digest("hex");
             if (currentHash !== metadata.hash) {
               changed.push(filePath);
@@ -35169,7 +36240,7 @@ __export(store_exports, {
   MetricsStore: () => MetricsStore
 });
 var crypto2, import_better_sqlite3, MetricsStore;
-var init_store2 = __esm({
+var init_store = __esm({
   "../core/src/metrics/store.ts"() {
     "use strict";
     crypto2 = __toESM(require("crypto"));
@@ -35494,7 +36565,7 @@ var init_metrics = __esm({
     init_analytics();
     init_collector();
     init_schema();
-    init_store2();
+    init_store();
     init_types5();
   }
 });
@@ -38142,11 +39213,11 @@ var init_utils3 = __esm({
 });
 
 // ../subagents/src/github/indexer.ts
-var fs8, path11, INDEXER_VERSION2, DEFAULT_STATE_PATH2, DEFAULT_STALE_THRESHOLD, GitHubIndexer;
+var fs7, path11, INDEXER_VERSION2, DEFAULT_STATE_PATH2, DEFAULT_STALE_THRESHOLD, GitHubIndexer;
 var init_indexer4 = __esm({
   "../subagents/src/github/indexer.ts"() {
     "use strict";
-    fs8 = __toESM(require("fs/promises"));
+    fs7 = __toESM(require("fs/promises"));
     path11 = __toESM(require("path"));
     init_src3();
     init_utils3();
@@ -38454,7 +39525,7 @@ ${doc.body}`,
        */
       async loadState() {
         try {
-          const stateContent = await fs8.readFile(this.statePath, "utf-8");
+          const stateContent = await fs7.readFile(this.statePath, "utf-8");
           this.state = JSON.parse(stateContent);
           if (this.state?.version !== INDEXER_VERSION2) {
             console.warn(`State version mismatch: ${this.state?.version} !== ${INDEXER_VERSION2}`);
@@ -38471,8 +39542,8 @@ ${doc.body}`,
         if (!this.state) {
           return;
         }
-        await fs8.mkdir(path11.dirname(this.statePath), { recursive: true });
-        await fs8.writeFile(this.statePath, JSON.stringify(this.state, null, 2), "utf-8");
+        await fs7.mkdir(path11.dirname(this.statePath), { recursive: true });
+        await fs7.writeFile(this.statePath, JSON.stringify(this.state, null, 2), "utf-8");
       }
     };
   }
@@ -39853,7 +40924,7 @@ async function getStoragePath(repositoryPath2) {
   return path12.join(baseStorageDir, pathHash);
 }
 async function ensureStorageDirectory(storagePath) {
-  await fs9.mkdir(storagePath, { recursive: true });
+  await fs8.mkdir(storagePath, { recursive: true });
 }
 function getStorageFilePaths(storagePath) {
   return {
@@ -39864,13 +40935,13 @@ function getStorageFilePaths(storagePath) {
     metrics: path12.join(storagePath, "metrics.db")
   };
 }
-var import_node_child_process6, crypto3, fs9, os, path12;
+var import_node_child_process6, crypto3, fs8, os, path12;
 var init_path = __esm({
   "../core/src/storage/path.ts"() {
     "use strict";
     import_node_child_process6 = require("child_process");
     crypto3 = __toESM(require("crypto"));
-    fs9 = __toESM(require("fs/promises"));
+    fs8 = __toESM(require("fs/promises"));
     os = __toESM(require("os"));
     path12 = __toESM(require("path"));
   }
@@ -40145,7 +41216,7 @@ var init_health_service = __esm({
         });
       }
       defaultMetricsStoreFactory(path16, logger) {
-        const { MetricsStore: Store } = (init_store2(), __toCommonJS(store_exports));
+        const { MetricsStore: Store } = (init_store(), __toCommonJS(store_exports));
         return new Store(path16, logger);
       }
       /**
@@ -40269,7 +41340,7 @@ var init_metrics_service = __esm({
        * Default factory that creates a real MetricsStore
        */
       defaultStoreFactory(path16, logger) {
-        const { MetricsStore: Store } = (init_store2(), __toCommonJS(store_exports));
+        const { MetricsStore: Store } = (init_store(), __toCommonJS(store_exports));
         return new Store(path16, logger);
       }
       /**
@@ -40397,28 +41468,28 @@ async function findTestFile(sourcePath, repositoryPath2) {
   for (const testPath of patterns) {
     const fullPath = path13.join(repositoryPath2, testPath);
     try {
-      await fs10.access(fullPath);
+      await fs9.access(fullPath);
       return testPath;
     } catch {
     }
   }
   return null;
 }
-var fs10, path13;
+var fs9, path13;
 var init_test_utils = __esm({
   "../core/src/utils/test-utils.ts"() {
     "use strict";
-    fs10 = __toESM(require("fs/promises"));
+    fs9 = __toESM(require("fs/promises"));
     path13 = __toESM(require("path"));
   }
 });
 
 // ../core/src/services/pattern-analysis-service.ts
-var fs11, path14, PatternAnalysisService;
+var fs10, path14, PatternAnalysisService;
 var init_pattern_analysis_service = __esm({
   "../core/src/services/pattern-analysis-service.ts"() {
     "use strict";
-    fs11 = __toESM(require("fs/promises"));
+    fs10 = __toESM(require("fs/promises"));
     path14 = __toESM(require("path"));
     init_scanner();
     init_test_utils();
@@ -40505,12 +41576,12 @@ var init_pattern_analysis_service = __esm({
        */
       async analyzeFileWithDocs(filePath, documents) {
         const fullPath = path14.join(this.config.repositoryPath, filePath);
-        const [stat4, content3] = await Promise.all([fs11.stat(fullPath), fs11.readFile(fullPath, "utf-8")]);
+        const [stat3, content3] = await Promise.all([fs10.stat(fullPath), fs10.readFile(fullPath, "utf-8")]);
         const lines = content3.split("\n").length;
         return {
           fileSize: {
             lines,
-            bytes: stat4.size
+            bytes: stat3.size
           },
           testing: await this.analyzeTesting(filePath),
           importStyle: await this.analyzeImportsFromFile(filePath, documents),
@@ -40543,7 +41614,7 @@ var init_pattern_analysis_service = __esm({
        */
       async analyzeImportsFromFile(filePath, _documents) {
         const fullPath = path14.join(this.config.repositoryPath, filePath);
-        const content3 = await fs11.readFile(fullPath, "utf-8");
+        const content3 = await fs10.readFile(fullPath, "utf-8");
         return this.analyzeImportsFromContent(content3);
       }
       /**
@@ -41101,7 +42172,7 @@ function getLastCommit(repositoryPath2) {
 async function loadMetadata(storagePath) {
   const metadataPath = path15.join(storagePath, "metadata.json");
   try {
-    const content3 = await fs12.readFile(metadataPath, "utf-8");
+    const content3 = await fs11.readFile(metadataPath, "utf-8");
     const data = JSON.parse(content3);
     const validated = validateRepositoryMetadata(data);
     return validated;
@@ -41128,8 +42199,8 @@ async function saveMetadata(storagePath, repositoryPath2, updates) {
       ...updates?.repository
     }
   };
-  await fs12.mkdir(storagePath, { recursive: true });
-  await fs12.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+  await fs11.mkdir(storagePath, { recursive: true });
+  await fs11.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
   return metadata;
 }
 async function updateIndexedStats(storagePath, stats) {
@@ -41141,12 +42212,12 @@ async function updateIndexedStats(storagePath, stats) {
     }
   });
 }
-var import_node_child_process7, fs12, path15, METADATA_VERSION;
+var import_node_child_process7, fs11, path15, METADATA_VERSION;
 var init_metadata2 = __esm({
   "../core/src/storage/metadata.ts"() {
     "use strict";
     import_node_child_process7 = require("child_process");
-    fs12 = __toESM(require("fs/promises"));
+    fs11 = __toESM(require("fs/promises"));
     path15 = __toESM(require("path"));
     init_path();
     init_validation2();
@@ -41290,6 +42361,7 @@ var init_utils5 = __esm({
 // ../core/src/index.ts
 var src_exports3 = {};
 __export(src_exports3, {
+  AntflyVectorStore: () => AntflyVectorStore,
   ApiServer: () => ApiServer,
   AsyncEventBus: () => AsyncEventBus,
   CodeMetadataSchema: () => CodeMetadataSchema,
@@ -41304,7 +42376,6 @@ __export(src_exports3, {
   GoScanner: () => GoScanner,
   HealthService: () => HealthService,
   HotspotSchema: () => HotspotSchema,
-  LanceDBVectorStore: () => LanceDBVectorStore,
   LocalGitExtractor: () => LocalGitExtractor,
   METRICS_SCHEMA_V1: () => METRICS_SCHEMA_V1,
   MarkdownScanner: () => MarkdownScanner,
@@ -41323,7 +42394,6 @@ __export(src_exports3, {
   SnapshotQuerySchema: () => SnapshotQuerySchema,
   StatsAggregator: () => StatsAggregator,
   StatsService: () => StatsService,
-  TransformersEmbedder: () => TransformersEmbedder,
   TypeScriptScanner: () => TypeScriptScanner,
   VectorStorage: () => VectorStorage,
   aggregateChangeFrequency: () => aggregateChangeFrequency,
@@ -57279,7 +58349,7 @@ var require_health_adapter = __commonJS({
     })();
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.HealthAdapter = void 0;
-    var fs13 = __importStar(require("fs/promises"));
+    var fs12 = __importStar(require("fs/promises"));
     var index_js_1 = require_schemas3();
     var tool_adapter_1 = require_tool_adapter();
     var validation_js_1 = require_validation();
@@ -57370,14 +58440,14 @@ ${content3}`
       }
       async checkVectorStorage(verbose) {
         try {
-          const stats = await fs13.stat(this.config.vectorStorePath);
+          const stats = await fs12.stat(this.config.vectorStorePath);
           if (!stats.isDirectory()) {
             return {
               status: "fail",
               message: "Vector storage path is not a directory"
             };
           }
-          const files = await fs13.readdir(this.config.vectorStorePath);
+          const files = await fs12.readdir(this.config.vectorStorePath);
           const hasData = files.length > 0;
           if (!hasData) {
             return {
@@ -57401,7 +58471,7 @@ ${content3}`
       }
       async checkRepository(verbose) {
         try {
-          const stats = await fs13.stat(this.config.repositoryPath);
+          const stats = await fs12.stat(this.config.repositoryPath);
           if (!stats.isDirectory()) {
             return {
               status: "fail",
@@ -57409,7 +58479,7 @@ ${content3}`
             };
           }
           try {
-            await fs13.stat(`${this.config.repositoryPath}/.git`);
+            await fs12.stat(`${this.config.repositoryPath}/.git`);
             return {
               status: "pass",
               message: "Repository accessible and is a Git repository",
@@ -57438,7 +58508,7 @@ ${content3}`
           };
         }
         try {
-          const content3 = await fs13.readFile(this.config.githubStatePath, "utf-8");
+          const content3 = await fs12.readFile(this.config.githubStatePath, "utf-8");
           const state = JSON.parse(content3);
           const lastIndexed = state.lastIndexed ? new Date(state.lastIndexed) : null;
           const itemCount = state.items?.length ?? 0;
@@ -59118,7 +60188,7 @@ var require_related_files = __commonJS({
     exports2.findTestFile = findTestFile2;
     exports2.findRelatedTestFiles = findRelatedTestFiles;
     exports2.formatRelatedFiles = formatRelatedFiles;
-    var fs13 = __importStar(require("fs/promises"));
+    var fs12 = __importStar(require("fs/promises"));
     var path16 = __importStar(require("path"));
     exports2.DEFAULT_TEST_PATTERNS = [
       // Same directory: foo.ts -> foo.test.ts, foo.spec.ts
@@ -59127,7 +60197,7 @@ var require_related_files = __commonJS({
     ];
     async function fileExists(filePath) {
       try {
-        await fs13.access(filePath);
+        await fs12.access(filePath);
         return true;
       } catch {
         return false;
@@ -59392,7 +60462,7 @@ var require_status_adapter = __commonJS({
     })();
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.StatusAdapter = void 0;
-    var fs13 = __importStar(require("fs"));
+    var fs12 = __importStar(require("fs"));
     var path16 = __importStar(require("path"));
     var utils_1 = require_utils5();
     var index_js_1 = require_schemas3();
@@ -59431,7 +60501,7 @@ var require_status_adapter = __commonJS({
         if (this.githubService) {
           this.githubStatePath = path16.join(this.repositoryPath, ".dev-agent/github-state.json");
           try {
-            const stats = await fs13.promises.stat(this.githubStatePath);
+            const stats = await fs12.promises.stat(this.githubStatePath);
             this.lastStateFileModTime = stats.mtimeMs;
           } catch {
           }
@@ -59446,7 +60516,7 @@ var require_status_adapter = __commonJS({
           return false;
         }
         try {
-          const stats = await fs13.promises.stat(this.githubStatePath);
+          const stats = await fs12.promises.stat(this.githubStatePath);
           const currentModTime = stats.mtimeMs;
           return currentModTime > this.lastStateFileModTime;
         } catch {
@@ -59462,7 +60532,7 @@ var require_status_adapter = __commonJS({
           return;
         }
         try {
-          const stats = await fs13.promises.stat(this.githubStatePath);
+          const stats = await fs12.promises.stat(this.githubStatePath);
           this.lastStateFileModTime = stats.mtimeMs;
         } catch {
         }
@@ -59760,7 +60830,7 @@ var require_status_adapter = __commonJS({
       async checkHealth() {
         const checks = [];
         try {
-          await fs13.promises.access(this.repositoryPath, fs13.constants.R_OK);
+          await fs12.promises.access(this.repositoryPath, fs12.constants.R_OK);
           checks.push({
             name: "Repository Access",
             status: "ok",
@@ -59838,14 +60908,14 @@ var require_status_adapter = __commonJS({
       checkHealthSync() {
         const checks = [];
         try {
-          fs13.accessSync(this.repositoryPath, fs13.constants.R_OK);
+          fs12.accessSync(this.repositoryPath, fs12.constants.R_OK);
           checks.push({ name: "Repository", status: "ok", message: "Accessible" });
         } catch {
           checks.push({ name: "Repository", status: "error", message: "Not accessible" });
         }
         try {
           const vectorDir = path16.dirname(this.vectorStorePath);
-          fs13.accessSync(vectorDir, fs13.constants.R_OK);
+          fs12.accessSync(vectorDir, fs12.constants.R_OK);
           checks.push({ name: "Vector Storage", status: "ok", message: "Available" });
         } catch {
           checks.push({ name: "Vector Storage", status: "warning", message: "Not initialized" });
@@ -59859,11 +60929,11 @@ var require_status_adapter = __commonJS({
         try {
           const getDirectorySize = async (dirPath) => {
             try {
-              const stats = await fs13.promises.stat(dirPath);
+              const stats = await fs12.promises.stat(dirPath);
               if (!stats.isDirectory()) {
                 return stats.size;
               }
-              const files = await fs13.promises.readdir(dirPath);
+              const files = await fs12.promises.readdir(dirPath);
               const sizes = await Promise.all(files.map((file2) => getDirectorySize(path16.join(dirPath, file2))));
               return sizes.reduce((acc, size) => acc + size, 0);
             } catch {