bluera-knowledge 0.29.0 → 0.30.0

package/dist/{chunk-T7J5RB6F.js → chunk-AEXFPA57.js}

@@ -2,17 +2,21 @@ import {
   AdapterRegistry,
   JobService,
   StoreDefinitionService,
+  TEXT_EXTENSIONS,
   createLazyServices,
   createLogger,
   destroyServices,
+  err,
   isFileStoreDefinition,
   isRepoStoreDefinition,
   isWebStoreDefinition,
+  ok,
   summarizePayload
-} from "./chunk-U27UECDZ.js";
+} from "./chunk-B335UOU7.js";
 import {
+  DEFAULT_IGNORE_DIRS,
   checkStoreModelCompatibility
-} from "./chunk-7JTPAQFO.js";
+} from "./chunk-N3XYMAU3.js";
 
 // src/mcp/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -698,6 +702,9 @@ var ListJobsArgsSchema = z.object({
 var CancelJobArgsSchema = z.object({
   jobId: z.string().min(1, "Job ID must be a non-empty string")
 });
+var StoresPullArgsSchema = z.object({
+  store: z.string().min(1, "Store name or ID must be a non-empty string")
+});
 var ExecuteArgsSchema = z.object({
   command: z.string().min(1, "Command name is required"),
   args: z.record(z.string(), z.unknown()).optional()
@@ -960,15 +967,173 @@ var metaCommands = [
 // src/mcp/commands/store.commands.ts
 import { z as z5 } from "zod";
 
-// src/mcp/handlers/store.handler.ts
-import { rm, access } from "fs/promises";
-import { join } from "path";
+// src/plugin/git-pull.ts
+import { spawn } from "child_process";
+var logger3 = createLogger("git-pull");
+var DEFAULT_PULL_TIMEOUT_MS = 6e4;
+var FORCE_KILL_DELAY_MS = 5e3;
+async function pullRepository(options) {
+  const { repoPath, branch, timeoutMs = DEFAULT_PULL_TIMEOUT_MS } = options;
+  const args = ["pull", "origin"];
+  if (branch !== void 0) {
+    args.push(branch);
+  }
+  logger3.info({ repoPath, branch }, "Starting git pull");
+  return new Promise((resolve) => {
+    const git = spawn("git", args, { cwd: repoPath, stdio: ["ignore", "pipe", "pipe"] });
+    let timedOut = false;
+    let forceKillTimeout = null;
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      git.kill("SIGTERM");
+      forceKillTimeout = setTimeout(() => {
+        if (!git.killed) {
+          git.kill("SIGKILL");
+        }
+      }, FORCE_KILL_DELAY_MS);
+    }, timeoutMs);
+    let stderr = "";
+    git.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    let stdout = "";
+    git.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    git.on("error", (error) => {
+      clearTimeout(timeout);
+      if (forceKillTimeout) clearTimeout(forceKillTimeout);
+      resolve(err(error));
+    });
+    git.on("close", (code) => {
+      clearTimeout(timeout);
+      if (forceKillTimeout) clearTimeout(forceKillTimeout);
+      if (timedOut) {
+        resolve(err(new Error(`Git pull timed out after ${String(timeoutMs)}ms in: ${repoPath}`)));
+      } else if (code === 0) {
+        logger3.info({ repoPath, output: stdout.trim() }, "Git pull completed");
+        resolve(ok(stdout.trim()));
+      } else {
+        resolve(err(new Error(`Git pull failed: ${stderr}`)));
+      }
+    });
+  });
+}
+
+// src/utils/eta.ts
+function estimateIndexingTime(fileCount) {
+  if (fileCount <= 0) {
+    return { etaSeconds: 0, etaDisplay: "a few seconds" };
+  }
+  const etaSeconds = Math.ceil(fileCount / 5) + 10;
+  return { etaSeconds, etaDisplay: formatDuration(etaSeconds) };
+}
+function formatDuration(seconds) {
+  if (seconds < 60) {
+    return `~${String(seconds)} seconds`;
+  }
+  const minutes = Math.round(seconds / 60);
+  if (minutes === 1) {
+    return "~1 minute";
+  }
+  return `~${String(minutes)} minutes`;
+}
+
+// src/utils/file-count.ts
+import { execFile } from "child_process";
+import { readdir, stat } from "fs/promises";
+import { extname, join } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var TIMEOUT_MS = 5e3;
+var IGNORE_DIRS = new Set(DEFAULT_IGNORE_DIRS);
+async function estimateFileCount(storePath) {
+  try {
+    return await withTimeout(estimateFileCountInner(storePath), TIMEOUT_MS);
+  } catch {
+    return 0;
+  }
+}
+async function estimateFileCountInner(storePath) {
+  const gitFiles = await gitLsFiles(storePath);
+  if (gitFiles !== null) {
+    return countTextFiles(gitFiles);
+  }
+  return walkAndCount(storePath);
+}
+async function gitLsFiles(repoPath) {
+  try {
+    await stat(join(repoPath, ".git"));
+    const cleanEnv = { ...process.env };
+    delete cleanEnv["GIT_DIR"];
+    delete cleanEnv["GIT_WORK_TREE"];
+    delete cleanEnv["GIT_INDEX_FILE"];
+    const { stdout } = await execFileAsync("git", ["ls-files", "-z"], {
+      cwd: repoPath,
+      maxBuffer: 50 * 1024 * 1024,
+      timeout: TIMEOUT_MS,
+      env: cleanEnv
+    });
+    return stdout.split("\0").filter(Boolean);
+  } catch {
+    return null;
+  }
+}
+function countTextFiles(files) {
+  let count = 0;
+  for (const file of files) {
+    const ext = extname(file).toLowerCase();
+    if (TEXT_EXTENSIONS.has(ext)) {
+      count++;
+    }
+  }
+  return count;
+}
+async function walkAndCount(dirPath, depth = 0) {
+  if (depth > 10) return 0;
+  let count = 0;
+  let entries;
+  try {
+    entries = await readdir(dirPath, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (IGNORE_DIRS.has(entry.name)) continue;
+      count += await walkAndCount(join(dirPath, entry.name), depth + 1);
+    } else if (entry.isFile()) {
+      const ext = extname(entry.name).toLowerCase();
+      if (TEXT_EXTENSIONS.has(ext)) {
+        count++;
+      }
+    }
+  }
+  return count;
+}
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error("Timeout"));
+    }, ms);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    );
+  });
+}
 
 // src/workers/spawn-worker.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import path from "path";
 import { fileURLToPath } from "url";
-var logger3 = createLogger("spawn-worker");
+var logger4 = createLogger("spawn-worker");
 function spawnBackgroundWorker(jobId, dataDir) {
   const currentFilePath = fileURLToPath(import.meta.url);
   const currentDir = path.dirname(currentFilePath);
@@ -982,15 +1147,15 @@ function spawnBackgroundWorker(jobId, dataDir) {
     const workerScript = path.join(distDir, "workers", "background-worker-cli.js");
     command = process.execPath;
     args = [workerScript, jobId];
-    logger3.debug({ workerScript, distDir, currentFilePath }, "Production worker path");
+    logger4.debug({ workerScript, distDir, currentFilePath }, "Production worker path");
   } else {
     const workerScript = path.join(currentDir, "background-worker-cli.ts");
     command = "npx";
     args = ["tsx", workerScript, jobId];
-    logger3.debug({ workerScript, currentDir }, "Development worker path");
+    logger4.debug({ workerScript, currentDir }, "Development worker path");
   }
-  logger3.info({ jobId, command, args, dataDir, isProduction }, "Spawning background worker");
-  const worker = spawn(command, args, {
+  logger4.info({ jobId, command, args, dataDir, isProduction }, "Spawning background worker");
+  const worker = spawn2(command, args, {
     detached: true,
     // Detach from parent process
     stdio: "ignore",
@@ -1002,22 +1167,104 @@ function spawnBackgroundWorker(jobId, dataDir) {
       // Only set if provided
     }
   });
-  worker.on("error", (err) => {
-    logger3.error({ jobId, error: err.message }, "Failed to spawn background worker");
+  worker.on("error", (err2) => {
+    logger4.error({ jobId, error: err2.message }, "Failed to spawn background worker");
   });
-  logger3.info({ jobId, pid: worker.pid }, "Background worker spawned");
+  logger4.info({ jobId, pid: worker.pid }, "Background worker spawned");
   worker.unref();
 }
 
+// src/mcp/handlers/pull.handler.ts
+var logger5 = createLogger("mcp-pull");
+var handleStoresPull = async (args, context) => {
+  const validated = StoresPullArgsSchema.parse(args);
+  logger5.info({ store: validated.store }, "Stores pull started");
+  const { services, options } = context;
+  const store = await services.store.getByIdOrName(validated.store);
+  if (store === void 0) {
+    throw new Error(`Store not found: ${validated.store}`);
+  }
+  if (store.type !== "repo") {
+    throw new Error(
+      `stores:pull only works on repo-type stores. Store "${store.name}" is type "${store.type}".`
+    );
+  }
+  if (store.url === void 0) {
+    throw new Error(`Store "${store.name}" has no git remote URL. Cannot pull without a remote.`);
+  }
+  const pullResult = await pullRepository({
+    repoPath: store.path,
+    branch: store.branch
+  });
+  if (!pullResult.success) {
+    logger5.error({ store: store.name, error: pullResult.error.message }, "Git pull failed");
+    throw new Error(`Git pull failed for "${store.name}": ${pullResult.error.message}`);
+  }
+  const pullOutput = pullResult.data;
+  logger5.info({ store: store.name, pullOutput }, "Git pull succeeded");
+  const jobService = new JobService(options.dataDir);
+  const job = jobService.createJob({
+    type: "index",
+    details: {
+      storeName: store.name,
+      storeId: store.id,
+      phase: "indexing",
+      phaseStep: 1,
+      phaseTotalSteps: 1,
+      path: store.path
+    },
+    message: `Re-indexing ${store.name} after git pull...`
+  });
+  spawnBackgroundWorker(job.id, options.dataDir);
+  logger5.info({ storeId: store.id, storeName: store.name, jobId: job.id }, "Stores pull completed");
+  const fileCount = await estimateFileCount(store.path);
+  const eta = estimateIndexingTime(fileCount);
+  const fileCountLabel = fileCount > 0 ? `~${String(fileCount)} files` : "files";
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            store: {
+              id: store.id,
+              name: store.name
+            },
+            pull: {
+              output: pullOutput
+            },
+            search: {
+              immediate: `Files available for Grep/Read at: ${store.path}`,
+              pending: `Similarity search re-indexing ${fileCountLabel}`,
+              eta: eta.etaDisplay,
+              monitor: `check job status with job:status ${job.id}`
+            },
+            job: {
+              id: job.id,
+              status: job.status,
+              message: `Re-indexing ${store.name} after git pull (${fileCountLabel}, ${eta.etaDisplay})...`
+            },
+            message: `Pulled latest changes. Files available for Grep/Read at ${store.path}. Similarity search re-indexing ${fileCountLabel} (${eta.etaDisplay}).`
+          },
+          null,
+          2
+        )
+      }
+    ]
+  };
+};
+
 // src/mcp/handlers/store.handler.ts
-var logger4 = createLogger("mcp-store");
+import { rm, access } from "fs/promises";
+import { join as join2 } from "path";
+var logger6 = createLogger("mcp-store");
 var handleListStores = async (args, context) => {
   const validated = ListStoresArgsSchema.parse(args);
-  logger4.info({ type: validated.type }, "List stores started");
+  logger6.info({ type: validated.type }, "List stores started");
   const { services } = context;
   const stores = await services.store.list();
   const filtered = validated.type !== void 0 ? stores.filter((s) => s.type === validated.type) : stores;
-  logger4.info({ count: filtered.length, type: validated.type }, "List stores completed");
+  logger6.info({ count: filtered.length, type: validated.type }, "List stores completed");
   return {
     content: [
       {
@@ -1048,14 +1295,14 @@ var handleListStores = async (args, context) => {
 };
 var handleGetStoreInfo = async (args, context) => {
   const validated = GetStoreInfoArgsSchema.parse(args);
-  logger4.info({ store: validated.store }, "Get store info started");
+  logger6.info({ store: validated.store }, "Get store info started");
   const { services } = context;
   const store = await services.store.getByIdOrName(validated.store);
   if (store === void 0) {
-    logger4.warn({ store: validated.store }, "Store not found");
+    logger6.warn({ store: validated.store }, "Store not found");
     throw new Error(`Store not found: ${validated.store}`);
   }
-  logger4.info({ storeId: store.id, storeName: store.name }, "Get store info completed");
+  logger6.info({ storeId: store.id, storeName: store.name }, "Get store info completed");
   return {
     content: [
       {
@@ -1088,7 +1335,7 @@ var handleGetStoreInfo = async (args, context) => {
 };
 var handleCreateStore = async (args, context) => {
   const validated = CreateStoreArgsSchema.parse(args);
-  logger4.info(
+  logger6.info(
     { name: validated.name, type: validated.type, source: validated.source },
     "Create store started"
   );
@@ -1107,7 +1354,7 @@ var handleCreateStore = async (args, context) => {
     ...validated.extractInstructions !== void 0 ? { extractInstructions: validated.extractInstructions } : {}
   });
   if (!result.success) {
-    logger4.error({ name: validated.name, error: result.error.message }, "Create store failed");
+    logger6.error({ name: validated.name, error: result.error.message }, "Create store failed");
     throw new Error(result.error.message);
   }
   const jobService = new JobService(options.dataDir);
@@ -1152,10 +1399,20 @@ var handleCreateStore = async (args, context) => {
     message: validated.type === "web" ? `Crawling ${result.data.name}...` : `Indexing ${result.data.name}...`
   });
   spawnBackgroundWorker(job.id, options.dataDir);
-  logger4.info(
+  logger6.info(
     { storeId: result.data.id, storeName: result.data.name, jobId: job.id },
     "Create store completed"
   );
+  const storePath = "path" in result.data ? result.data.path : void 0;
+  let fileCount = 0;
+  if (validated.type === "web") {
+    fileCount = validated.maxPages ?? 0;
+  } else if (storePath !== void 0) {
+    fileCount = await estimateFileCount(storePath);
+  }
+  const eta = estimateIndexingTime(fileCount);
+  const fileCountLabel = fileCount > 0 ? `~${String(fileCount)} files` : "files";
+  const jobMessage = fileCount > 0 ? `Indexing ${result.data.name} (${fileCountLabel}, ${eta.etaDisplay})...` : job.message;
   return {
     content: [
       {
@@ -1166,14 +1423,20 @@ var handleCreateStore = async (args, context) => {
               id: result.data.id,
               name: result.data.name,
               type: result.data.type,
-              path: "path" in result.data ? result.data.path : void 0
+              path: storePath
+            },
+            search: {
+              immediate: storePath !== void 0 ? `Files available for Grep/Read at: ${storePath}` : void 0,
+              pending: `Similarity search indexing ${fileCountLabel}`,
+              eta: eta.etaDisplay,
+              monitor: `check job status with job:status ${job.id}`
             },
             job: {
               id: job.id,
               status: job.status,
-              message: job.message
+              message: jobMessage
             },
-            message: `Store created. Indexing started in background (Job ID: ${job.id})`
+            message: storePath !== void 0 ? `Store created. Files available for Grep/Read now at ${storePath}. Similarity search indexing ${fileCountLabel} (${eta.etaDisplay}).` : `Store created. Similarity search indexing ${fileCountLabel} (${eta.etaDisplay}).`
           },
           null,
           2
@@ -1184,11 +1447,11 @@ var handleCreateStore = async (args, context) => {
 };
 var handleIndexStore = async (args, context) => {
   const validated = IndexStoreArgsSchema.parse(args);
-  logger4.info({ store: validated.store }, "Index store started");
+  logger6.info({ store: validated.store }, "Index store started");
   const { services, options } = context;
   const store = await services.store.getByIdOrName(validated.store);
   if (store === void 0) {
-    logger4.warn({ store: validated.store }, "Store not found for indexing");
+    logger6.warn({ store: validated.store }, "Store not found for indexing");
     throw new Error(`Store not found: ${validated.store}`);
   }
   const jobService = new JobService(options.dataDir);
@@ -1209,7 +1472,12 @@ var handleIndexStore = async (args, context) => {
     message: `Re-indexing ${store.name}...`
   });
   spawnBackgroundWorker(job.id, options.dataDir);
-  logger4.info({ storeId: store.id, storeName: store.name, jobId: job.id }, "Index store completed");
+  logger6.info({ storeId: store.id, storeName: store.name, jobId: job.id }, "Index store completed");
+  const storePath = "path" in store ? store.path : void 0;
+  const fileCount = storePath !== void 0 ? await estimateFileCount(storePath) : 0;
+  const eta = estimateIndexingTime(fileCount);
+  const fileCountLabel = fileCount > 0 ? `~${String(fileCount)} files` : "files";
+  const jobMessage = fileCount > 0 ? `Re-indexing ${store.name} (${fileCountLabel}, ${eta.etaDisplay})...` : job.message;
   return {
     content: [
       {
@@ -1220,12 +1488,18 @@ var handleIndexStore = async (args, context) => {
               id: store.id,
               name: store.name
             },
+            search: {
+              immediate: storePath !== void 0 ? `Files available for Grep/Read at: ${storePath}` : void 0,
+              pending: `Similarity search re-indexing ${fileCountLabel}`,
+              eta: eta.etaDisplay,
+              monitor: `check job status with job:status ${job.id}`
+            },
             job: {
               id: job.id,
               status: job.status,
-              message: job.message
+              message: jobMessage
             },
-            message: `Indexing started in background (Job ID: ${job.id})`
+            message: storePath !== void 0 ? `Re-indexing started. Files available for Grep/Read at ${storePath}. Similarity search indexing ${fileCountLabel} (${eta.etaDisplay}).` : `Re-indexing started. Similarity search indexing ${fileCountLabel} (${eta.etaDisplay}).`
           },
           null,
           2
@@ -1236,34 +1510,34 @@ var handleIndexStore = async (args, context) => {
 };
 var handleDeleteStore = async (args, context) => {
   const validated = DeleteStoreArgsSchema.parse(args);
-  logger4.info({ store: validated.store }, "Delete store started");
+  logger6.info({ store: validated.store }, "Delete store started");
   const { services, options } = context;
   const store = await services.store.getByIdOrName(validated.store);
   if (store === void 0) {
-    logger4.warn({ store: validated.store }, "Store not found for deletion");
+    logger6.warn({ store: validated.store }, "Store not found for deletion");
     throw new Error(`Store not found: ${validated.store}`);
   }
-  logger4.debug({ storeId: store.id, storeName: store.name }, "Deleting LanceDB table");
+  logger6.debug({ storeId: store.id, storeName: store.name }, "Deleting LanceDB table");
   await services.lance.deleteStore(store.id);
-  logger4.debug({ storeId: store.id }, "Deleting code graph");
+  logger6.debug({ storeId: store.id }, "Deleting code graph");
   await services.codeGraph.deleteGraph(store.id);
-  logger4.debug({ storeId: store.id }, "Deleting manifest");
+  logger6.debug({ storeId: store.id }, "Deleting manifest");
   await services.manifest.delete(store.id);
   if (store.type === "repo" && "url" in store && store.url !== void 0) {
     if (options.dataDir === void 0) {
       throw new Error("dataDir is required to delete cloned repository files");
     }
-    const repoPath = join(options.dataDir, "repos", store.id);
-    logger4.debug({ storeId: store.id, repoPath }, "Removing cloned repository");
+    const repoPath = join2(options.dataDir, "repos", store.id);
+    logger6.debug({ storeId: store.id, repoPath }, "Removing cloned repository");
     await rm(repoPath, { recursive: true, force: true });
   }
-  logger4.debug({ storeId: store.id }, "Removing from registry");
+  logger6.debug({ storeId: store.id }, "Removing from registry");
   const result = await services.store.delete(store.id);
   if (!result.success) {
-    logger4.error({ storeId: store.id, error: result.error.message }, "Delete store failed");
+    logger6.error({ storeId: store.id, error: result.error.message }, "Delete store failed");
     throw new Error(result.error.message);
   }
-  logger4.info(
+  logger6.info(
     { storeId: store.id, storeName: store.name, storeType: store.type },
     "Delete store completed"
   );
@@ -1289,7 +1563,7 @@ var handleDeleteStore = async (args, context) => {
   };
 };
 var handleCheckModels = async (_args, context) => {
-  logger4.info("Check models started");
+  logger6.info("Check models started");
   const { services } = context;
   const stores = await services.store.list();
   const currentModelId = services.store.getCurrentModelId();
@@ -1305,7 +1579,7 @@ var handleCheckModels = async (_args, context) => {
     };
   });
   const needsReindex = storeStatuses.filter((s) => s.status === "needs-reindex");
-  logger4.info(
+  logger6.info(
     { total: stores.length, needsReindex: needsReindex.length },
     "Check models completed"
   );
@@ -1376,7 +1650,7 @@ async function checkStoreHealth(store, currentModelId) {
   };
 }
 var handleStoreHealth = async (args, context) => {
-  logger4.info({ store: args.store }, "Store health check started");
+  logger6.info({ store: args.store }, "Store health check started");
   const { services } = context;
   const currentModelId = services.store.getCurrentModelId();
   let storesToCheck;
@@ -1400,7 +1674,7 @@ var handleStoreHealth = async (args, context) => {
   const healthy = results.filter((r) => r.status === "healthy").length;
   const warnings = results.filter((r) => r.status === "warning").length;
   const errors = results.filter((r) => r.status === "error").length;
-  logger4.info(
+  logger6.info(
     { total: results.length, healthy, warnings, errors, exitCode },
     "Store health check completed"
   );
@@ -1478,6 +1752,19 @@ var storeCommands = [
     }),
     handler: (args, context) => handleDeleteStore(args, context)
   },
+  {
+    name: "stores:pull",
+    description: "Pull latest changes from git remote and re-index a repo-type store",
+    argsSchema: z5.object({
+      store: z5.string().min(1).describe("Store name or ID")
+    }),
+    handler: (args, context) => {
+      if (typeof args["store"] !== "string" || args["store"].length === 0) {
+        throw new Error("Store name or ID is required");
+      }
+      return handleStoresPull({ store: args["store"] }, context);
+    }
+  },
   {
     name: "stores:check-models",
     description: "Check embedding model compatibility for all stores",
@@ -1499,11 +1786,11 @@ var storeCommands = [
 
 // src/mcp/commands/sync.commands.ts
 import { rm as rm2 } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { z as z6 } from "zod";
-var logger5 = createLogger("mcp-sync");
+var logger7 = createLogger("mcp-sync");
 async function handleStoresSync(args, context) {
-  logger5.info(
+  logger7.info(
     { prune: args.prune, dryRun: args.dryRun, reindex: args.reindex },
     "Stores sync started"
   );
@@ -1562,7 +1849,7 @@ async function handleStoresSync(args, context) {
           await services.manifest.delete(store.id);
           if (store.type === "repo" && "url" in store && store.url !== void 0) {
             const dataDir = services.config.resolveDataDir();
-            const repoPath = join2(dataDir, "repos", store.id);
+            const repoPath = join3(dataDir, "repos", store.id);
             await rm2(repoPath, { recursive: true, force: true });
           }
           const deleteResult = await services.store.delete(store.id, { skipDefinitionSync: true });
@@ -1594,7 +1881,7 @@ async function handleStoresSync(args, context) {
       }
     }
   }
-  logger5.info(
+  logger7.info(
     {
       created: result.created.length,
       skipped: result.skipped.length,
@@ -1708,24 +1995,24 @@ import { z as z7 } from "zod";
 
 // src/mcp/handlers/uninstall.handler.ts
 import { existsSync } from "fs";
-import { readdir, rm as rm3 } from "fs/promises";
+import { readdir as readdir2, rm as rm3 } from "fs/promises";
 import { homedir } from "os";
-import { join as join3 } from "path";
-var logger6 = createLogger("uninstall-handler");
+import { join as join4 } from "path";
+var logger8 = createLogger("uninstall-handler");
 var handleUninstall = async (args, context) => {
   const { global: includeGlobal = false, keepDefinitions = true } = args;
   const deleted = [];
   const kept = [];
   const errors = [];
   const projectRoot = context.options.projectRoot ?? process.cwd();
-  const projectDataDir = join3(projectRoot, ".bluera", "bluera-knowledge");
-  logger6.info({ projectDataDir, includeGlobal, keepDefinitions }, "Starting uninstall");
+  const projectDataDir = join4(projectRoot, ".bluera", "bluera-knowledge");
+  logger8.info({ projectDataDir, includeGlobal, keepDefinitions }, "Starting uninstall");
   if (existsSync(projectDataDir)) {
     if (keepDefinitions) {
       try {
-        const entries = await readdir(projectDataDir, { withFileTypes: true });
+        const entries = await readdir2(projectDataDir, { withFileTypes: true });
         for (const entry of entries) {
-          const entryPath = join3(projectDataDir, entry.name);
+          const entryPath = join4(projectDataDir, entry.name);
           if (entry.name === "stores.config.json") {
             kept.push(entryPath);
             continue;
@@ -1733,42 +2020,42 @@ var handleUninstall = async (args, context) => {
           try {
             await rm3(entryPath, { recursive: true, force: true });
             deleted.push(entryPath);
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
+          } catch (err2) {
+            const msg = err2 instanceof Error ? err2.message : String(err2);
             errors.push(`Failed to delete ${entryPath}: ${msg}`);
-            logger6.error({ error: msg, path: entryPath }, "Failed to delete");
+            logger8.error({ error: msg, path: entryPath }, "Failed to delete");
           }
         }
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
+      } catch (err2) {
+        const msg = err2 instanceof Error ? err2.message : String(err2);
         errors.push(`Failed to read ${projectDataDir}: ${msg}`);
-        logger6.error({ error: msg, path: projectDataDir }, "Failed to read directory");
+        logger8.error({ error: msg, path: projectDataDir }, "Failed to read directory");
       }
     } else {
       try {
         await rm3(projectDataDir, { recursive: true, force: true });
         deleted.push(projectDataDir);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
+      } catch (err2) {
+        const msg = err2 instanceof Error ? err2.message : String(err2);
         errors.push(`Failed to delete ${projectDataDir}: ${msg}`);
-        logger6.error({ error: msg, path: projectDataDir }, "Failed to delete");
+        logger8.error({ error: msg, path: projectDataDir }, "Failed to delete");
       }
     }
   }
   if (includeGlobal) {
-    const globalDir = join3(homedir(), ".local", "share", "bluera-knowledge");
+    const globalDir = join4(homedir(), ".local", "share", "bluera-knowledge");
     if (existsSync(globalDir)) {
       try {
         await rm3(globalDir, { recursive: true, force: true });
         deleted.push(globalDir);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
+      } catch (err2) {
+        const msg = err2 instanceof Error ? err2.message : String(err2);
         errors.push(`Failed to delete ${globalDir}: ${msg}`);
-        logger6.error({ error: msg, path: globalDir }, "Failed to delete global data");
+        logger8.error({ error: msg, path: globalDir }, "Failed to delete global data");
       }
     }
   }
-  logger6.info({ deleted, kept, errors }, "Uninstall complete");
+  logger8.info({ deleted, kept, errors }, "Uninstall complete");
   const lines = [];
   if (deleted.length > 0) {
     lines.push("## Deleted:");
@@ -1829,11 +2116,11 @@ commandRegistry.registerAll(syncCommands);
 commandRegistry.registerAll(uninstallCommands);
 
 // src/mcp/handlers/execute.handler.ts
-var logger7 = createLogger("mcp-execute");
+var logger9 = createLogger("mcp-execute");
 var handleExecute = async (args, context) => {
   const validated = ExecuteArgsSchema.parse(args);
   const commandArgs = validated.args ?? {};
-  logger7.info(
+  logger9.info(
     { command: validated.command, args: JSON.stringify(commandArgs) },
     "Execute command started"
   );
@@ -1841,11 +2128,11 @@ var handleExecute = async (args, context) => {
   try {
     const result = await executeCommand(validated.command, commandArgs, context);
     const durationMs = Date.now() - startTime;
-    logger7.info({ command: validated.command, durationMs }, "Execute command completed");
+    logger9.info({ command: validated.command, durationMs }, "Execute command completed");
     return result;
   } catch (error) {
     const durationMs = Date.now() - startTime;
-    logger7.error(
+    logger9.error(
       {
         command: validated.command,
         durationMs,
@@ -1952,11 +2239,11 @@ var LRUCache = class {
 };
 
 // src/mcp/handlers/search.handler.ts
-var logger8 = createLogger("mcp-search");
+var logger10 = createLogger("mcp-search");
 var resultCache = new LRUCache(1e3);
 var handleSearch = async (args, context) => {
   const validated = SearchArgsSchema.parse(args);
-  logger8.info(
+  logger10.info(
     {
       query: validated.query,
       stores: validated.stores,
@@ -1996,7 +2283,7 @@ var handleSearch = async (args, context) => {
     );
   }
   if (skippedStores.length > 0) {
-    logger8.warn({ skippedStores }, "Some stores skipped due to model incompatibility");
+    logger10.warn({ skippedStores }, "Some stores skipped due to model incompatibility");
   }
   const storeIds = compatibleStores.map((s) => s.id);
   try {
@@ -2062,7 +2349,7 @@ var handleSearch = async (args, context) => {
   const header = `Search: "${validated.query}" | Results: ${String(results.totalResults)} | ${formatTokenCount(responseTokens)} tokens | ${String(results.timeMs)}ms${confidenceInfo}${rerankInfo}
 
 `;
-  logger8.info(
+  logger10.info(
     {
       query: validated.query,
       totalResults: results.totalResults,
@@ -2083,7 +2370,7 @@ var handleSearch = async (args, context) => {
 };
 var handleGetFullContext = async (args, context) => {
   const validated = GetFullContextArgsSchema.parse(args);
-  logger8.info({ resultId: validated.resultId }, "Get full context requested");
+  logger10.info({ resultId: validated.resultId }, "Get full context requested");
   const resultId = validated.resultId;
   const cachedResult = resultCache.get(resultId);
   if (!cachedResult) {
@@ -2101,7 +2388,7 @@ var handleGetFullContext = async (args, context) => {
       null,
       2
     );
-    logger8.info(
+    logger10.info(
       {
         resultId,
         cached: true,
@@ -2168,7 +2455,7 @@ var handleGetFullContext = async (args, context) => {
     null,
     2
   );
-  logger8.info(
+  logger10.info(
     {
       resultId,
       cached: false,
@@ -2204,7 +2491,7 @@ var tools = [
 ];
 
 // src/mcp/server.ts
-var logger9 = createLogger("mcp-server");
+var logger11 = createLogger("mcp-server");
 var registry = AdapterRegistry.getInstance();
 if (!registry.hasExtension(".zil")) {
   registry.register(new ZilAdapter());
@@ -2320,7 +2607,7 @@ function createMCPServer(options, services) {
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const startTime = Date.now();
-    logger9.info({ tool: name, args: JSON.stringify(args) }, "Tool invoked");
+    logger11.info({ tool: name, args: JSON.stringify(args) }, "Tool invoked");
     const context = { services, options };
     try {
       let result;
@@ -2336,11 +2623,11 @@ function createMCPServer(options, services) {
         result = await tool.handler(validated, context);
       }
       const durationMs = Date.now() - startTime;
-      logger9.info({ tool: name, durationMs }, "Tool completed");
+      logger11.info({ tool: name, durationMs }, "Tool completed");
       return result;
     } catch (error) {
       const durationMs = Date.now() - startTime;
-      logger9.error(
+      logger11.error(
         {
           tool: name,
           durationMs,
@@ -2354,7 +2641,7 @@ function createMCPServer(options, services) {
   return server;
 }
 async function runMCPServer(options) {
-  logger9.info(
+  logger11.info(
     {
       dataDir: options.dataDir,
       projectRoot: options.projectRoot
@@ -2365,12 +2652,12 @@ async function runMCPServer(options) {
   const server = createMCPServer(options, services);
   const transport = new StdioServerTransport();
   const shutdown = async (signal) => {
-    logger9.info({ signal }, "Shutdown signal received");
+    logger11.info({ signal }, "Shutdown signal received");
     try {
       await destroyServices(services);
-      logger9.info("Services destroyed, exiting");
+      logger11.info("Services destroyed, exiting");
     } catch (error) {
-      logger9.error(
+      logger11.error(
         { error: error instanceof Error ? error.message : String(error) },
         "Error during shutdown"
       );
@@ -2379,7 +2666,7 @@ async function runMCPServer(options) {
   process.on("SIGINT", () => void shutdown("SIGINT"));
   process.on("SIGTERM", () => void shutdown("SIGTERM"));
   await server.connect(transport);
-  logger9.info("MCP server connected to stdio transport");
+  logger11.info("MCP server connected to stdio transport");
 }
 var scriptPath = process.argv[1] ?? "";
 var isMCPServerEntry = scriptPath.endsWith("mcp/server.js") || scriptPath.endsWith("mcp/server");
@@ -2393,7 +2680,7 @@ if (isMCPServerEntry) {
     config: process.env["CONFIG_PATH"],
     projectRoot
   }).catch((error) => {
-    logger9.error(
+    logger11.error(
       { error: error instanceof Error ? error.message : String(error) },
       "Failed to start MCP server"
     );
@@ -2407,4 +2694,4 @@ export {
   createMCPServer,
   runMCPServer
 };
-//# sourceMappingURL=chunk-T7J5RB6F.js.map
+//# sourceMappingURL=chunk-AEXFPA57.js.map