@dikolab/kbdb 0.4.3 → 0.6.0

package/dist/cli.mjs

@@ -7,10 +7,9 @@ import {
   log,
   parseLogLevel,
   parseWorkerToml,
-  resolveBaseDir,
   resolveLogLevel,
   resolveWorkerScript
-} from "./chunk-BJXEVALU.mjs";
+} from "./chunk-QLJ33C74.mjs";
 
 // src/cli.ts
 import { readFileSync as readFileSync4 } from "node:fs";
@@ -18,7 +17,7 @@ import { join as join9 } from "node:path";
 
 // src/shared/cli/constants/defaults.constant.ts
 var DEFAULT_LIMIT = 20;
-var DEFAULT_FORMAT = "json";
+var DEFAULT_FORMAT = "rec";
 var DEFAULT_MODE = "sections";
 var SUPPORTED_EXTENSIONS = [
   ".md",
@@ -130,6 +129,18 @@ function parseArgs(argv) {
       case "--replace":
         options.replace = true;
         break;
+      case "--level":
+      case "--weight": {
+        const raw = argv[++i];
+        const n = Number(raw);
+        if (!Number.isInteger(n) || n < 1 || n > 6) {
+          throw new Error(
+            `Invalid level "${raw}": must be integer 1-6`
+          );
+        }
+        options.level = n;
+        break;
+      }
       case "--depth":
       case "-d":
         options.depth = Math.min(
@@ -176,18 +187,8 @@ function parseArgs(argv) {
   return options;
 }
 
-// src/shared/cli/functions/format-output.function.ts
-function formatOutput(paged, format) {
-  switch (format) {
-    case "json":
-      return JSON.stringify(paged, null, 2);
-    case "text":
-      return formatText(paged);
-    case "mcp":
-      return formatMcp(paged);
-  }
-}
-function formatText(paged) {
+// src/shared/cli/functions/format-text-output.function.ts
+function formatTextOutput(paged) {
   if (paged.items.length === 0) return "No results found.";
   const start = paged.offset + 1;
   const end = paged.offset + paged.items.length;
@@ -207,7 +208,9 @@ Showing ${String(start)}-${String(end)} of ${String(paged.total)} results`;
 Use --offset ${String(end)} to see more` : "";
   return lines + footer + hint;
 }
-function formatMcp(paged) {
+
+// src/shared/cli/functions/format-mcp-output.function.ts
+function formatMcpOutput(paged) {
   const mcpItems = paged.items.map((r) => ({
     kbid: r.kbid,
     heading: r.heading,
@@ -236,6 +239,168 @@ function formatMcp(paged) {
   );
 }
 
+// src/shared/cli/functions/resolve-recfile-key.function.ts
+function resolveRecfileKey(obj, key) {
+  const parts = key.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+
+// src/shared/cli/functions/render-recfile-value.function.ts
+function renderRecfileValue(value) {
+  if (value === null || value === void 0) return null;
+  if (Array.isArray(value)) {
+    if (value.length === 0) return null;
+    return value.map(String).join(", ");
+  }
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") return String(value);
+  if (typeof value === "string") return value === "" ? null : value;
+  return JSON.stringify(value);
+}
+
+// src/shared/cli/functions/format-recfile-output.function.ts
+function formatRecfileOutput(data, fields) {
+  const records = Array.isArray(data) ? data : [data];
+  return records.map((record) => formatRecord(record, fields)).filter(Boolean).join("\n\n");
+}
+function formatRecord(record, fields) {
+  if (!record || typeof record !== "object") return "";
+  const lines = [];
+  for (const [field, key] of fields) {
+    const value = resolveRecfileKey(record, key);
+    const rendered = renderRecfileValue(value);
+    if (rendered === null) continue;
+    lines.push(formatField(field, rendered));
+  }
+  return lines.join("\n");
+}
+function formatField(field, value) {
+  const lines = value.split("\n");
+  if (lines.length === 1) return `${field}: ${lines[0]}`;
+  return [
+    `${field}: ${lines[0]}`,
+    ...lines.slice(1).map((line) => `+ ${line}`)
+  ].join("\n");
+}
+
+// src/shared/cli/constants/recfile-field-maps.constant.ts
+var SEARCH_FIELDS = [
+  ["kbid", "kbid"],
+  ["heading", "heading"],
+  ["score", "score"],
+  ["confidence", "confidence"],
+  ["type", "type"],
+  ["terms", "matched_terms"],
+  ["fields", "matched_fields"],
+  ["snippet", "snippet"],
+  ["level", "level"]
+];
+var LEARN_FIELDS = [
+  ["kbid", "kbid"],
+  ["path", "path"],
+  ["size", "size"],
+  ["skipped", "skipped"],
+  ["superseded", "superseded"],
+  ["warnings", "warnings"],
+  ["level", "level"]
+];
+var UNLEARN_FIELDS = [
+  ["removed", "removed"],
+  ["elapsed_ms", "elapsed_ms"]
+];
+var RECALL_FIELDS = [
+  ["kbid", "kbid"],
+  ["heading", "heading"],
+  ["type", "type"],
+  ["docids", "docids"],
+  ["content", "content"],
+  ["level", "level"]
+];
+var EXPORT_FIELDS = [
+  ["path", "path"],
+  ["sections", "sections_exported"],
+  ["documents", "documents_exported"],
+  ["elapsed_ms", "elapsed_ms"]
+];
+var IMPORT_FIELDS = [
+  ["sections", "sections_imported"],
+  ["documents", "documents_imported"],
+  ["rebuilt", "rebuilt"],
+  ["dry_run", "dry_run"],
+  ["elapsed_ms", "elapsed_ms"]
+];
+var STATUS_FIELDS = [
+  ["initialized", "initialized"],
+  ["path", "contextPath"],
+  ["content_cached", "cacheStats.contentCount"],
+  ["index_cached", "cacheStats.indexCount"]
+];
+var CHECK_FIELDS = [
+  ["ok", "ok"],
+  ["sections_checked", "sections_checked"],
+  ["documents_checked", "documents_checked"],
+  ["references_checked", "references_checked"],
+  ["elapsed_ms", "elapsed_ms"]
+];
+var GC_FIELDS = [
+  ["removed_sections", "removed_sections"],
+  ["removed_bytes", "removed_bytes"],
+  ["elapsed_ms", "elapsed_ms"]
+];
+var REBUILD_FIELDS = [
+  ["sections_reindexed", "sections_reindexed"],
+  ["terms_indexed", "terms_indexed"],
+  ["elapsed_ms", "elapsed_ms"]
+];
+
+// src/shared/cli/functions/format-output.function.ts
+function formatOutput(paged, format) {
+  switch (format) {
+    case "json":
+      return JSON.stringify(paged, null, 2);
+    case "text":
+      return formatTextOutput(paged);
+    case "rec":
+      return formatRecfileOutput(paged.items, SEARCH_FIELDS);
+    case "mcp":
+      return formatMcpOutput(paged);
+  }
+}
+
+// src/shared/cli/constants/recfile-command-field-map.constant.ts
+var RECFILE_COMMAND_FIELD_MAP = {
+  learn: LEARN_FIELDS,
+  unlearn: UNLEARN_FIELDS,
+  recall: RECALL_FIELDS,
+  export: EXPORT_FIELDS,
+  import: IMPORT_FIELDS,
+  status: STATUS_FIELDS,
+  check: CHECK_FIELDS,
+  gc: GC_FIELDS,
+  rebuild: REBUILD_FIELDS
+};
+
+// src/shared/cli/functions/format-command-output.function.ts
+function formatCommandOutput(data, format, command) {
+  switch (format) {
+    case "rec": {
+      const fields = RECFILE_COMMAND_FIELD_MAP[command];
+      return fields ? formatRecfileOutput(data, fields) : JSON.stringify(data, null, 2);
+    }
+    case "json":
+    case "text":
+    case "mcp":
+      return JSON.stringify(data, null, 2);
+  }
+}
+
 // src/shared/cli/functions/run-search.function.ts
 async function runSearch(client, options) {
   log("searching: " + options.args.join(" "), 0 /* DEBUG */);
@@ -332,15 +497,64 @@ async function runRecall(client, options) {
 }
 
 // src/shared/cli/functions/run-export.function.ts
+import { resolve } from "node:path";
 async function runExport(client, options) {
   log("running export", 0 /* DEBUG */);
-  const path = options.args[0];
+  const path = options.args.length > 0 ? resolve(process.cwd(), options.args[0]) : void 0;
   return client.export({ path });
 }
 
 // src/shared/cli/functions/run-learn.function.ts
-import { readFileSync, readdirSync, statSync } from "node:fs";
+import { readFileSync } from "node:fs";
+
+// src/shared/cli/functions/collect-files.function.ts
+import { readdirSync, statSync } from "node:fs";
 import { basename, extname, join } from "node:path";
+function collectFiles(target) {
+  try {
+    const stat = statSync(target);
+    if (stat.isFile()) {
+      return isSupportedFile(target) ? [target] : [];
+    }
+    if (stat.isDirectory()) {
+      return scanDirectory(target);
+    }
+  } catch {
+  }
+  return [];
+}
+function scanDirectory(dir) {
+  const files = [];
+  for (const entry of readdirSync(dir)) {
+    if (entry.startsWith(".")) continue;
+    const full = join(dir, entry);
+    try {
+      const stat = statSync(full);
+      if (stat.isDirectory()) {
+        files.push(...scanDirectory(full));
+      } else if (isSupportedFile(full)) {
+        files.push(full);
+      }
+    } catch {
+    }
+  }
+  return files;
+}
+function isSupportedFile(path) {
+  if (basename(path).startsWith(".")) return false;
+  const ext = extname(path).toLowerCase();
+  return SUPPORTED_EXTENSIONS.includes(ext);
+}
+
+// src/shared/cli/functions/compute-directory-level.function.ts
+var MAX_LEVEL = 6;
+function computeDirectoryLevel(filePath, basePath) {
+  const relative = filePath.slice(basePath.length).replace(/^\//, "");
+  const depth = relative.split("/").length - 1;
+  return Math.min(depth + 1, MAX_LEVEL);
+}
+
+// src/shared/cli/functions/run-learn.function.ts
 async function runLearn(client, options, io) {
   log(
     "learning " + options.args.length.toString() + " targets",
@@ -361,7 +575,8 @@ async function runLearn(client, options, io) {
         description: options.description,
         docid: options.docid,
         tags: options.tags,
-        replace: options.replace
+        replace: options.replace,
+        level: options.level
       });
       results.push(mapAddSectionResult(result, "-", content.length));
       continue;
@@ -377,7 +592,8 @@ async function runLearn(client, options, io) {
         docid: options.docid,
         tags: options.tags,
         replace: options.replace,
-        sourcePath: file
+        sourcePath: file,
+        level: options.level ?? computeDirectoryLevel(file, target)
       });
       results.push(
         mapAddSectionResult(result, file, content.length)
@@ -402,52 +618,17 @@ function mapAddSectionResult(result, path, size) {
   };
 }
 function readProcessStdin() {
-  return new Promise((resolve4) => {
+  return new Promise((resolve7) => {
     const chunks = [];
     process.stdin.on("data", (chunk) => {
       chunks.push(chunk);
     });
     process.stdin.on("end", () => {
-      resolve4(Buffer.concat(chunks).toString("utf-8"));
+      resolve7(Buffer.concat(chunks).toString("utf-8"));
     });
     process.stdin.resume();
   });
 }
-function collectFiles(target) {
-  try {
-    const stat = statSync(target);
-    if (stat.isFile()) {
-      return isSupportedFile(target) ? [target] : [];
-    }
-    if (stat.isDirectory()) {
-      return scanDirectory(target);
-    }
-  } catch {
-  }
-  return [];
-}
-function scanDirectory(dir) {
-  const files = [];
-  for (const entry of readdirSync(dir)) {
-    if (entry.startsWith(".")) continue;
-    const full = join(dir, entry);
-    try {
-      const stat = statSync(full);
-      if (stat.isDirectory()) {
-        files.push(...scanDirectory(full));
-      } else if (isSupportedFile(full)) {
-        files.push(full);
-      }
-    } catch {
-    }
-  }
-  return files;
-}
-function isSupportedFile(path) {
-  if (basename(path).startsWith(".")) return false;
-  const ext = extname(path).toLowerCase();
-  return SUPPORTED_EXTENSIONS.includes(ext);
-}
 
 // src/shared/cli/functions/run-unlearn.function.ts
 async function runUnlearn(client, options) {
@@ -508,10 +689,10 @@ async function runRebuild(client, _options) {
 
 // src/shared/cli/functions/find-db.function.ts
 import { existsSync } from "node:fs";
-import { dirname, join as join2, resolve } from "node:path";
+import { dirname, join as join2, resolve as resolve2 } from "node:path";
 function findDb(dbPath) {
   if (dbPath) {
-    const target = join2(resolve(dbPath), ".kbdb");
+    const target = join2(resolve2(dbPath), ".kbdb");
     return existsSync(target) ? target : null;
   }
   let current = process.cwd();
@@ -528,7 +709,7 @@ function findDb(dbPath) {
 
 // src/shared/cli/functions/run-init.function.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join4, resolve as resolve2 } from "node:path";
+import { join as join4, resolve as resolve3 } from "node:path";
 
 // src/shared/cli/functions/install-default-skills.function.ts
 import { createHash } from "node:crypto";
@@ -659,7 +840,7 @@ function createScaffold(dbDir) {
 }
 function runInit(options) {
   log("running init", 0 /* DEBUG */);
-  const basePath = options.dbPath ? resolve2(options.dbPath) : process.cwd();
+  const basePath = options.dbPath ? resolve3(options.dbPath) : process.cwd();
   const dbDir = join4(basePath, ".kbdb");
   try {
     if (existsSync3(dbDir)) {
@@ -696,14 +877,14 @@ async function promptUser(question, io) {
   return answer.trim();
 }
 function askReadline(question) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve7) => {
     const rl = createInterface({
       input: process.stdin,
       output: process.stdout
     });
     rl.question(question, (answer) => {
       rl.close();
-      resolve4(answer);
+      resolve7(answer);
     });
   });
 }
@@ -1033,6 +1214,7 @@ async function runAgentDelete(client, options) {
 }
 
 // src/shared/cli/functions/run-import.function.ts
+import { resolve as resolve4 } from "node:path";
 async function runImport(client, options) {
   const from = options.from;
   if (!from) {
@@ -1041,11 +1223,24 @@ async function runImport(client, options) {
     throw new Error(msg);
   }
   return client.import({
-    from,
+    from: resolve4(process.cwd(), from),
     dryRun: options.dryRun === true
   });
 }
 
+// src/shared/cli/functions/hydrate-search-previews.function.ts
+async function hydrateSearchPreviews(client, paged) {
+  await Promise.all(
+    paged.items.map(async (result) => {
+      try {
+        const contentResult = await client.content([result.kbid]);
+        result.preview = contentResult.data;
+      } catch {
+      }
+    })
+  );
+}
+
 // src/shared/cli/functions/dispatch-command.function.ts
 async function dispatchCommand(client, options, io) {
   log("dispatching command: " + options.command, 0 /* DEBUG */);
@@ -1120,7 +1315,7 @@ async function handleLearn(client, options, io) {
   try {
     const results = await runLearn(client, options, io);
     return {
-      output: JSON.stringify(results, null, 2),
+      output: formatCommandOutput(results, options.format, "learn"),
       exitCode: 0
     };
   } catch (err) {
@@ -1134,7 +1329,11 @@ async function handleUnlearn(client, options) {
   try {
     const results = await runUnlearn(client, options);
     return {
-      output: JSON.stringify(results, null, 2),
+      output: formatCommandOutput(
+        results,
+        options.format,
+        "unlearn"
+      ),
       exitCode: 0
     };
   } catch (err) {
@@ -1171,7 +1370,7 @@ async function handleRecall(client, options) {
       };
     }
     return {
-      output: JSON.stringify(result, null, 2),
+      output: formatCommandOutput(result, options.format, "recall"),
       exitCode: 0
     };
   } catch (err) {
@@ -1185,7 +1384,7 @@ async function handleExport(client, options) {
   try {
     const result = await runExport(client, options);
     return {
-      output: JSON.stringify(result, null, 2),
+      output: formatCommandOutput(result, options.format, "export"),
       exitCode: 0
     };
   } catch (err) {
@@ -1199,7 +1398,7 @@ async function handleImport(client, options) {
   try {
     const result = await runImport(client, options);
     return {
-      output: JSON.stringify(result, null, 2),
+      output: formatCommandOutput(result, options.format, "import"),
       exitCode: 0
     };
   } catch (err) {
@@ -1212,6 +1411,9 @@ async function handleImport(client, options) {
 async function handleContent(client, options) {
   try {
     const result = await runContent(client, options);
+    if (options.format === "rec") {
+      return { output: result.data, exitCode: 0 };
+    }
     return {
       output: JSON.stringify(result, null, 2),
       exitCode: 0
@@ -1227,7 +1429,7 @@ async function handleCheck(client, options) {
   try {
     const result = await runCheck(client, options);
     return {
-      output: JSON.stringify(result, null, 2),
+      output: formatCommandOutput(result, options.format, "check"),
       exitCode: result.ok ? 0 : 1
     };
   } catch (err) {
@@ -1241,7 +1443,7 @@ async function handleGc(client, options) {
   try {
     const result = await runGc(client, options);
     return {
-      output: JSON.stringify(result, null, 2),
+      output: formatCommandOutput(result, options.format, "gc"),
       exitCode: 0
     };
   } catch (err) {
@@ -1255,7 +1457,7 @@ async function handleRebuild(client, options) {
   try {
     const result = await runRebuild(client, options);
     return {
-      output: JSON.stringify(result, null, 2),
+      output: formatCommandOutput(result, options.format, "rebuild"),
       exitCode: 0
     };
   } catch (err) {
@@ -1269,7 +1471,7 @@ async function handleStatus(client, options) {
   try {
     const result = await runStatus(client, options);
     return {
-      output: JSON.stringify(result, null, 2),
+      output: formatCommandOutput(result, options.format, "status"),
       exitCode: 0
     };
   } catch (err) {
@@ -1286,7 +1488,11 @@ async function handleDbMigrate(client, options) {
   try {
     const result = await runDbMigrate(client, options);
     return {
-      output: JSON.stringify(result, null, 2),
+      output: formatCommandOutput(
+        result,
+        options.format,
+        "db-migrate"
+      ),
       exitCode: 0
     };
   } catch (err) {
@@ -1296,20 +1502,9 @@ async function handleDbMigrate(client, options) {
     };
   }
 }
-async function hydrateSearchPreviews(client, paged) {
-  await Promise.all(
-    paged.items.map(async (result) => {
-      try {
-        const contentResult = await client.content([result.kbid]);
-        result.preview = contentResult.data;
-      } catch {
-      }
-    })
-  );
-}
 
 // src/shared/version/constants/version.constant.ts
-var VERSION = "0.4.3";
+var VERSION = "0.6.0";
 
 // src/shared/cli/functions/generate-help.function.ts
 var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
@@ -1332,7 +1527,8 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
 var GROUP_SUBCOMMANDS = {
   db: [
     ["init", "Initialise a new .kbdb directory"],
-    ["migrate", "Migrate database to current format"]
+    ["migrate", "Migrate database to current format"],
+    ["path", "Show resolved database path"]
   ],
   skill: [
     ["learn", "Create a new skill definition"],
@@ -1396,6 +1592,7 @@ Knowledge Base:
 Database:
    db init             Initialise a new .kbdb directory
    db migrate          Migrate database to current format
+   db path             Show resolved database path
 
 Maintenance:
    check               Verify knowledge base integrity
@@ -1692,6 +1889,30 @@ Output:
 Examples:
    kbdb db migrate
    kbdb db migrate --db /path/to/project
+`,
+  "db-path": `kbdb db path - Show resolved database path
+
+Usage: kbdb db path [options]
+
+Prints the absolute path of the .kbdb database
+that would be used by the current command
+context. Useful for debugging database
+resolution.
+
+Resolution order:
+   1. --db <path>       Explicit flag
+   2. cwd traversal     Walk up from cwd
+   3. KBDB_DB_DIR       Environment variable
+
+Options:
+   --db <path>         Path to .kbdb directory
+   --format json       Show full diagnostic
+   -h, --help          Show this help message
+
+Examples:
+   kbdb db path
+   kbdb db path --format json
+   kbdb db path --db /path/to/project
 `,
   "skill-learn": `kbdb skill learn - Create a new skill definition
 
@@ -1853,6 +2074,73 @@ function generateSubcommandHelp(command, subcommand) {
   return generateCommandHelp(command);
 }
 
+// src/shared/cli/functions/resolve-db-dir.function.ts
+function resolveDbDir(options, findDb2) {
+  if (options.dbPath) {
+    const flagResult = findDb2(options.dbPath);
+    return flagResult ? { path: flagResult, source: "flag" } : null;
+  }
+  if (!options.skipTraversal) {
+    const traversalResult = findDb2();
+    if (traversalResult) {
+      return { path: traversalResult, source: "traversal" };
+    }
+  }
+  const envDir = process.env["KBDB_DB_DIR"];
+  if (envDir) {
+    const envResult = findDb2(envDir);
+    if (envResult) {
+      return { path: envResult, source: "env" };
+    }
+  }
+  return null;
+}
+
+// src/shared/cli/functions/format-db-not-found.function.ts
+function formatDbNotFound(options) {
+  if (options.dbPath) {
+    return `error: no .kbdb database found at ${options.dbPath}`;
+  }
+  const envValue = process.env["KBDB_DB_DIR"] ?? "(not set)";
+  const lines = [
+    "error: no .kbdb database found",
+    "  --db:         (not set)"
+  ];
+  if (!options.skipTraversal) {
+    lines.push(`  cwd:          ${process.cwd()} (searched upward)`);
+  }
+  lines.push(`  KBDB_DB_DIR:  ${envValue}`);
+  if (!options.skipTraversal) {
+    lines.push('Run "kbdb db init" to create a database.');
+  }
+  return lines.join("\n");
+}
+
+// src/shared/cli/functions/run-db-path.function.ts
+function runDbPath(options, findDb2) {
+  const resolution = resolveDbDir({ dbPath: options.dbPath }, findDb2);
+  if (!resolution) {
+    return {
+      error: formatDbNotFound({ dbPath: options.dbPath }),
+      exitCode: 1
+    };
+  }
+  if (options.format === "json") {
+    const diagnostic = {
+      path: resolution.path,
+      source: resolution.source,
+      flag: options.dbPath ?? null,
+      cwd: process.cwd(),
+      env: process.env["KBDB_DB_DIR"] ?? null
+    };
+    return {
+      output: JSON.stringify(diagnostic, null, 2),
+      exitCode: 0
+    };
+  }
+  return { output: resolution.path, exitCode: 0 };
+}
+
 // src/shared/worker-client/classes/worker-client.class.ts
 import { connect } from "node:net";
 
@@ -1997,7 +2285,7 @@ var WorkerClient = class {
    * post-connect failure handlers.
    */
   async tryConnect() {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve7, reject) => {
       const sock = connect(this.socketPath, () => {
         sock.removeListener("error", reject);
         sock.setKeepAlive(true, 3e4);
@@ -2018,7 +2306,7 @@ var WorkerClient = class {
           this.socket = null;
         });
         this.socket = sock;
-        resolve4();
+        resolve7();
       });
       sock.on("error", reject);
       sock.on("data", (chunk) => {
@@ -2346,8 +2634,8 @@ var WorkerClient = class {
       params: { ctx: this.contextId, ...params }
     };
     const timeoutMs = this.requestTimeoutMs;
-    return new Promise((resolve4, reject) => {
-      const call = { resolve: resolve4, reject };
+    return new Promise((resolve7, reject) => {
+      const call = { resolve: resolve7, reject };
       if (timeoutMs) {
         call.timer = setTimeout(() => {
           if (!this.pending.has(id)) return;
@@ -2416,16 +2704,11 @@ var WorkerClient = class {
   }
 };
 
-// src/shared/worker-client/functions/create-worker-client.function.ts
-import { existsSync as existsSync7, readFileSync as readFileSync3, unlinkSync as unlinkSync2 } from "node:fs";
-import { join as join8 } from "node:path";
-import { tmpdir as tmpdir3 } from "node:os";
-
 // src/shared/worker-client/functions/resolve-db-path.function.ts
 import { existsSync as existsSync5 } from "node:fs";
-import { join as join6, resolve as resolve3 } from "node:path";
+import { join as join6, resolve as resolve5 } from "node:path";
 function resolveDbPath(targetDir) {
-  const base = targetDir ? resolve3(targetDir) : process.cwd();
+  const base = targetDir ? resolve5(targetDir) : process.cwd();
   const dbPath = join6(base, ".kbdb");
   if (!existsSync5(dbPath)) {
     const msg = `database not found: ${dbPath}`;
@@ -2443,16 +2726,35 @@ async function computeContextId(absolutePath) {
 
 // src/shared/worker-client/functions/spawn-daemon.function.ts
 import { spawn } from "node:child_process";
-function spawnDaemon(contextPath, runtime2, workerScript2) {
-  if (!workerScript2) {
+
+// src/shared/worker-client/functions/build-deno-permissions.function.ts
+function buildDenoPermissions() {
+  return [
+    "--allow-read",
+    "--allow-write",
+    "--allow-env",
+    "--allow-run",
+    "--allow-sys"
+  ];
+}
+
+// src/shared/worker-client/functions/spawn-daemon.function.ts
+function spawnDaemon(contextPath, runtime, workerScript) {
+  if (!workerScript) {
     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 execPath = runtime === "deno" ? "deno" : process.execPath;
   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];
+  const args = runtime === "deno" ? [
+    "run",
+    ...buildDenoPermissions(),
+    workerScript,
+    contextPath,
+    ...logArgs
+  ] : [workerScript, contextPath, ...logArgs];
   log(
     "spawning daemon: " + execPath + " " + args.join(" "),
     0 /* DEBUG */
@@ -2498,6 +2800,40 @@ async function waitForDaemon(contextId, timeoutMs = DEFAULT_TIMEOUT_MS) {
   return false;
 }
 
+// src/shared/worker-client/functions/read-crash-reason.function.ts
+import { existsSync as existsSync7, readFileSync as readFileSync3, unlinkSync as unlinkSync2 } from "node:fs";
+import { join as join8 } from "node:path";
+import { tmpdir as tmpdir3 } from "node:os";
+function readCrashReason(contextId) {
+  const crashPath = join8(tmpdir3(), `kbdb-${contextId}.crash`);
+  if (!existsSync7(crashPath)) {
+    return "daemon failed to start (no details available)";
+  }
+  try {
+    const raw = readFileSync3(crashPath, "utf-8");
+    const crash = JSON.parse(raw);
+    unlinkSync2(crashPath);
+    return crash.error ?? "unknown error (crash log empty)";
+  } catch {
+    return "daemon failed to start (crash log unreadable)";
+  }
+}
+
+// src/shared/worker-client/functions/resolve-spawn-script.function.ts
+import { dirname as dirname2, resolve as resolve6 } from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveSpawnScript(runtime) {
+  return resolveWorkerScript(resolveScriptDir(runtime), runtime);
+}
+function resolveScriptDir(runtime) {
+  if (typeof __dirname !== "undefined") return __dirname;
+  const thisDir = dirname2(fileURLToPath(import.meta.url));
+  if (runtime === "deno") {
+    return resolve6(thisDir, "..", "..", "..");
+  }
+  return thisDir;
+}
+
 // src/shared/worker-client/functions/create-worker-client.function.ts
 async function createWorkerClient(options) {
   const dbPath = options?.contextPath ?? resolveDbPath(options?.dbPath);
@@ -2511,9 +2847,10 @@ async function createWorkerClient(options) {
     log("no daemon found", 0 /* DEBUG */);
   }
   if (!daemon && options?.autoSpawn !== false) {
-    const runtime2 = detectRuntime();
+    const runtime = detectRuntime();
     log("auto-spawning daemon", 0 /* DEBUG */);
-    spawnDaemon(dbPath, runtime2, options?.workerScript);
+    const workerScript = resolveSpawnScript(runtime);
+    spawnDaemon(dbPath, runtime, workerScript);
     log("waiting for daemon after spawn", 0 /* DEBUG */);
     await waitForDaemon(contextId, options?.connectTimeoutMs);
     daemon = discoverDaemon(contextId);
@@ -2532,20 +2869,6 @@ async function createWorkerClient(options) {
   await client.connect();
   return client;
 }
-function readCrashReason(contextId) {
-  const crashPath = join8(tmpdir3(), `kbdb-${contextId}.crash`);
-  if (!existsSync7(crashPath)) {
-    return "daemon failed to start (no details available)";
-  }
-  try {
-    const raw = readFileSync3(crashPath, "utf-8");
-    const crash = JSON.parse(raw);
-    unlinkSync2(crashPath);
-    return crash.error ?? "unknown error (crash log empty)";
-  } catch {
-    return "daemon failed to start (crash log unreadable)";
-  }
-}
 
 // src/shared/cli/functions/run-worker-stop.function.ts
 async function runWorkerStop(dbDir) {
@@ -2609,11 +2932,6 @@ async function runWorkerRestart(dbDir) {
   };
 }
 
-// src/shared/cli/functions/resolve-raw-db-path.function.ts
-function resolveRawDbPath(options) {
-  return options.dbPath ?? process.env["KBDB_DB_DIR"];
-}
-
 // src/shared/worker-client/functions/retry-on-timeout.function.ts
 async function retryOnTimeout(createClient, operation, maxRetries) {
   let lastError = new Error("retryOnTimeout exhausted");
@@ -2682,9 +3000,6 @@ async function runCli(argv, deps2) {
   }
   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 = effectiveDeps.isStdoutTty() ? "text" : "json";
-  }
   if (options.command === "help" || !options.command) {
     const helpCommand = options.args[0];
     const helpSubcommand = options.args[1];
@@ -2700,6 +3015,9 @@ async function runCli(argv, deps2) {
   if (options.command === "init" || options.command === "db-init") {
     return handleInit(options, effectiveDeps);
   }
+  if (options.command === "db-path") {
+    return runDbPath(options, effectiveDeps.findDb);
+  }
   if (options.command === "mcp") {
     return handleMcp(options, effectiveDeps);
   }
@@ -2742,14 +3060,20 @@ function resolveRetryCount(options) {
   return options.retry ?? (parseInt(process.env["KBDB_RETRY"] ?? "", 10) || DEFAULT_RETRY_COUNT);
 }
 async function handleMcp(options, deps2) {
-  const explicitPath = resolveRawDbPath(options);
-  const dbDir = deps2.findDb(explicitPath);
-  if (!dbDir) {
+  const resolution = resolveDbDir(
+    { dbPath: options.dbPath, skipTraversal: true },
+    deps2.findDb
+  );
+  if (!resolution) {
     return {
-      error: "error: no .kbdb database found at " + (explicitPath ?? process.cwd()),
+      error: formatDbNotFound({
+        dbPath: options.dbPath,
+        skipTraversal: true
+      }),
       exitCode: 1
     };
   }
+  const dbDir = resolution.path;
   const timeoutMs = resolveTimeoutMs(options);
   const maxRetries = resolveRetryCount(options);
   let client;
@@ -2788,14 +3112,17 @@ async function handleMcp(options, deps2) {
   }
 }
 async function handleMigrate(options, deps2) {
-  const dbDir = deps2.findDb(options.dbPath);
-  if (!dbDir) {
-    const basePath = options.dbPath ?? process.cwd();
+  const resolution = resolveDbDir(
+    { dbPath: options.dbPath },
+    deps2.findDb
+  );
+  if (!resolution) {
     return {
-      error: `error: no .kbdb database found at ${basePath}`,
+      error: formatDbNotFound({ dbPath: options.dbPath }),
       exitCode: 1
     };
   }
+  const dbDir = resolution.path;
   let client;
   try {
     client = await deps2.createWorkerClient({
@@ -2833,13 +3160,18 @@ async function handleMigrate(options, deps2) {
   }
 }
 async function handleDataCommand(options, deps2) {
-  const explicitPath = resolveRawDbPath(options);
-  let dbDir = deps2.findDb(explicitPath);
+  const resolution = resolveDbDir(
+    { dbPath: options.dbPath },
+    deps2.findDb
+  );
+  let dbDir = resolution?.path ?? null;
   if (!dbDir) {
-    const basePath = explicitPath ?? process.cwd();
+    const basePath = options.dbPath ?? process.cwd();
     if (!deps2.isStdinTty()) {
       return {
-        error: `error: no .kbdb database found at ${basePath} -- run \`kbdb --init\` to create one`,
+        error: formatDbNotFound({
+          dbPath: options.dbPath
+        }),
         exitCode: 1
       };
     }
@@ -2887,14 +3219,17 @@ async function handleDataCommand(options, deps2) {
   }
 }
 async function handleWorkerLifecycle(options, deps2, action) {
-  const explicitPath = resolveRawDbPath(options);
-  const dbDir = deps2.findDb(explicitPath);
-  if (!dbDir) {
+  const resolution = resolveDbDir(
+    { dbPath: options.dbPath },
+    deps2.findDb
+  );
+  if (!resolution) {
     return {
-      error: "error: no .kbdb database found at " + (explicitPath ?? process.cwd()),
+      error: formatDbNotFound({ dbPath: options.dbPath }),
       exitCode: 1
     };
   }
+  const dbDir = resolution.path;
   return action(dbDir);
 }
 async function versionGate(client, dbDir) {
@@ -4474,7 +4809,7 @@ var McpServer = class {
     });
     log("MCP server listening on stdin", 0 /* DEBUG */);
     let pending = Promise.resolve();
-    await new Promise((resolve4) => {
+    await new Promise((resolve7) => {
       rl.on("line", (line) => {
         pending = pending.then(() => this.dispatchLine(line));
       });
@@ -4484,7 +4819,7 @@ var McpServer = class {
           this.autoCaptureController = null;
           this.client.disconnect();
           log("MCP stdin closed", 0 /* DEBUG */);
-          resolve4();
+          resolve7();
         });
       });
     });
@@ -4528,13 +4863,13 @@ var McpServer = class {
     const id = this.nextRequestId++;
     const request = { jsonrpc: "2.0", id, method, params };
     process.stdout.write(JSON.stringify(request) + "\n");
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve7, reject) => {
       const timer = setTimeout(() => {
         this.pendingRequests.delete(id);
         reject(new Error(`Request ${method} timed out`));
       }, 3e4);
       this.pendingRequests.set(id, {
-        resolve: resolve4,
+        resolve: resolve7,
         reject,
         timer
       });
@@ -4847,22 +5182,16 @@ function createMcpServer(client, contextPath, autoCaptureConfig, clientFactory,
 }
 
 // src/cli.ts
-var runtime = detectRuntime();
-var baseDir = resolveBaseDir(import.meta.url, import.meta.dirname);
-var workerScript = resolveWorkerScript(baseDir.scriptDir, runtime);
 var deps = {
   isStdinTty,
   isStdoutTty: () => process.stdout.isTTY,
   promptUser,
-  createWorkerClient: (opts) => createWorkerClient({ ...opts, workerScript }),
+  createWorkerClient: (opts) => createWorkerClient(opts),
   findDb,
   runInit,
   startMcpServer: async (contextPath, clientFactory, maxRetries) => {
     log("starting MCP server", 1 /* INFO */);
-    const client = await createWorkerClient({
-      contextPath,
-      workerScript
-    });
+    const client = await createWorkerClient({ contextPath });
     try {
       const tomlPath = join9(contextPath, "worker.toml");
       let autoCaptureConfig;