@vpxa/kb 0.1.1

package/packages/cli/dist/helpers.js

@@ -0,0 +1,458 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import {
+  check,
+  find
+} from "@kb/tools";
+function extractNumFlag(args, flag, defaultValue) {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length) return defaultValue;
+  const val = Number.parseInt(args.splice(idx, 2)[1], 10);
+  return Number.isNaN(val) ? defaultValue : val;
+}
+function extractStrFlag(args, flag, defaultValue) {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length) return defaultValue;
+  return args.splice(idx, 2)[1];
+}
+function extractBoolFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1) return false;
+  args.splice(idx, 1);
+  return true;
+}
+async function readStdin() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function readInput(filePath) {
+  if (filePath) return readFile(resolve(filePath), "utf-8");
+  return readStdin();
+}
+function splitCsv(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function parseBatchPayload(input) {
+  const parsed = JSON.parse(input);
+  if (Array.isArray(parsed)) {
+    return { operations: validateBatchOperations(parsed) };
+  }
+  if (parsed && typeof parsed === "object" && "operations" in parsed) {
+    const payload = parsed;
+    return {
+      operations: validateBatchOperations(payload.operations),
+      concurrency: typeof payload.concurrency === "number" ? payload.concurrency : void 0
+    };
+  }
+  throw new Error(
+    "Batch input must be an array of operations or an object with an operations array."
+  );
+}
+function validateBatchOperations(value) {
+  if (!Array.isArray(value)) {
+    throw new Error("Batch operations must be an array.");
+  }
+  return value.map((item, index) => {
+    if (!item || typeof item !== "object") {
+      throw new Error(`Batch operation at index ${index} must be an object.`);
+    }
+    const candidate = item;
+    if (typeof candidate.id !== "string" || candidate.id.length === 0) {
+      throw new Error(`Batch operation at index ${index} is missing a valid id.`);
+    }
+    if (typeof candidate.type !== "string" || candidate.type.length === 0) {
+      throw new Error(`Batch operation ${candidate.id} is missing a valid type.`);
+    }
+    if (!candidate.args || typeof candidate.args !== "object" || Array.isArray(candidate.args)) {
+      throw new Error(`Batch operation ${candidate.id} must include an args object.`);
+    }
+    return {
+      id: candidate.id,
+      type: candidate.type,
+      args: candidate.args
+    };
+  });
+}
+function formatFocusRanges(ranges) {
+  return ranges.map((range) => {
+    const heading = range.heading ? ` ${range.heading}` : "";
+    return `${range.start}-${range.end}${heading}`;
+  }).join(", ");
+}
+function printParsedOutput(result) {
+  switch (result.tool) {
+    case "tsc":
+    case "biome": {
+      console.log(`${result.tool} errors: ${result.errors.length}`);
+      for (const error of result.errors) {
+        const location = [error.line, error.column].filter((value) => value !== void 0).join(":");
+        const prefix = location ? `${error.file}:${location}` : error.file;
+        const code = error.code ? ` ${error.code}` : "";
+        console.log(`- ${prefix} [${error.severity}${code}] ${error.message}`);
+      }
+      return;
+    }
+    case "vitest":
+      console.log("Vitest summary");
+      console.log(`  Passed:  ${result.summary.passed}`);
+      console.log(`  Failed:  ${result.summary.failed}`);
+      console.log(`  Skipped: ${result.summary.skipped}`);
+      if (result.summary.duration !== void 0) {
+        console.log(`  Duration: ${result.summary.duration}ms`);
+      }
+      for (const test of result.summary.tests) {
+        if (test.status !== "fail") continue;
+        console.log(`- ${test.name}${test.file ? ` (${test.file})` : ""}`);
+        if (test.error) console.log(`  ${test.error}`);
+      }
+      return;
+    case "git-status":
+      console.log(`Branch: ${result.status.branch ?? "unknown"}`);
+      console.log(`Staged: ${result.status.staged.length}`);
+      for (const item of result.status.staged) console.log(`  ${item.status} ${item.file}`);
+      console.log(`Unstaged: ${result.status.unstaged.length}`);
+      for (const item of result.status.unstaged) console.log(`  ${item.status} ${item.file}`);
+      console.log(`Untracked: ${result.status.untracked.length}`);
+      for (const item of result.status.untracked) console.log(`  ?? ${item}`);
+      return;
+  }
+}
+function printCheckResult(result) {
+  console.log(`Overall: ${result.passed ? "passed" : "failed"}`);
+  printCheckSection("tsc", result.tsc.passed, result.tsc.errors);
+  printCheckSection("biome", result.biome.passed, result.biome.errors);
+}
+function printCheckSection(label, passed, errors) {
+  console.log(`${label}: ${passed ? "passed" : `${errors.length} issue(s)`}`);
+  for (const error of errors) {
+    const location = [error.line, error.column].filter((value) => value !== void 0).join(":");
+    const prefix = location ? `${error.file}:${location}` : error.file;
+    const code = error.code ? ` ${error.code}` : "";
+    console.log(`  - ${prefix} [${error.severity}${code}] ${error.message}`);
+  }
+}
+function printTestRunResult(result) {
+  console.log(`Vitest: ${result.passed ? "passed" : "failed"}`);
+  console.log(`  Duration: ${result.durationMs}ms`);
+  console.log(`  Passed: ${result.summary.passed}`);
+  console.log(`  Failed: ${result.summary.failed}`);
+  console.log(`  Skipped: ${result.summary.skipped}`);
+  if (result.summary.suites !== void 0) {
+    console.log(`  Suites: ${result.summary.suites}`);
+  }
+  const failedTests = result.summary.tests.filter((test) => test.status === "fail");
+  if (failedTests.length === 0) return;
+  console.log("Failed tests:");
+  for (const test of failedTests) {
+    console.log(`  - ${test.name}${test.file ? ` (${test.file})` : ""}`);
+    if (test.error) console.log(`    ${test.error}`);
+  }
+}
+function printGitContext(result) {
+  console.log(`Branch: ${result.branch}`);
+  console.log(`Staged: ${result.status.staged.length}`);
+  for (const file of result.status.staged) console.log(`  - ${file}`);
+  console.log(`Modified: ${result.status.modified.length}`);
+  for (const file of result.status.modified) console.log(`  - ${file}`);
+  console.log(`Untracked: ${result.status.untracked.length}`);
+  for (const file of result.status.untracked) console.log(`  - ${file}`);
+  console.log("");
+  console.log("Recent commits:");
+  if (result.recentCommits.length === 0) {
+    console.log("  none");
+  } else {
+    for (const commit of result.recentCommits) {
+      console.log(`  - ${commit.hash} ${commit.message}`);
+      console.log(`    ${commit.author} @ ${commit.date}`);
+    }
+  }
+  if (result.diff) {
+    console.log("");
+    console.log("Diff stat:");
+    console.log(result.diff);
+  }
+}
+function printDiffFiles(files) {
+  if (files.length === 0) {
+    console.log("No diff files found.");
+    return;
+  }
+  for (const file of files) {
+    const renameInfo = file.oldPath ? ` (from ${file.oldPath})` : "";
+    console.log(`${file.path}${renameInfo}`);
+    console.log(`  Status: ${file.status}`);
+    console.log(`  Changes: +${file.additions} -${file.deletions}`);
+    console.log(`  Hunks: ${file.hunks.length}`);
+    for (const hunk of file.hunks) {
+      const header = hunk.header ? ` ${hunk.header}` : "";
+      console.log(
+        `    @@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@${header}`
+      );
+    }
+  }
+}
+function printTraceResult(result) {
+  console.log(`Start: ${result.start}`);
+  console.log(`Direction: ${result.direction}`);
+  console.log(`Depth reached: ${result.depth}`);
+  console.log(`Nodes: ${result.nodes.length}`);
+  if (result.nodes.length === 0) {
+    console.log("No trace nodes found.");
+    return;
+  }
+  for (const node of result.nodes) {
+    console.log(`  - [${node.relationship}] ${node.path}:${node.line} ${node.symbol}`);
+  }
+}
+function printExamplesResult(result) {
+  console.log(`Query: ${result.query}`);
+  console.log(`Examples: ${result.examples.length} shown (${result.totalFound} total)`);
+  if (result.examples.length === 0) {
+    console.log("No matching examples found.");
+    return;
+  }
+  for (const example of result.examples) {
+    console.log("");
+    console.log(`${example.path}:${example.startLine}-${example.endLine}`);
+    console.log(`  Context: ${example.context}`);
+    console.log(`  Relevance: ${(example.relevance * 100).toFixed(1)}%`);
+    for (const line of example.content.split("\n")) {
+      console.log(`  ${line}`);
+    }
+  }
+}
+function printManagedProcess(info) {
+  console.log(info.id);
+  console.log(`  Command: ${info.command}${info.args.length > 0 ? ` ${info.args.join(" ")}` : ""}`);
+  console.log(`  PID: ${info.pid ?? "unknown"}`);
+  console.log(`  Status: ${info.status}`);
+  console.log(`  Started: ${info.startedAt}`);
+  if (info.exitCode !== void 0) console.log(`  Exit code: ${info.exitCode}`);
+  console.log(`  Logs: ${info.logs.length}`);
+}
+function printDeadSymbolsResult(result) {
+  console.log(`Exports scanned: ${result.totalExports}`);
+  console.log(`Potentially dead: ${result.totalDead}`);
+  if (result.deadSymbols.length === 0) {
+    console.log("No dead symbols found.");
+    return;
+  }
+  for (const symbolInfo of result.deadSymbols) {
+    console.log(`  - ${symbolInfo.path}:${symbolInfo.line} ${symbolInfo.kind} ${symbolInfo.name}`);
+  }
+}
+function printFileSummary(summary) {
+  console.log(summary.path);
+  console.log(`  Language: ${summary.language}`);
+  console.log(`  Lines: ${summary.lines}`);
+  console.log(`  Estimated tokens: ~${summary.estimatedTokens}`);
+  console.log("");
+  printSection("Imports", summary.imports);
+  printSection("Exports", summary.exports);
+  printSection(
+    "Functions",
+    summary.functions.map(
+      (item) => `${item.name} @ line ${item.line}${item.exported ? " [exported]" : ""}`
+    )
+  );
+  printSection(
+    "Classes",
+    summary.classes.map(
+      (item) => `${item.name} @ line ${item.line}${item.exported ? " [exported]" : ""}`
+    )
+  );
+  printSection(
+    "Interfaces",
+    summary.interfaces.map((item) => `${item.name} @ line ${item.line}`)
+  );
+  printSection(
+    "Types",
+    summary.types.map((item) => `${item.name} @ line ${item.line}`)
+  );
+}
+function printSymbolInfo(result) {
+  console.log(`Symbol: ${result.name}`);
+  if (result.definedIn) {
+    console.log(
+      `Defined in: ${result.definedIn.path}:${result.definedIn.line} (${result.definedIn.kind})`
+    );
+  } else {
+    console.log("Defined in: not found");
+  }
+  console.log("");
+  console.log("Imported by:");
+  if (result.importedBy.length === 0) {
+    console.log("  none");
+  } else {
+    for (const item of result.importedBy) {
+      console.log(`  - ${item.path}:${item.line} ${item.importStatement}`);
+    }
+  }
+  console.log("");
+  console.log("Referenced in:");
+  if (result.referencedIn.length === 0) {
+    console.log("  none");
+  } else {
+    for (const item of result.referencedIn) {
+      console.log(`  - ${item.path}:${item.line} ${item.context}`);
+    }
+  }
+}
+function printWorkset(workset) {
+  console.log(workset.name);
+  console.log(`  Files: ${workset.files.length}`);
+  console.log(`  Updated: ${workset.updated}`);
+  if (workset.description) console.log(`  Description: ${workset.description}`);
+  for (const file of workset.files) console.log(`  - ${file}`);
+}
+function printCheckpoint(checkpoint) {
+  console.log(checkpoint.id);
+  console.log(`  Label: ${checkpoint.label}`);
+  console.log(`  Created: ${checkpoint.createdAt}`);
+  if (checkpoint.notes) console.log(`  Notes: ${checkpoint.notes}`);
+  if (checkpoint.files?.length) {
+    console.log(`  Files: ${checkpoint.files.length}`);
+    for (const file of checkpoint.files) console.log(`  - ${file}`);
+  }
+  console.log("  Data:");
+  for (const line of JSON.stringify(checkpoint.data, null, 2).split("\n")) {
+    console.log(`    ${line}`);
+  }
+}
+function printSection(label, items) {
+  console.log(`${label}:`);
+  if (items.length === 0) {
+    console.log("  none");
+    console.log("");
+    return;
+  }
+  for (const item of items) console.log(`  - ${item}`);
+  console.log("");
+}
+function parseMaybeJsonString(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return value;
+  }
+}
+function parseRecordString(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return {};
+  const parsed = JSON.parse(trimmed);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Checkpoint data must be a JSON object.");
+  }
+  return parsed;
+}
+function rrf(vecResults, ftsResults, k = 60) {
+  const merged = /* @__PURE__ */ new Map();
+  for (let i = 0; i < vecResults.length; i++) {
+    const r = vecResults[i];
+    merged.set(r.record.id, { record: r.record, score: 1 / (k + i + 1) });
+  }
+  for (let i = 0; i < ftsResults.length; i++) {
+    const r = ftsResults[i];
+    const existing = merged.get(r.record.id);
+    if (existing) existing.score += 1 / (k + i + 1);
+    else merged.set(r.record.id, { record: r.record, score: 1 / (k + i + 1) });
+  }
+  return [...merged.values()].sort((a, b) => b.score - a.score);
+}
+async function executeCliBatchOperation(operation, context) {
+  switch (operation.type) {
+    case "search": {
+      if (!context) throw new Error("search operation requires knowledge base context");
+      const query = typeof operation.args.query === "string" ? operation.args.query.trim() : "";
+      if (!query) throw new Error("search operation requires a query");
+      const limit = typeof operation.args.limit === "number" ? operation.args.limit : 5;
+      const searchMode = operation.args.search_mode === "semantic" || operation.args.search_mode === "keyword" ? operation.args.search_mode : "hybrid";
+      const contentType = typeof operation.args.content_type === "string" ? operation.args.content_type : void 0;
+      const minScore = typeof operation.args.min_score === "number" ? operation.args.min_score : 0.25;
+      if (searchMode === "keyword") {
+        return (await context.store.ftsSearch(query, { limit, contentType, minScore })).slice(
+          0,
+          limit
+        );
+      }
+      const queryVector = await context.embedder.embedQuery(query);
+      if (searchMode === "semantic") {
+        return context.store.search(queryVector, { limit, contentType, minScore });
+      }
+      const [vectorResults, ftsResults] = await Promise.all([
+        context.store.search(queryVector, { limit: limit * 2, contentType, minScore }),
+        context.store.ftsSearch(query, { limit: limit * 2, contentType, minScore }).catch(() => [])
+      ]);
+      return rrf(vectorResults, ftsResults).slice(0, limit);
+    }
+    case "find": {
+      if (!context) throw new Error("find operation requires knowledge base context");
+      const query = typeof operation.args.query === "string" ? operation.args.query : void 0;
+      const glob = typeof operation.args.glob === "string" ? operation.args.glob : void 0;
+      const pattern = typeof operation.args.pattern === "string" ? operation.args.pattern : void 0;
+      const limit = typeof operation.args.limit === "number" ? operation.args.limit : 10;
+      const contentType = typeof operation.args.content_type === "string" ? operation.args.content_type : void 0;
+      const cwd = typeof operation.args.cwd === "string" ? operation.args.cwd : void 0;
+      if (!query && !glob && !pattern) {
+        throw new Error("find operation requires query, glob, or pattern");
+      }
+      return find(context.embedder, context.store, {
+        query,
+        glob,
+        pattern,
+        limit,
+        contentType,
+        cwd
+      });
+    }
+    case "check": {
+      const files = Array.isArray(operation.args.files) ? operation.args.files.filter((item) => typeof item === "string") : void 0;
+      const cwd = typeof operation.args.cwd === "string" ? operation.args.cwd : void 0;
+      const skipTypes = operation.args.skip_types === true;
+      const skipLint = operation.args.skip_lint === true;
+      return check({
+        files,
+        cwd,
+        skipTypes,
+        skipLint
+      });
+    }
+    default:
+      throw new Error(`Unsupported batch operation type: ${operation.type}`);
+  }
+}
+export {
+  executeCliBatchOperation,
+  extractBoolFlag,
+  extractNumFlag,
+  extractStrFlag,
+  formatFocusRanges,
+  parseBatchPayload,
+  parseMaybeJsonString,
+  parseRecordString,
+  printCheckResult,
+  printCheckSection,
+  printCheckpoint,
+  printDeadSymbolsResult,
+  printDiffFiles,
+  printExamplesResult,
+  printFileSummary,
+  printGitContext,
+  printManagedProcess,
+  printParsedOutput,
+  printSection,
+  printSymbolInfo,
+  printTestRunResult,
+  printTraceResult,
+  printWorkset,
+  readInput,
+  readStdin,
+  rrf,
+  splitCsv,
+  validateBatchOperations
+};
+//# sourceMappingURL=helpers.js.map

package/packages/cli/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @anvpx/kb CLI — command-line interface for the knowledge base toolkit.
+ *
+ * Thin adapter: arg parsing + output formatting.
+ * All core logic lives in @kb/core, @kb/store, @kb/embeddings, etc.
+ */
+export declare function run(argv: string[]): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/packages/cli/dist/index.js

@@ -0,0 +1,69 @@
+import { analyzeCommands } from "./commands/analyze.js";
+import { contextCommands } from "./commands/context-cmds.js";
+import { environmentCommands } from "./commands/environment.js";
+import { executionCommands } from "./commands/execution.js";
+import { graphCommands } from "./commands/graph.js";
+import { knowledgeCommands } from "./commands/knowledge.js";
+import { searchCommands } from "./commands/search.js";
+import { systemCommands } from "./commands/system.js";
+import { workspaceCommands } from "./commands/workspace.js";
+import { getCtx } from "./context.js";
+const commands = [
+  ...searchCommands,
+  ...knowledgeCommands,
+  ...analyzeCommands,
+  ...graphCommands,
+  ...systemCommands,
+  ...executionCommands,
+  ...contextCommands,
+  ...workspaceCommands,
+  ...environmentCommands
+];
+commands.push({
+  name: "help",
+  description: "Show available commands",
+  run: async () => {
+    printHelp();
+  }
+});
+async function run(argv) {
+  const args = [...argv];
+  const commandName = args.shift();
+  if (!commandName || commandName === "--help" || commandName === "-h") {
+    printHelp();
+    return;
+  }
+  if (commandName === "--version" || commandName === "-v") {
+    console.log("0.1.0");
+    return;
+  }
+  const command = commands.find((candidate) => candidate.name === commandName);
+  if (!command) {
+    console.error(`Unknown command: ${commandName}`);
+    printHelp();
+    process.exit(1);
+  }
+  try {
+    await command.run(args);
+  } finally {
+    const kbContext = getCtx();
+    if (kbContext) await kbContext.store.close();
+  }
+}
+function printHelp() {
+  console.log("@anvpx/kb \u2014 Local-first AI developer toolkit\n");
+  console.log("Usage: kb <command> [options]\n");
+  console.log("Commands:");
+  const maxLen = Math.max(...commands.map((command) => command.name.length));
+  for (const command of commands) {
+    console.log(`  ${command.name.padEnd(maxLen + 2)}${command.description}`);
+  }
+  console.log("");
+  console.log("Options:");
+  console.log("  --help, -h     Show this help");
+  console.log("  --version, -v  Show version");
+}
+export {
+  run
+};
+//# sourceMappingURL=index.js.map

package/packages/cli/dist/kb-init.d.ts

@@ -0,0 +1,57 @@
+/**
+ * KB initialization for CLI commands.
+ * Mirrors the server's initializeKnowledgeBase but avoids importing @kb/server
+ * (which has MCP SDK deps and auto-runs on import from index.ts).
+ */
+import type { KBConfig } from '@kb/core';
+import { type IEmbedder } from '@kb/embeddings';
+import { IncrementalIndexer } from '@kb/indexer';
+import { type IGraphStore, type IKnowledgeStore } from '@kb/store';
+interface ICuratedManager {
+    reindexAll(): Promise<{
+        indexed: number;
+    }>;
+    remember(title: string, content: string, category: string, tags?: string[]): Promise<{
+        path: string;
+    }>;
+    update(relativePath: string, newContent: string, reason: string): Promise<{
+        path: string;
+        version: number;
+    }>;
+    forget(relativePath: string, reason: string): Promise<{
+        path: string;
+    }>;
+    read(relativePath: string): Promise<{
+        path: string;
+        title: string;
+        category: string;
+        tags: string[];
+        version: number;
+        content: string;
+    }>;
+    list(filters?: {
+        category?: string;
+        tag?: string;
+    }): Promise<Array<{
+        path: string;
+        title: string;
+        category: string;
+        tags: string[];
+        version: number;
+        contentPreview: string;
+    }>>;
+}
+export interface KBContext {
+    config: KBConfig;
+    embedder: IEmbedder;
+    store: IKnowledgeStore;
+    graphStore: IGraphStore;
+    indexer: IncrementalIndexer;
+    curated: ICuratedManager;
+}
+/**
+ * Initialize all KB components for CLI use.
+ */
+export declare function initKB(): Promise<KBContext>;
+export {};
+//# sourceMappingURL=kb-init.d.ts.map

package/packages/cli/dist/kb-init.js

@@ -0,0 +1,82 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { initializeTreeSitter } from "@kb/chunker";
+import { OnnxEmbedder } from "@kb/embeddings";
+import { IncrementalIndexer } from "@kb/indexer";
+import { createStore, SqliteGraphStore } from "@kb/store";
+function loadConfig() {
+  const configPath = process.env.KB_CONFIG_PATH ?? (existsSync(resolve(process.cwd(), "kb.config.json")) ? resolve(process.cwd(), "kb.config.json") : null);
+  if (!configPath) {
+    console.error("No kb.config.json found in current directory.");
+    console.error("Run `kb init` to create one, or set KB_CONFIG_PATH.");
+    process.exit(1);
+  }
+  const raw = readFileSync(configPath, "utf-8");
+  const config = JSON.parse(raw);
+  const root = dirname(configPath);
+  config.sources = config.sources.map((s) => ({
+    ...s,
+    path: resolve(root, s.path)
+  }));
+  config.store.path = resolve(root, config.store.path);
+  config.curated = config.curated ?? { path: "curated" };
+  config.curated.path = resolve(root, config.curated.path);
+  return config;
+}
+async function initKB() {
+  const config = loadConfig();
+  const embedder = new OnnxEmbedder({
+    model: config.embedding.model,
+    dimensions: config.embedding.dimensions
+  });
+  await embedder.initialize();
+  const store = await createStore({
+    backend: config.store.backend,
+    path: config.store.path
+  });
+  await store.initialize();
+  const indexer = new IncrementalIndexer(embedder, store);
+  const { CuratedKnowledgeManager } = await import("@kb/server/curated-manager");
+  const curated = new CuratedKnowledgeManager(config.curated.path, store, embedder);
+  let graphStore;
+  try {
+    const gs = new SqliteGraphStore({ path: config.store.path });
+    await gs.initialize();
+    graphStore = gs;
+    indexer.setGraphStore(graphStore);
+  } catch (err) {
+    console.error(`[kb] Graph store init failed (non-fatal): ${err.message}`);
+    graphStore = {
+      initialize: async () => {
+      },
+      upsertNode: async () => {
+      },
+      upsertEdge: async () => {
+      },
+      upsertNodes: async () => {
+      },
+      upsertEdges: async () => {
+      },
+      getNode: async () => null,
+      getNeighbors: async () => ({ nodes: [], edges: [] }),
+      traverse: async () => ({ nodes: [], edges: [] }),
+      findNodes: async () => [],
+      findEdges: async () => [],
+      deleteNode: async () => {
+      },
+      deleteBySourcePath: async () => 0,
+      clear: async () => {
+      },
+      getStats: async () => ({ nodeCount: 0, edgeCount: 0, nodeTypes: {}, edgeTypes: {} }),
+      close: async () => {
+      }
+    };
+  }
+  await initializeTreeSitter().catch(() => {
+  });
+  return { config, embedder, store, graphStore, indexer, curated };
+}
+export {
+  initKB
+};
+//# sourceMappingURL=kb-init.js.map

package/packages/cli/dist/types.d.ts

@@ -0,0 +1,7 @@
+export interface Command {
+    name: string;
+    description: string;
+    usage?: string;
+    run: (args: string[]) => Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/cli/dist/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map