@dikolab/kbdb 0.4.0 → 0.4.3

package/dist/cli.cjs

@@ -69,6 +69,26 @@ var SUPPORTED_EXTENSIONS = [
   ".adoc"
 ];
 
+// src/shared/log/typings/log-level.type.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARNING"] = 2] = "WARNING";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+
+// src/shared/log/functions/parse-log-level.function.ts
+var LOG_LEVEL_MAP = {
+  debug: 0 /* DEBUG */,
+  info: 1 /* INFO */,
+  warning: 2 /* WARNING */,
+  error: 3 /* ERROR */
+};
+function parseLogLevel(value) {
+  return LOG_LEVEL_MAP[value.toLowerCase()] ?? 2 /* WARNING */;
+}
+
 // src/shared/cli/functions/parse-args.function.ts
 function parseArgs(argv) {
   const options = {
@@ -92,19 +112,31 @@ function parseArgs(argv) {
         }
         return options;
       case "--version":
-      case "-v":
         options.command = "version";
         return options;
+      case "-v":
+      case "--verbose": {
+        const next = argv[i + 1];
+        if (next && !next.startsWith("-")) {
+          options.logLevel = parseLogLevel(next);
+          i++;
+        } else {
+          options.logLevel = 2 /* WARNING */;
+        }
+        break;
+      }
+      case "-vv":
+      case "--verbose-info":
+        options.logLevel = 1 /* INFO */;
+        break;
+      case "-vvv":
+      case "--verbose-debug":
+        options.logLevel = 0 /* DEBUG */;
+        break;
       case "--init":
-        console.error(
-          'warning: --init is deprecated, use "kbdb db init"'
-        );
         options.command = "init";
         break;
       case "--migrate":
-        console.error(
-          'warning: --migrate is deprecated, use "kbdb db migrate"'
-        );
         options.command = "migrate";
         break;
       case "--db":
@@ -189,6 +221,9 @@ function parseArgs(argv) {
       case "--retry":
         options.retry = parseInt(argv[++i] ?? "", 10) || void 0;
         break;
+      case "--non-interactive":
+        options.nonInteractive = true;
+        break;
       default:
         if (!options.command) {
           options.command = arg;
@@ -263,8 +298,67 @@ function formatMcp(paged) {
   );
 }
 
+// src/shared/log/constants/log-colors.constant.ts
+var ANSI_RESET = "\x1B[0m";
+var LOG_COLORS = {
+  [0 /* DEBUG */]: "\x1B[37m",
+  [1 /* INFO */]: "\x1B[36m",
+  [2 /* WARNING */]: "\x1B[33m",
+  [3 /* ERROR */]: "\x1B[91m"
+};
+
+// src/shared/log/constants/log-icons.constant.ts
+var LOG_ICONS = {
+  [0 /* DEBUG */]: "\u25B8",
+  [1 /* INFO */]: "\u2139",
+  [2 /* WARNING */]: "\u26A0",
+  [3 /* ERROR */]: "\u2716"
+};
+
+// src/shared/log/constants/log-defaults.constant.ts
+var DEFAULT_LOG_LEVEL = 3 /* ERROR */;
+
+// src/shared/log/functions/write-stderr.function.ts
+function writeStderr(message) {
+  const g = globalThis;
+  const proc = g["process"];
+  if (proc?.stderr) {
+    proc.stderr.write(message);
+    return;
+  }
+  const deno = g["Deno"];
+  deno?.stderr.writeSync(new TextEncoder().encode(message));
+}
+
+// src/shared/log/functions/log.function.ts
+var currentLevel = DEFAULT_LOG_LEVEL;
+var outputs = {
+  [0 /* DEBUG */]: writeStderr,
+  [1 /* INFO */]: writeStderr,
+  [2 /* WARNING */]: writeStderr,
+  [3 /* ERROR */]: writeStderr
+};
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function setLogOutput(level, output) {
+  outputs[level] = output;
+}
+function log(message, level = 3 /* ERROR */) {
+  if (level < currentLevel) {
+    return;
+  }
+  const color = LOG_COLORS[level];
+  const icon = LOG_ICONS[level];
+  const name = LogLevel[level];
+  const line = `${color}${icon} [${name}] ${message}${ANSI_RESET}
+`;
+  outputs[level](line);
+}
+
 // src/shared/cli/functions/run-search.function.ts
 async function runSearch(client, options) {
+  log("searching: " + options.args.join(" "), 0 /* DEBUG */);
   const query = options.args.join(" ").trim();
   if (!query) {
     return {
@@ -284,6 +378,10 @@ async function runSearch(client, options) {
     algo: options.algo,
     relaxed: options.relaxed
   });
+  log(
+    "search returned " + results.total.toString() + " results",
+    0 /* DEBUG */
+  );
   return {
     items: results.items.map((r) => ({
       kbid: r.kbid,
@@ -321,12 +419,14 @@ async function resolveKbidPrefix(prefix, client) {
     }
   }
   if (seen.size === 0) {
-    throw new Error(`no section matches prefix "${prefix}"`);
+    const msg = `no section matches prefix "${prefix}"`;
+    log(msg, 3 /* ERROR */);
+    throw new Error(msg);
   }
   if (seen.size > 1) {
-    throw new Error(
-      `ambiguous prefix "${prefix}": ${seen.size.toString()} matches`
-    );
+    const msg = `ambiguous prefix "${prefix}": ${seen.size.toString()} matches`;
+    log(msg, 3 /* ERROR */);
+    throw new Error(msg);
   }
   return [...seen][0];
 }
@@ -334,6 +434,7 @@ async function resolveKbidPrefix(prefix, client) {
 // src/shared/cli/functions/run-recall.function.ts
 var MAX_RECALL_DEPTH = 3;
 async function runRecall(client, options) {
+  log("running recall", 0 /* DEBUG */);
   if (options.args.length === 0) {
     return { error: "no kbid provided" };
   }
@@ -352,6 +453,7 @@ async function runRecall(client, options) {
 
 // src/shared/cli/functions/run-export.function.ts
 async function runExport(client, options) {
+  log("running export", 0 /* DEBUG */);
   const path = options.args[0];
   return client.export({ path });
 }
@@ -360,6 +462,10 @@ async function runExport(client, options) {
 var import_node_fs = require("node:fs");
 var import_node_path3 = require("node:path");
 async function runLearn(client, options, io) {
+  log(
+    "learning " + options.args.length.toString() + " targets",
+    0 /* DEBUG */
+  );
   const results = [];
   let stdinConsumed = false;
   const readStdin = io?.readStdin ?? readProcessStdin;
@@ -398,6 +504,10 @@ async function runLearn(client, options, io) {
       );
     }
   }
+  log(
+    "learned " + results.length.toString() + " sections",
+    0 /* DEBUG */
+  );
   return results;
 }
 function mapAddSectionResult(result, path, size) {
@@ -461,6 +571,7 @@ function isSupportedFile(path) {
 
 // src/shared/cli/functions/run-unlearn.function.ts
 async function runUnlearn(client, options) {
+  log("running unlearn", 0 /* DEBUG */);
   const results = [];
   for (const arg of options.args) {
     const kbid = await resolveKbidPrefix(arg, client);
@@ -472,6 +583,7 @@ async function runUnlearn(client, options) {
 
 // src/shared/cli/functions/run-content.function.ts
 async function runContent(client, options) {
+  log("running content", 0 /* DEBUG */);
   const resolved = await Promise.all(
     options.args.map((a) => resolveKbidPrefix(a, client))
   );
@@ -489,6 +601,7 @@ function parseDivergentContent(encoded) {
   }).filter((entry) => entry.kbids.length > 0);
 }
 async function runCheck(client, _options) {
+  log("running check", 0 /* DEBUG */);
   const raw = await client.integrityCheck();
   return {
     ok: raw.ok,
@@ -503,11 +616,13 @@ async function runCheck(client, _options) {
 
 // src/shared/cli/functions/run-gc.function.ts
 async function runGc(client, _options) {
+  log("running gc", 0 /* DEBUG */);
   return client.gc();
 }
 
 // src/shared/cli/functions/run-rebuild.function.ts
 async function runRebuild(client, _options) {
+  log("running rebuild", 0 /* DEBUG */);
   return client.rebuildIndexes();
 }
 
@@ -663,6 +778,7 @@ function createScaffold(dbDir) {
   (0, import_node_fs4.writeFileSync)((0, import_node_path6.join)(dbDir, ".gitignore"), GITIGNORE);
 }
 function runInit(options) {
+  log("running init", 0 /* DEBUG */);
   const basePath = options.dbPath ? (0, import_node_path6.resolve)(options.dbPath) : process.cwd();
   const dbDir = (0, import_node_path6.join)(basePath, ".kbdb");
   try {
@@ -714,11 +830,13 @@ function askReadline(question) {
 
 // src/shared/cli/functions/run-status.function.ts
 async function runStatus(client, _options) {
+  log("running status", 0 /* DEBUG */);
   return client.dbStatus();
 }
 
 // src/shared/cli/functions/run-db-init.function.ts
 function runDbInit(options, runInitFn) {
+  log("running db-init", 0 /* DEBUG */);
   const result = runInitFn(options);
   if (result.ok) {
     return {
@@ -738,6 +856,7 @@ function runDbInit(options, runInitFn) {
 
 // src/shared/cli/functions/run-db-migrate.function.ts
 async function runDbMigrate(client, options) {
+  log("running db-migrate", 0 /* DEBUG */);
   const dbPath = options.dbPath ?? process.cwd();
   return client.migrateDatabase(dbPath);
 }
@@ -765,6 +884,7 @@ function serializeSkillContent(skill) {
 
 // src/shared/cli/functions/run-skill-learn.function.ts
 async function runSkillLearn(client, options) {
+  log("running skill-learn", 0 /* DEBUG */);
   const name = options.name;
   if (!name) {
     return { error: "--name is required", exitCode: 1 };
@@ -795,6 +915,7 @@ async function runSkillLearn(client, options) {
 
 // src/shared/cli/functions/run-skill-list.function.ts
 async function runSkillList(client, _options) {
+  log("running skill-list", 0 /* DEBUG */);
   const records = await client.listByType("skill");
   const items = records.map((r) => {
     let argumentCount = 0;
@@ -822,9 +943,11 @@ async function runSkillList(client, _options) {
 function parseSkillContent(json) {
   const raw = JSON.parse(json);
   if (typeof raw["name"] !== "string" || !raw["name"]) {
+    log("skill name is required", 3 /* ERROR */);
     throw new Error("skill name is required");
   }
   if (typeof raw["body"] !== "string") {
+    log("skill body is required", 3 /* ERROR */);
     throw new Error("skill body is required");
   }
   return {
@@ -837,6 +960,7 @@ function parseSkillContent(json) {
 
 // src/shared/cli/functions/run-skill-get.function.ts
 async function runSkillGet(client, options) {
+  log("running skill-get", 0 /* DEBUG */);
   const identifier = options.args[0] ?? options.name;
   if (!identifier) {
     return {
@@ -873,6 +997,7 @@ async function runSkillGet(client, options) {
 
 // src/shared/cli/functions/run-skill-delete.function.ts
 async function runSkillDelete(client, options) {
+  log("running skill-delete", 0 /* DEBUG */);
   const kbid = options.args[0];
   if (!kbid) {
     return { error: "kbid is required", exitCode: 1 };
@@ -890,6 +1015,7 @@ async function runSkillDelete(client, options) {
 
 // src/shared/cli/functions/run-agent-create.function.ts
 async function runAgentCreate(client, options) {
+  log("running agent-create", 0 /* DEBUG */);
   const name = options.name;
   if (!name) {
     return { error: "--name is required", exitCode: 1 };
@@ -935,6 +1061,7 @@ async function runAgentCreate(client, options) {
 
 // src/shared/cli/functions/run-agent-list.function.ts
 async function runAgentList(client, _options) {
+  log("running agent-list", 0 /* DEBUG */);
   const docs = await client.listDocumentsByType("agent");
   const items = docs.map((d) => ({
     docid: d.docid,
@@ -991,6 +1118,7 @@ async function resolveSkills(client, skillRefs) {
   });
 }
 async function runAgentGet(client, options) {
+  log("running agent-get", 0 /* DEBUG */);
   const docid = options.args[0];
   if (!docid) {
     return { error: "docid is required", exitCode: 1 };
@@ -1012,6 +1140,7 @@ async function runAgentGet(client, options) {
 
 // src/shared/cli/functions/run-agent-delete.function.ts
 async function runAgentDelete(client, options) {
+  log("running agent-delete", 0 /* DEBUG */);
   const docid = options.args[0];
   if (!docid) {
     return { error: "docid is required", exitCode: 1 };
@@ -1027,7 +1156,9 @@ async function runAgentDelete(client, options) {
 async function runImport(client, options) {
   const from = options.from;
   if (!from) {
-    throw new Error("import requires --from <path>");
+    const msg = "import requires --from <path>";
+    log(msg, 3 /* ERROR */);
+    throw new Error(msg);
   }
   return client.import({
     from,
@@ -1037,6 +1168,7 @@ async function runImport(client, options) {
 
 // src/shared/cli/functions/dispatch-command.function.ts
 async function dispatchCommand(client, options, io) {
+  log("dispatching command: " + options.command, 0 /* DEBUG */);
   switch (options.command) {
     case "learn":
       return handleLearn(client, options, io);
@@ -1097,6 +1229,7 @@ async function dispatchCommand(client, options, io) {
       return result;
     }
     default:
+      log("unknown command: " + options.command, 2 /* WARNING */);
       return {
         error: `unknown command: ${options.command}`,
         exitCode: 1
@@ -1296,7 +1429,7 @@ async function hydrateSearchPreviews(client, paged) {
 }
 
 // src/shared/version/constants/version.constant.ts
-var VERSION = "0.4.0";
+var VERSION = "0.4.3";
 
 // src/shared/cli/functions/generate-help.function.ts
 var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
@@ -1842,6 +1975,57 @@ function generateSubcommandHelp(command, subcommand) {
 
 // src/shared/worker-client/classes/worker-client.class.ts
 var import_node_net = require("node:net");
+
+// src/shared/worker-client/functions/discover-daemon.function.ts
+var import_node_fs5 = require("node:fs");
+var import_node_path7 = require("node:path");
+var import_node_os = require("node:os");
+
+// src/shared/platform/functions/is-process-alive.function.ts
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/shared/worker-client/functions/discover-daemon.function.ts
+function discoverDaemon(contextId) {
+  log("discovering daemon for context: " + contextId, 0 /* DEBUG */);
+  const pidPath = (0, import_node_path7.join)((0, import_node_os.tmpdir)(), `kbdb-${contextId}.pid`);
+  if (!(0, import_node_fs5.existsSync)(pidPath)) {
+    log(
+      "no daemon PID file found for context: " + contextId,
+      0 /* DEBUG */
+    );
+    return null;
+  }
+  const pidStr = (0, import_node_fs5.readFileSync)(pidPath, "utf-8").trim();
+  const pid = parseInt(pidStr, 10);
+  if (isNaN(pid) || !isProcessAlive(pid)) {
+    log(
+      "daemon process not alive for context: " + contextId,
+      0 /* DEBUG */
+    );
+    try {
+      (0, import_node_fs5.unlinkSync)(pidPath);
+    } catch {
+    }
+    return null;
+  }
+  log("daemon found: pid=" + pid.toString(), 0 /* DEBUG */);
+  const socketPath = (0, import_node_path7.join)((0, import_node_os.tmpdir)(), `kbdb-${contextId}.sock`);
+  const crashPath = (0, import_node_path7.join)((0, import_node_os.tmpdir)(), `kbdb-${contextId}.crash`);
+  try {
+    (0, import_node_fs5.unlinkSync)(crashPath);
+  } catch {
+  }
+  return { pid, socketPath };
+}
+
+// src/shared/worker-client/classes/worker-client.class.ts
 var WorkerClient = class {
   /**
    * @param socketPath - absolute path to the daemon's IPC socket
@@ -1877,11 +2061,13 @@ var WorkerClient = class {
    * @throws {Error} if the connection cannot be established
    */
   async connect() {
+    log("connecting to " + this.socketPath, 0 /* DEBUG */);
     const maxRetries = 5;
     let delay = 50;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
       try {
         await this.tryConnect();
+        log("connected", 0 /* DEBUG */);
         return;
       } catch (err) {
         const code = err.code;
@@ -1889,6 +2075,10 @@ var WorkerClient = class {
         if (!retriable || attempt === maxRetries) {
           throw err;
         }
+        log(
+          "connect retry: attempt=" + attempt.toString() + " code=" + code + " delay=" + delay.toString() + "ms",
+          0 /* DEBUG */
+        );
         await new Promise((r) => setTimeout(r, delay));
         delay = Math.min(delay * 2, 1e3);
       }
@@ -1896,11 +2086,32 @@ var WorkerClient = class {
   }
   /** Destroys the IPC socket and clears the connection state. */
   disconnect() {
+    log("disconnecting client", 0 /* DEBUG */);
     if (this.socket) {
       this.socket.destroy();
       this.socket = null;
     }
   }
+  /**
+   * Kills the daemon process and disconnects the client.
+   *
+   * Discovers the daemon via PID file and sends `SIGTERM`.
+   * Always disconnects the socket regardless of kill outcome.
+   */
+  killDaemon() {
+    const info = discoverDaemon(this.contextId);
+    log(
+      "killing daemon: pid=" + (info ? info.pid.toString() : "unknown"),
+      0 /* DEBUG */
+    );
+    if (info) {
+      try {
+        process.kill(info.pid, "SIGTERM");
+      } catch {
+      }
+    }
+    this.disconnect();
+  }
   /**
    * Single connection attempt with keepalive and
    * post-connect failure handlers.
@@ -1911,9 +2122,14 @@ var WorkerClient = class {
         sock.removeListener("error", reject);
         sock.setKeepAlive(true, 3e4);
         sock.on("error", (err) => {
+          log(
+            "socket error: code=" + (err.code ?? err.message),
+            0 /* DEBUG */
+          );
           this.handleSocketFailure(err);
         });
         sock.on("close", () => {
+          log("socket closed", 0 /* DEBUG */);
           if (this.pending.size > 0) {
             this.handleSocketFailure(
               new Error("connection closed")
@@ -1935,6 +2151,10 @@ var WorkerClient = class {
    * disconnected.
    */
   handleSocketFailure(err) {
+    log(
+      "socket failure: pending=" + this.pending.size.toString() + " err=" + err.message,
+      0 /* DEBUG */
+    );
     const sock = this.socket;
     this.socket = null;
     for (const [id, call] of this.pending) {
@@ -2235,6 +2455,10 @@ var WorkerClient = class {
       throw new Error("not connected");
     }
     const id = this.nextId++;
+    log(
+      "call: method=" + method + " id=" + id.toString(),
+      0 /* DEBUG */
+    );
     const request = {
       jsonrpc: "2.0",
       id,
@@ -2248,6 +2472,10 @@ var WorkerClient = class {
         call.timer = setTimeout(() => {
           if (!this.pending.has(id)) return;
           this.pending.delete(id);
+          log(
+            "request timeout after " + String(timeoutMs) + "ms",
+            2 /* WARNING */
+          );
           const err = new Error(
             `request timeout after ${String(timeoutMs)}ms`
           );
@@ -2278,14 +2506,31 @@ var WorkerClient = class {
           this.pending.delete(response.id);
           if (pending.timer) clearTimeout(pending.timer);
           if (response.error) {
+            log(
+              "response error: id=" + response.id.toString() + " code=" + response.error.code.toString(),
+              0 /* DEBUG */
+            );
             const err = new Error(response.error.message);
             err.code = response.error.code;
             pending.reject(err);
           } else {
+            log(
+              "response ok: id=" + response.id.toString(),
+              0 /* DEBUG */
+            );
             pending.resolve(response.result);
           }
+        } else {
+          log(
+            "unmatched response id=" + response.id.toString(),
+            0 /* DEBUG */
+          );
         }
-      } catch {
+      } catch (parseErr) {
+        log(
+          "json parse error: " + parseErr.message,
+          0 /* DEBUG */
+        );
       }
     }
   }
@@ -2297,13 +2542,15 @@ var import_node_path11 = require("node:path");
 var import_node_os4 = require("node:os");
 
 // src/shared/worker-client/functions/resolve-db-path.function.ts
-var import_node_fs5 = require("node:fs");
-var import_node_path7 = require("node:path");
+var import_node_fs6 = require("node:fs");
+var import_node_path8 = require("node:path");
 function resolveDbPath(targetDir) {
-  const base = targetDir ? (0, import_node_path7.resolve)(targetDir) : process.cwd();
-  const dbPath = (0, import_node_path7.join)(base, ".kbdb");
-  if (!(0, import_node_fs5.existsSync)(dbPath)) {
-    throw new Error(`database not found: ${dbPath}`);
+  const base = targetDir ? (0, import_node_path8.resolve)(targetDir) : process.cwd();
+  const dbPath = (0, import_node_path8.join)(base, ".kbdb");
+  if (!(0, import_node_fs6.existsSync)(dbPath)) {
+    const msg = `database not found: ${dbPath}`;
+    log(msg, 3 /* ERROR */);
+    throw new Error(msg);
   }
   return dbPath;
 }
@@ -2322,53 +2569,22 @@ async function computeContextId(absolutePath) {
   return hash.slice(0, 16);
 }
 
-// src/shared/worker-client/functions/discover-daemon.function.ts
-var import_node_fs6 = require("node:fs");
-var import_node_path8 = require("node:path");
-var import_node_os = require("node:os");
-
-// src/shared/platform/functions/is-process-alive.function.ts
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/shared/worker-client/functions/discover-daemon.function.ts
-function discoverDaemon(contextId) {
-  const pidPath = (0, import_node_path8.join)((0, import_node_os.tmpdir)(), `kbdb-${contextId}.pid`);
-  if (!(0, import_node_fs6.existsSync)(pidPath)) return null;
-  const pidStr = (0, import_node_fs6.readFileSync)(pidPath, "utf-8").trim();
-  const pid = parseInt(pidStr, 10);
-  if (isNaN(pid) || !isProcessAlive(pid)) {
-    try {
-      (0, import_node_fs6.unlinkSync)(pidPath);
-    } catch {
-    }
-    return null;
-  }
-  const socketPath = (0, import_node_path8.join)((0, import_node_os.tmpdir)(), `kbdb-${contextId}.sock`);
-  const crashPath = (0, import_node_path8.join)((0, import_node_os.tmpdir)(), `kbdb-${contextId}.crash`);
-  try {
-    (0, import_node_fs6.unlinkSync)(crashPath);
-  } catch {
-  }
-  return { pid, socketPath };
-}
-
 // src/shared/worker-client/functions/spawn-daemon.function.ts
 var import_node_child_process = require("node:child_process");
 function spawnDaemon(contextPath, runtime2, workerScript2) {
   if (!workerScript2) {
-    throw new Error(
-      "workerScript must be provided (resolve at entry point)"
-    );
+    const msg = "workerScript must be provided (resolve at entry point)";
+    log(msg, 3 /* ERROR */);
+    throw new Error(msg);
   }
   const execPath = runtime2 === "deno" ? "deno" : process.execPath;
-  const args = runtime2 === "deno" ? ["run", "--allow-all", workerScript2, contextPath] : [workerScript2, contextPath];
+  const logLevelEnv = process.env["KBDB_LOG_LEVEL"];
+  const logArgs = logLevelEnv ? ["--log-level", logLevelEnv] : [];
+  const args = runtime2 === "deno" ? ["run", "--allow-all", workerScript2, contextPath, ...logArgs] : [workerScript2, contextPath, ...logArgs];
+  log(
+    "spawning daemon: " + execPath + " " + args.join(" "),
+    0 /* DEBUG */
+  );
   const child = (0, import_node_child_process.spawn)(execPath, args, {
     detached: true,
     stdio: "ignore"
@@ -2383,12 +2599,30 @@ var import_node_os2 = require("node:os");
 var DEFAULT_TIMEOUT_MS = 1e4;
 var POLL_INTERVAL_MS = 100;
 async function waitForDaemon(contextId, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  log("waiting for daemon: contextId=" + contextId, 0 /* DEBUG */);
   const pidPath = (0, import_node_path9.join)((0, import_node_os2.tmpdir)(), `kbdb-${contextId}.pid`);
   const start = Date.now();
+  let iteration = 0;
   while (Date.now() - start < timeoutMs) {
-    if ((0, import_node_fs7.existsSync)(pidPath)) return true;
+    if ((0, import_node_fs7.existsSync)(pidPath)) {
+      log("daemon PID file appeared", 0 /* DEBUG */);
+      return true;
+    }
+    iteration++;
+    if (iteration % 10 === 0) {
+      const elapsed2 = Date.now() - start;
+      log(
+        "still waiting for daemon: elapsed=" + elapsed2.toString() + "ms",
+        0 /* DEBUG */
+      );
+    }
     await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
   }
+  const elapsed = Date.now() - start;
+  log(
+    "timed out waiting for daemon: elapsed=" + elapsed.toString() + "ms",
+    0 /* DEBUG */
+  );
   return false;
 }
 
@@ -2413,19 +2647,28 @@ function getIpcPath(ctx) {
 async function createWorkerClient(options) {
   const dbPath = options?.contextPath ?? resolveDbPath(options?.dbPath);
   const contextId = await computeContextId(dbPath);
+  log("create-worker-client: contextId=" + contextId, 0 /* DEBUG */);
   const socketPath = getIpcPath(contextId);
   let daemon = discoverDaemon(contextId);
+  if (daemon) {
+    log("daemon found: pid=" + daemon.pid.toString(), 0 /* DEBUG */);
+  } else {
+    log("no daemon found", 0 /* DEBUG */);
+  }
   if (!daemon && options?.autoSpawn !== false) {
     const runtime2 = detectRuntime();
+    log("auto-spawning daemon", 0 /* DEBUG */);
     spawnDaemon(dbPath, runtime2, options?.workerScript);
+    log("waiting for daemon after spawn", 0 /* DEBUG */);
     await waitForDaemon(contextId, options?.connectTimeoutMs);
     daemon = discoverDaemon(contextId);
   }
   if (!daemon) {
-    throw new Error(
-      `kbdb worker daemon did not start: ${readCrashReason(contextId)}`
-    );
+    const msg = `kbdb worker daemon did not start: ${readCrashReason(contextId)}`;
+    log(msg, 3 /* ERROR */);
+    throw new Error(msg);
   }
+  log("connecting to daemon", 0 /* DEBUG */);
   const client = new WorkerClient(
     socketPath,
     contextId,
@@ -2451,27 +2694,58 @@ function readCrashReason(contextId) {
 
 // src/shared/cli/functions/run-worker-stop.function.ts
 async function runWorkerStop(dbDir) {
+  log("running worker-stop", 0 /* DEBUG */);
   const contextId = await computeContextId(dbDir);
   const info = discoverDaemon(contextId);
   if (!info) {
     return { output: "no daemon running", exitCode: 0 };
   }
+  log("pid found: " + info.pid.toString(), 0 /* DEBUG */);
   try {
     process.kill(info.pid, "SIGTERM");
-    return {
-      output: `stopped daemon (pid ${info.pid.toString()})`,
-      exitCode: 0
-    };
+    log("sigterm sent to pid=" + info.pid.toString(), 0 /* DEBUG */);
   } catch {
     return {
       error: "error: failed to stop daemon",
       exitCode: 1
     };
   }
+  const deadline = Date.now() + 5e3;
+  let pollIteration = 0;
+  while (Date.now() < deadline) {
+    try {
+      process.kill(info.pid, 0);
+    } catch {
+      log(
+        "process exited: pid=" + info.pid.toString(),
+        0 /* DEBUG */
+      );
+      break;
+    }
+    pollIteration++;
+    if (pollIteration % 5 === 0) {
+      log(
+        "waiting for exit: pid=" + info.pid.toString() + " poll=" + pollIteration.toString(),
+        0 /* DEBUG */
+      );
+    }
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  if (Date.now() >= deadline) {
+    log(
+      "timed out waiting for exit: pid=" + info.pid.toString(),
+      0 /* DEBUG */
+    );
+  }
+  return {
+    output: `stopped daemon (pid ${info.pid.toString()})`,
+    exitCode: 0
+  };
 }
 
 // src/shared/cli/functions/run-worker-restart.function.ts
 async function runWorkerRestart(dbDir) {
+  log("running worker-restart", 0 /* DEBUG */);
   const stopResult = await runWorkerStop(dbDir);
   if (stopResult.exitCode !== 0) return stopResult;
   return {
@@ -2489,20 +2763,44 @@ function resolveRawDbPath(options) {
 async function retryOnTimeout(createClient, operation, maxRetries) {
   let lastError = new Error("retryOnTimeout exhausted");
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    log(
+      "retry-on-timeout: attempt=" + attempt.toString() + " max=" + maxRetries.toString(),
+      0 /* DEBUG */
+    );
     const client = await createClient();
     try {
       const result = await operation(client);
+      log(
+        "retry-on-timeout: success on attempt=" + attempt.toString(),
+        0 /* DEBUG */
+      );
       return { client, result };
     } catch (err) {
       const code = err.code;
       if (code !== "REQUEST_TIMEOUT" || attempt >= maxRetries) {
+        log(
+          "retry-on-timeout: non-retriable error code=" + String(code),
+          0 /* DEBUG */
+        );
         client.disconnect();
         throw err;
       }
       lastError = err;
-      client.disconnect();
+      if (client.killDaemon) {
+        log(
+          "retry " + String(attempt + 1) + "/" + String(maxRetries) + ": killing daemon",
+          2 /* WARNING */
+        );
+        client.killDaemon();
+      } else {
+        client.disconnect();
+      }
     }
   }
+  log(
+    "retry-on-timeout: all retries exhausted max=" + maxRetries.toString(),
+    0 /* DEBUG */
+  );
   throw lastError;
 }
 
@@ -2512,11 +2810,57 @@ var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
 // src/shared/worker-client/constants/retry-defaults.constant.ts
 var DEFAULT_RETRY_COUNT = 5;
 
+// src/shared/log/functions/resolve-log-level.function.ts
+function resolveLogLevel(cliLevel) {
+  if (cliLevel !== void 0) {
+    return cliLevel;
+  }
+  const envValue = process.env["KBDB_LOG_LEVEL"];
+  if (envValue !== void 0) {
+    return parseLogLevel(envValue);
+  }
+  return DEFAULT_LOG_LEVEL;
+}
+
+// src/shared/log/functions/configure-log.function.ts
+function configureLog(config) {
+  setLogLevel(config.level);
+  if (config.outputs === void 0) {
+    return;
+  }
+  const levels = [
+    0 /* DEBUG */,
+    1 /* INFO */,
+    2 /* WARNING */,
+    3 /* ERROR */
+  ];
+  for (const level of levels) {
+    const output = config.outputs[level];
+    if (output !== void 0) {
+      setLogOutput(level, output.write);
+    }
+  }
+}
+
 // src/shared/cli/functions/run-cli.function.ts
 async function runCli(argv, deps2) {
   const options = parseArgs(argv);
+  const logLevel = resolveLogLevel(options.logLevel);
+  configureLog({ level: logLevel });
+  log("command: " + options.command, 0 /* DEBUG */);
+  if (options.command === "init") {
+    log('--init is deprecated, use "kbdb db init"', 2 /* WARNING */);
+  }
+  if (options.command === "migrate") {
+    log(
+      '--migrate is deprecated, use "kbdb db migrate"',
+      2 /* WARNING */
+    );
+  }
+  const nonInteractive = options.nonInteractive || process.env["KBDB_NON_INTERACTIVE"] === "1" || process.env["KBDB_NON_INTERACTIVE"] === "true";
+  const effectiveDeps = nonInteractive ? { ...deps2, isStdinTty: () => false } : deps2;
   if (!options.formatExplicit) {
-    options.format = deps2.isStdoutTty() ? "text" : "json";
+    options.format = effectiveDeps.isStdoutTty() ? "text" : "json";
   }
   if (options.command === "help" || !options.command) {
     const helpCommand = options.args[0];
@@ -2531,21 +2875,29 @@ async function runCli(argv, deps2) {
     return { output: VERSION, exitCode: 0 };
   }
   if (options.command === "init" || options.command === "db-init") {
-    return handleInit(options, deps2);
+    return handleInit(options, effectiveDeps);
   }
   if (options.command === "mcp") {
-    return handleMcp(options, deps2);
+    return handleMcp(options, effectiveDeps);
   }
   if (options.command === "migrate" || options.command === "db-migrate") {
-    return handleMigrate(options, deps2);
+    return handleMigrate(options, effectiveDeps);
   }
   if (options.command === "worker-stop") {
-    return handleWorkerLifecycle(options, deps2, runWorkerStop);
+    return handleWorkerLifecycle(
+      options,
+      effectiveDeps,
+      runWorkerStop
+    );
   }
   if (options.command === "worker-restart") {
-    return handleWorkerLifecycle(options, deps2, runWorkerRestart);
+    return handleWorkerLifecycle(
+      options,
+      effectiveDeps,
+      runWorkerRestart
+    );
   }
-  return handleDataCommand(options, deps2);
+  return handleDataCommand(options, effectiveDeps);
 }
 function handleInit(options, deps2) {
   const result = deps2.runInit(options);
@@ -2686,6 +3038,7 @@ async function handleDataCommand(options, deps2) {
     }
     dbDir = initResult.targetPath;
   }
+  log("db path: " + dbDir, 0 /* DEBUG */);
   const timeoutMs = resolveTimeoutMs(options);
   const maxRetries = resolveRetryCount(options);
   try {
@@ -3458,6 +3811,7 @@ function asStringArray2(value) {
   return [];
 }
 async function handleToolCall(client, name, args) {
+  log("tool call: " + name, 0 /* DEBUG */);
   try {
     switch (name) {
       case "search":
@@ -3501,6 +3855,7 @@ async function handleToolCall(client, name, args) {
       case "auto-capture-review":
         return handleAutoCaptureReview();
       default:
+        log("unknown tool: " + name, 2 /* WARNING */);
         return {
           content: [
             {
@@ -3512,6 +3867,10 @@ async function handleToolCall(client, name, args) {
         };
     }
   } catch (err) {
+    log(
+      "tool call failed: " + name + ": " + (err instanceof Error ? err.message : String(err)),
+      3 /* ERROR */
+    );
     return {
       content: [
         {
@@ -3886,6 +4245,7 @@ async function handleResourceRead(client, uri) {
       ]
     };
   }
+  log(`Unknown resource URI: ${uri}`, 3 /* ERROR */);
   throw new Error(`Unknown resource URI: ${uri}`);
 }
 
@@ -3962,6 +4322,7 @@ async function handleAgentPrompt(name, client) {
   const agents = await client.listDocumentsByType("agent");
   const doc = agents.find((a) => a.title === agentName);
   if (!doc) {
+    log("agent not found: " + agentName, 3 /* ERROR */);
     throw new Error("agent not found: " + agentName);
   }
   const sections = doc.sections;
@@ -4006,6 +4367,7 @@ async function handleSkillPrompt(name, promptArgs, client) {
     }
   }
   if (matchContent === void 0) {
+    log(`Prompt not found: ${name}`, 3 /* ERROR */);
     throw new Error(`Prompt not found: ${name}`);
   }
   const parsed = JSON.parse(matchContent);
@@ -4119,6 +4481,7 @@ function isSamplingResponse(v) {
 async function runAutoCapture(controller, config, client, hostCapabilities, requestSampling) {
   try {
     const trigger = controller.evaluate();
+    log("auto-capture trigger evaluated", 0 /* DEBUG */);
     if (!trigger.shouldCapture) return;
     if (!hasSamplingCapability(hostCapabilities)) return;
     const prompt = buildCapturePrompt("recent conversation context");
@@ -4130,17 +4493,20 @@ async function runAutoCapture(controller, config, client, hostCapabilities, requ
     const text = raw.content.text.trim();
     if (!text) return;
     if (config.dryRun) return;
+    log("auto-capture storing knowledge", 0 /* DEBUG */);
     await client.addSection({
       sectionType: "text/markdown",
       content: text,
       title: "Auto-captured knowledge"
     });
   } catch {
+    log("auto-capture error (non-fatal)", 0 /* DEBUG */);
   }
 }
 
 // src/shared/auto-capture/functions/evaluate-trigger.function.ts
 function evaluateTrigger(config, state) {
+  log("evaluating auto-capture trigger conditions", 0 /* DEBUG */);
   if (!config.enabled) {
     return {
       shouldCapture: false,
@@ -4192,6 +4558,7 @@ var AutoCaptureController = class {
    * @returns the trigger decision with a human-readable reason
    */
   evaluate() {
+    log("evaluating auto-capture trigger", 0 /* DEBUG */);
     const trigger = evaluateTrigger(this.config, this.state());
     if (trigger.shouldCapture) {
       this.totalCapturesThisSession += 1;
@@ -4202,6 +4569,7 @@ var AutoCaptureController = class {
   }
   /** Reset all counters, e.g. on client disconnect. */
   reset() {
+    log("resetting auto-capture controller", 0 /* DEBUG */);
     this.toolCallsSinceLastCapture = 0;
     this.lastCaptureTimestamp = 0;
     this.totalCapturesThisSession = 0;
@@ -4252,10 +4620,12 @@ var McpServer = class {
   }
   async reconnectClient() {
     if (!this.clientFactory) {
+      log("no client factory for reconnect", 3 /* ERROR */);
       throw new Error("no client factory for reconnect");
     }
     this.client.disconnect();
     this.client = await this.clientFactory();
+    log("MCP client reconnected", 0 /* DEBUG */);
   }
   async withRetry(fn) {
     for (let attempt = 0; ; attempt++) {
@@ -4266,6 +4636,10 @@ var McpServer = class {
         if (code !== "REQUEST_TIMEOUT" || attempt >= this.maxRetries || !this.clientFactory) {
           throw err;
         }
+        log(
+          "request timeout, reconnecting (attempt " + (attempt + 1).toString() + "/" + this.maxRetries.toString() + ")",
+          2 /* WARNING */
+        );
         await this.reconnectClient();
       }
     }
@@ -4275,6 +4649,7 @@ var McpServer = class {
       input: process.stdin,
       terminal: false
     });
+    log("MCP server listening on stdin", 0 /* DEBUG */);
     let pending = Promise.resolve();
     await new Promise((resolve4) => {
       rl.on("line", (line) => {
@@ -4285,6 +4660,7 @@ var McpServer = class {
           this.autoCaptureController?.reset();
           this.autoCaptureController = null;
           this.client.disconnect();
+          log("MCP stdin closed", 0 /* DEBUG */);
           resolve4();
         });
       });
@@ -4348,6 +4724,7 @@ var McpServer = class {
    */
   async requestSampling(messages, maxTokens) {
     if (!this.hostCapabilities?.["sampling"]) {
+      log("Host does not support sampling", 3 /* ERROR */);
       throw new Error("Host does not support sampling");
     }
     return this.sendRequest("sampling/createMessage", {
@@ -4394,10 +4771,12 @@ var McpServer = class {
       return null;
     }
     const request = parsed;
+    log("MCP request: " + request.method, 0 /* DEBUG */);
     if (request.id === void 0) {
       if (request.method === "notifications/initialized" || request.method === "notifications/cancelled") {
         if (request.method === "notifications/initialized" && !this.initialized) {
           this.initialized = true;
+          log("MCP initialized", 1 /* INFO */);
           if (this.autoCaptureConfig !== null) {
             this.autoCaptureController = new AutoCaptureController(this.autoCaptureConfig);
           }
@@ -4634,6 +5013,7 @@ var McpServer = class {
 
 // src/shared/mcp/functions/create-mcp-server.function.ts
 function createMcpServer(client, contextPath, autoCaptureConfig, clientFactory, maxRetries) {
+  log("creating MCP server", 0 /* DEBUG */);
   return new McpServer(
     client,
     contextPath,
@@ -4775,6 +5155,7 @@ var deps = {
   findDb,
   runInit,
   startMcpServer: async (contextPath, clientFactory, maxRetries) => {
+    log("starting MCP server", 1 /* INFO */);
     const client = await createWorkerClient({
       contextPath,
       workerScript
@@ -4795,7 +5176,9 @@ var deps = {
         clientFactory,
         maxRetries
       );
+      log("MCP server listening on stdio", 0 /* DEBUG */);
       await server.listen();
+      log("MCP server closed", 1 /* INFO */);
     } finally {
       client.disconnect();
     }
@@ -4807,7 +5190,7 @@ async function main() {
     console.log(result.output);
   }
   if (result.error) {
-    console.error(result.error);
+    log(result.error, 3 /* ERROR */);
   }
   if (result.exitCode !== 0) {
     process.exitCode = result.exitCode;
@@ -4815,7 +5198,7 @@ async function main() {
 }
 main().catch((err) => {
   const msg = err instanceof Error ? err.message : String(err);
-  console.error(`error: ${msg}`);
+  log("error: " + msg, 3 /* ERROR */);
   process.exitCode = 1;
 });
 //# sourceMappingURL=cli.cjs.map