@vpxa/kb 0.1.1

package/packages/cli/dist/commands/environment.js

@@ -0,0 +1,204 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import {
+  delegate,
+  delegateListModels,
+  processList,
+  processLogs,
+  processStart,
+  processStatus,
+  processStop,
+  watchList,
+  watchStart,
+  watchStop
+} from "@kb/tools";
+import { extractNumFlag, extractStrFlag, printManagedProcess, readStdin } from "../helpers.js";
+const environmentCommands = [
+  {
+    name: "proc",
+    description: "Manage in-memory child processes",
+    usage: "kb proc <start|stop|status|list|logs> ...",
+    run: async (args) => {
+      const action = args.shift()?.trim() ?? "";
+      switch (action) {
+        case "start": {
+          const id = args.shift()?.trim();
+          const command = args.shift()?.trim();
+          if (!id || !command) {
+            console.error("Usage: kb proc start <id> <command> [args...]");
+            process.exit(1);
+          }
+          printManagedProcess(processStart(id, command, args));
+          return;
+        }
+        case "stop": {
+          const id = args.shift()?.trim();
+          if (!id) {
+            console.error("Usage: kb proc stop <id>");
+            process.exit(1);
+          }
+          const result = processStop(id);
+          if (!result) {
+            console.log(`No managed process found: ${id}`);
+            return;
+          }
+          printManagedProcess(result);
+          return;
+        }
+        case "status": {
+          const id = args.shift()?.trim();
+          if (!id) {
+            console.error("Usage: kb proc status <id>");
+            process.exit(1);
+          }
+          const result = processStatus(id);
+          if (!result) {
+            console.log(`No managed process found: ${id}`);
+            return;
+          }
+          printManagedProcess(result);
+          return;
+        }
+        case "list": {
+          const processes = processList();
+          if (processes.length === 0) {
+            console.log("No managed processes.");
+            return;
+          }
+          for (const info of processes) {
+            printManagedProcess(info);
+            console.log("");
+          }
+          return;
+        }
+        case "logs": {
+          const tail = extractNumFlag(args, "--tail", 50);
+          const id = args.shift()?.trim();
+          if (!id) {
+            console.error("Usage: kb proc logs <id> [--tail N]");
+            process.exit(1);
+          }
+          const logs = processLogs(id, tail);
+          if (logs.length === 0) {
+            console.log(`No logs found for process: ${id}`);
+            return;
+          }
+          for (const line of logs) console.log(line);
+          return;
+        }
+        default:
+          console.error(`Unknown proc action: ${action}`);
+          console.error("Actions: start, stop, status, list, logs");
+          process.exit(1);
+      }
+    }
+  },
+  {
+    name: "watch",
+    description: "Manage in-memory filesystem watchers",
+    usage: "kb watch <start|stop|list> ...",
+    run: async (args) => {
+      const action = args.shift()?.trim() ?? "";
+      switch (action) {
+        case "start": {
+          const targetPath = args.shift()?.trim();
+          if (!targetPath) {
+            console.error("Usage: kb watch start <path>");
+            process.exit(1);
+          }
+          const handle = watchStart({ path: resolve(targetPath) });
+          console.log(`Started watcher: ${handle.id}`);
+          console.log(`  Path: ${handle.path}`);
+          console.log(`  Status: ${handle.status}`);
+          return;
+        }
+        case "stop": {
+          const id = args.shift()?.trim();
+          if (!id) {
+            console.error("Usage: kb watch stop <id>");
+            process.exit(1);
+          }
+          const stopped = watchStop(id);
+          console.log(stopped ? `Stopped watcher: ${id}` : `Watcher not found: ${id}`);
+          return;
+        }
+        case "list": {
+          const watches = watchList();
+          if (watches.length === 0) {
+            console.log("No active watchers.");
+            return;
+          }
+          for (const watcher of watches) {
+            console.log(`${watcher.id}`);
+            console.log(`  Path: ${watcher.path}`);
+            console.log(`  Status: ${watcher.status}`);
+            console.log(`  Events: ${watcher.eventCount}`);
+          }
+          return;
+        }
+        default:
+          console.error(`Unknown watch action: ${action}`);
+          console.error("Actions: start, stop, list");
+          process.exit(1);
+      }
+    }
+  },
+  {
+    name: "delegate",
+    description: "Delegate a task to a local Ollama model",
+    usage: "kb delegate [--model name] [--system prompt] [--temp 0.3] <prompt | --stdin>",
+    run: async (args) => {
+      const action = args[0] === "models" ? args.shift() : void 0;
+      if (action === "models") {
+        try {
+          const models = await delegateListModels();
+          if (models.length === 0) {
+            console.log("No Ollama models available. Pull one with: ollama pull qwen2.5-coder:7b");
+            return;
+          }
+          for (const m of models) console.log(m);
+        } catch {
+          console.error("Ollama is not running. Start it with: ollama serve");
+          process.exit(1);
+        }
+        return;
+      }
+      const model = extractStrFlag(args, "--model", "");
+      const system = extractStrFlag(args, "--system", "");
+      const temp = extractNumFlag(args, "--temp", 0.3);
+      const contextFile = extractStrFlag(args, "--context", "");
+      let prompt = args.join(" ");
+      if (!prompt) {
+        prompt = await readStdin();
+      }
+      if (!prompt) {
+        console.error("Usage: kb delegate [--model name] <prompt>");
+        process.exit(1);
+      }
+      let context;
+      if (contextFile) {
+        context = await readFile(resolve(contextFile), "utf-8");
+      }
+      const result = await delegate({
+        prompt,
+        model: model || void 0,
+        system: system || void 0,
+        context,
+        temperature: temp
+      });
+      if (result.error) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+      console.log(result.response);
+      console.error(
+        `
+(${result.model}, ${result.durationMs}ms, ${result.tokenCount ?? "?"} tokens)`
+      );
+    }
+  }
+];
+export {
+  environmentCommands
+};
+//# sourceMappingURL=environment.js.map

package/packages/cli/dist/commands/execution.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from '../types.js';
+export declare const executionCommands: Command[];
+//# sourceMappingURL=execution.d.ts.map

package/packages/cli/dist/commands/execution.js

@@ -0,0 +1,137 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { codemod, dataTransform, evaluate, rename, testRun } from "@kb/tools";
+import {
+  extractBoolFlag,
+  extractNumFlag,
+  extractStrFlag,
+  printTestRunResult,
+  readStdin,
+  splitCsv
+} from "../helpers.js";
+const executionCommands = [
+  {
+    name: "eval",
+    description: "Evaluate JavaScript or TypeScript in a constrained VM sandbox",
+    usage: "kb eval [code] [--lang js|ts] [--timeout ms]",
+    run: async (args) => {
+      const lang = extractStrFlag(args, "--lang", "js");
+      const timeout = extractNumFlag(args, "--timeout", 5e3);
+      const inlineCode = args.join(" ");
+      const stdinCode = inlineCode.trim() ? "" : await readStdin();
+      const code = inlineCode || stdinCode;
+      if (!code.trim()) {
+        console.error("Usage: kb eval [code] [--lang js|ts] [--timeout ms]");
+        process.exit(1);
+      }
+      const result = evaluate({
+        code,
+        lang: lang === "ts" ? "ts" : "js",
+        timeout
+      });
+      if (!result.success) {
+        console.error(`Eval failed in ${result.durationMs}ms: ${result.error}`);
+        process.exitCode = 1;
+        return;
+      }
+      console.log(`Eval succeeded in ${result.durationMs}ms`);
+      console.log("\u2500".repeat(60));
+      console.log(result.output);
+    }
+  },
+  {
+    name: "test",
+    description: "Run Vitest for all tests or a specific subset",
+    usage: "kb test [files...] [--grep pattern] [--cwd path] [--timeout ms]",
+    run: async (args) => {
+      const grep = extractStrFlag(args, "--grep", "").trim() || void 0;
+      const cwd = extractStrFlag(args, "--cwd", "").trim() || void 0;
+      const timeout = extractNumFlag(args, "--timeout", 6e4);
+      const files = args.filter(Boolean);
+      const result = await testRun({
+        files: files.length > 0 ? files : void 0,
+        grep,
+        cwd,
+        timeout
+      });
+      printTestRunResult(result);
+      if (!result.passed) process.exitCode = 1;
+    }
+  },
+  {
+    name: "rename",
+    description: "Rename a symbol across files using whole-word regex matching",
+    usage: "kb rename <old> <new> <path> [--dry-run] [--extensions .ts,.tsx] [--exclude dist/**]",
+    run: async (args) => {
+      const oldName = args.shift()?.trim() ?? "";
+      const newName = args.shift()?.trim() ?? "";
+      const targetPath = args.shift()?.trim() ?? "";
+      if (!oldName || !newName || !targetPath) {
+        console.error(
+          "Usage: kb rename <old> <new> <path> [--dry-run] [--extensions .ts,.tsx] [--exclude dist/**]"
+        );
+        process.exit(1);
+      }
+      const extensions = splitCsv(extractStrFlag(args, "--extensions", ""));
+      const exclude = splitCsv(extractStrFlag(args, "--exclude", ""));
+      const result = await rename({
+        oldName,
+        newName,
+        rootPath: resolve(targetPath),
+        extensions: extensions.length > 0 ? extensions : void 0,
+        exclude: exclude.length > 0 ? exclude : void 0,
+        dryRun: extractBoolFlag(args, "--dry-run")
+      });
+      console.log(JSON.stringify(result, null, 2));
+    }
+  },
+  {
+    name: "codemod",
+    description: "Apply regex-based codemod rules from a JSON file across a path",
+    usage: "kb codemod <path> --rules <file.json> [--dry-run] [--extensions .ts,.tsx] [--exclude dist/**]",
+    run: async (args) => {
+      const targetPath = args.shift()?.trim() ?? "";
+      const rulesPath = extractStrFlag(args, "--rules", "").trim();
+      if (!targetPath || !rulesPath) {
+        console.error(
+          "Usage: kb codemod <path> --rules <file.json> [--dry-run] [--extensions .ts,.tsx] [--exclude dist/**]"
+        );
+        process.exit(1);
+      }
+      const rulesInput = await readFile(resolve(rulesPath), "utf-8");
+      const parsedRules = JSON.parse(rulesInput);
+      if (!Array.isArray(parsedRules)) {
+        throw new Error("Codemod rules file must contain a JSON array.");
+      }
+      const extensions = splitCsv(extractStrFlag(args, "--extensions", ""));
+      const exclude = splitCsv(extractStrFlag(args, "--exclude", ""));
+      const result = await codemod({
+        rootPath: resolve(targetPath),
+        rules: parsedRules,
+        extensions: extensions.length > 0 ? extensions : void 0,
+        exclude: exclude.length > 0 ? exclude : void 0,
+        dryRun: extractBoolFlag(args, "--dry-run")
+      });
+      console.log(JSON.stringify(result, null, 2));
+    }
+  },
+  {
+    name: "transform",
+    description: "Apply jq-like transforms to JSON from stdin",
+    usage: "cat data.json | kb transform <expression>",
+    run: async (args) => {
+      const expression = args.join(" ").trim();
+      const input = await readStdin();
+      if (!expression || !input.trim()) {
+        console.error("Usage: cat data.json | kb transform <expression>");
+        process.exit(1);
+      }
+      const result = dataTransform({ input, expression });
+      console.log(result.outputString);
+    }
+  }
+];
+export {
+  executionCommands
+};
+//# sourceMappingURL=execution.js.map

package/packages/cli/dist/commands/graph.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from '../types.js';
+export declare const graphCommands: Command[];
+//# sourceMappingURL=graph.d.ts.map

package/packages/cli/dist/commands/graph.js

@@ -0,0 +1,81 @@
+import { graphQuery } from "@kb/tools";
+import { ctx } from "../context.js";
+import { extractNumFlag, extractStrFlag } from "../helpers.js";
+const graphCommands = [
+  {
+    name: "graph",
+    description: "Query the knowledge graph",
+    usage: "kb graph <action> [options]\n  Actions: stats, find-nodes, find-edges, neighbors, traverse, delete, clear\n  Options: --type, --name, --node-id, --edge-type, --direction, --depth, --limit, --source-path",
+    run: async (args) => {
+      const action = args.shift()?.trim() ?? "";
+      if (!action) {
+        console.error(
+          "Usage: kb graph <action>\nActions: stats, find-nodes, find-edges, neighbors, traverse, delete, clear"
+        );
+        process.exit(1);
+      }
+      const { graphStore } = await ctx();
+      const nodeType = extractStrFlag(args, "--type", "");
+      const namePattern = extractStrFlag(args, "--name", "");
+      const nodeId = extractStrFlag(args, "--node-id", "");
+      const edgeType = extractStrFlag(args, "--edge-type", "");
+      const direction = extractStrFlag(args, "--direction", "both");
+      const maxDepth = extractNumFlag(args, "--depth", 2);
+      const limit = extractNumFlag(args, "--limit", 50);
+      const sourcePath = extractStrFlag(args, "--source-path", "");
+      const actionMap = {
+        stats: "stats",
+        "find-nodes": "find_nodes",
+        "find-edges": "find_edges",
+        neighbors: "neighbors",
+        traverse: "traverse",
+        delete: "delete",
+        clear: "clear"
+      };
+      const mapped = actionMap[action];
+      if (!mapped) {
+        console.error(`Unknown graph action: ${action}`);
+        console.error("Actions: stats, find-nodes, find-edges, neighbors, traverse, delete, clear");
+        process.exit(1);
+      }
+      const result = await graphQuery(graphStore, {
+        action: mapped,
+        nodeType: nodeType || void 0,
+        namePattern: namePattern || void 0,
+        sourcePath: sourcePath || void 0,
+        nodeId: nodeId || void 0,
+        edgeType: edgeType || void 0,
+        direction,
+        maxDepth,
+        limit
+      });
+      console.log(result.summary);
+      if (result.nodes && result.nodes.length > 0) {
+        console.log("\nNodes:");
+        for (const n of result.nodes) {
+          const props = Object.keys(n.properties).length > 0 ? ` ${JSON.stringify(n.properties)}` : "";
+          console.log(`  ${n.name} (${n.type}, id: ${n.id})${props}`);
+        }
+      }
+      if (result.edges && result.edges.length > 0) {
+        console.log("\nEdges:");
+        for (const e of result.edges) {
+          const w = e.weight !== 1 ? ` (weight: ${e.weight})` : "";
+          console.log(`  ${e.fromId} --[${e.type}]--> ${e.toId}${w}`);
+        }
+      }
+      if (result.stats) {
+        console.log(`
+Node types: ${JSON.stringify(result.stats.nodeTypes)}`);
+        console.log(`Edge types: ${JSON.stringify(result.stats.edgeTypes)}`);
+      }
+      if (result.deleted !== void 0) {
+        console.log(`Deleted: ${result.deleted}`);
+      }
+    }
+  }
+];
+export {
+  graphCommands
+};
+//# sourceMappingURL=graph.js.map

package/packages/cli/dist/commands/init.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `kb init` — scaffold a knowledge base in the current directory.
+ * Creates kb.config.json, .gitignore entry, and optional IDE config.
+ */
+export declare function initProject(options: {
+    force: boolean;
+}): Promise<void>;
+//# sourceMappingURL=init.d.ts.map

package/packages/cli/dist/commands/init.js

@@ -0,0 +1,87 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+const DEFAULT_CONFIG = {
+  sources: [
+    {
+      path: ".",
+      excludePatterns: [
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/build/**",
+        "**/.git/**",
+        "**/.kb-data/**",
+        "**/coverage/**",
+        "**/*.min.js",
+        "**/package-lock.json",
+        "**/pnpm-lock.yaml"
+      ]
+    }
+  ],
+  indexing: {
+    chunkSize: 1500,
+    chunkOverlap: 200,
+    minChunkSize: 100
+  },
+  embedding: {
+    model: "Xenova/mxbai-embed-large-v1",
+    dimensions: 1024
+  },
+  store: {
+    backend: "lancedb",
+    path: ".kb-data/lance"
+  },
+  curated: {
+    path: "curated"
+  }
+};
+const VSCODE_MCP_CONFIG = {
+  servers: {
+    "knowledge-base": {
+      type: "stdio",
+      command: "npx",
+      args: ["kb", "serve"]
+    }
+  }
+};
+async function initProject(options) {
+  const cwd = process.cwd();
+  const configPath = resolve(cwd, "kb.config.json");
+  if (existsSync(configPath) && !options.force) {
+    console.log("kb.config.json already exists. Use --force to overwrite.");
+    return;
+  }
+  writeFileSync(configPath, `${JSON.stringify(DEFAULT_CONFIG, null, 2)}
+`, "utf-8");
+  console.log("  Created kb.config.json");
+  const curatedDir = resolve(cwd, "curated");
+  if (!existsSync(curatedDir)) {
+    mkdirSync(curatedDir, { recursive: true });
+    console.log("  Created curated/");
+  }
+  const gitignorePath = resolve(cwd, ".gitignore");
+  if (existsSync(gitignorePath)) {
+    const content = readFileSync(gitignorePath, "utf-8");
+    if (!content.includes(".kb-data")) {
+      appendFileSync(gitignorePath, "\n# Knowledge base vector store\n.kb-data/\n", "utf-8");
+      console.log("  Added .kb-data/ to .gitignore");
+    }
+  } else {
+    writeFileSync(gitignorePath, "# Knowledge base vector store\n.kb-data/\n", "utf-8");
+    console.log("  Created .gitignore with .kb-data/");
+  }
+  const vscodePath = resolve(cwd, ".vscode");
+  const mcpJsonPath = resolve(vscodePath, "mcp.json");
+  if (existsSync(vscodePath) && !existsSync(mcpJsonPath)) {
+    writeFileSync(mcpJsonPath, `${JSON.stringify(VSCODE_MCP_CONFIG, null, 2)}
+`, "utf-8");
+    console.log("  Created .vscode/mcp.json");
+  }
+  console.log("\nKnowledge base initialized! Next steps:");
+  console.log("  kb reindex     Index your codebase");
+  console.log("  kb search      Search indexed content");
+  console.log("  kb serve       Start MCP server for IDE integration");
+}
+export {
+  initProject
+};
+//# sourceMappingURL=init.js.map

package/packages/cli/dist/commands/knowledge.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from '../types.js';
+export declare const knowledgeCommands: Command[];
+//# sourceMappingURL=knowledge.d.ts.map

package/packages/cli/dist/commands/knowledge.js

@@ -0,0 +1,139 @@
+import { compact } from "@kb/tools";
+import { ctx } from "../context.js";
+import { extractNumFlag, extractStrFlag, readStdin, splitCsv } from "../helpers.js";
+const knowledgeCommands = [
+  {
+    name: "remember",
+    description: "Store curated knowledge",
+    usage: "kb remember <title> --category <cat> [--tags tag1,tag2]",
+    run: async (args) => {
+      const category = extractStrFlag(args, "--category", "").trim();
+      const tags = splitCsv(extractStrFlag(args, "--tags", ""));
+      const title = args.shift()?.trim() ?? "";
+      const stdinContent = await readStdin();
+      const content = stdinContent.trim().length > 0 ? stdinContent : args.join(" ").trim();
+      if (!title || !category || !content.trim()) {
+        console.error("Usage: kb remember <title> --category <cat> [--tags tag1,tag2]");
+        process.exit(1);
+      }
+      const { curated } = await ctx();
+      const result = await curated.remember(title, content, category, tags);
+      console.log("Stored curated entry");
+      console.log(`  Path: ${result.path}`);
+      console.log(`  Category: ${category}`);
+      if (tags.length > 0) console.log(`  Tags: ${tags.join(", ")}`);
+    }
+  },
+  {
+    name: "forget",
+    description: "Remove a curated entry",
+    usage: "kb forget <path> --reason <reason>",
+    run: async (args) => {
+      const reason = extractStrFlag(args, "--reason", "").trim();
+      const relativePath = args.shift()?.trim() ?? "";
+      if (!relativePath || !reason) {
+        console.error("Usage: kb forget <path> --reason <reason>");
+        process.exit(1);
+      }
+      const { curated } = await ctx();
+      const result = await curated.forget(relativePath, reason);
+      console.log(`Removed curated entry: ${result.path}`);
+    }
+  },
+  {
+    name: "read",
+    description: "Read a curated entry",
+    usage: "kb read <path>",
+    run: async (args) => {
+      const relativePath = args.shift()?.trim() ?? "";
+      if (!relativePath) {
+        console.error("Usage: kb read <path>");
+        process.exit(1);
+      }
+      const { curated } = await ctx();
+      const entry = await curated.read(relativePath);
+      console.log(entry.title);
+      console.log("\u2500".repeat(60));
+      console.log(`Path: ${entry.path}`);
+      console.log(`Category: ${entry.category}`);
+      console.log(`Version: ${entry.version}`);
+      console.log(`Tags: ${entry.tags.length > 0 ? entry.tags.join(", ") : "None"}`);
+      console.log("");
+      console.log(entry.content);
+    }
+  },
+  {
+    name: "list",
+    description: "List curated entries",
+    usage: "kb list [--category <cat>] [--tag <tag>]",
+    run: async (args) => {
+      const category = extractStrFlag(args, "--category", "").trim() || void 0;
+      const tag = extractStrFlag(args, "--tag", "").trim() || void 0;
+      const { curated } = await ctx();
+      const entries = await curated.list({ category, tag });
+      if (entries.length === 0) {
+        console.log("No curated entries found.");
+        return;
+      }
+      console.log(`Curated entries (${entries.length})`);
+      console.log("\u2500".repeat(60));
+      for (const entry of entries) {
+        console.log(entry.path);
+        console.log(`  ${entry.title}`);
+        console.log(`  Category: ${entry.category} | Version: ${entry.version}`);
+        console.log(`  Tags: ${entry.tags.length > 0 ? entry.tags.join(", ") : "None"}`);
+        const preview = entry.contentPreview.replace(/\s+/g, " ").trim();
+        if (preview) console.log(`  Preview: ${preview}`);
+        console.log("");
+      }
+    }
+  },
+  {
+    name: "update",
+    description: "Update a curated entry",
+    usage: "kb update <path> --reason <reason>",
+    run: async (args) => {
+      const reason = extractStrFlag(args, "--reason", "").trim();
+      const relativePath = args.shift()?.trim() ?? "";
+      const content = await readStdin();
+      if (!relativePath || !reason || !content.trim()) {
+        console.error("Usage: kb update <path> --reason <reason>");
+        process.exit(1);
+      }
+      const { curated } = await ctx();
+      const result = await curated.update(relativePath, content, reason);
+      console.log("Updated curated entry");
+      console.log(`  Path: ${result.path}`);
+      console.log(`  Version: ${result.version}`);
+    }
+  },
+  {
+    name: "compact",
+    description: "Compress text for context",
+    usage: "kb compact <query> [--max-chars N] [--segmentation paragraph|sentence|line]",
+    run: async (args) => {
+      const maxChars = extractNumFlag(args, "--max-chars", 3e3);
+      const segmentation = extractStrFlag(args, "--segmentation", "paragraph");
+      const query = args.join(" ").trim();
+      const text = await readStdin();
+      if (!query || !text.trim()) {
+        console.error(
+          "Usage: kb compact <query> [--max-chars N] [--segmentation paragraph|sentence|line]"
+        );
+        process.exit(1);
+      }
+      const { embedder } = await ctx();
+      const result = await compact(embedder, { text, query, maxChars, segmentation });
+      console.log(`Compressed ${result.originalChars} chars to ${result.compressedChars} chars`);
+      console.log(
+        `Ratio: ${(result.ratio * 100).toFixed(1)}% | Segments: ${result.segmentsKept}/${result.segmentsTotal}`
+      );
+      console.log("");
+      console.log(result.text);
+    }
+  }
+];
+export {
+  knowledgeCommands
+};
+//# sourceMappingURL=knowledge.js.map

package/packages/cli/dist/commands/search.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from '../types.js';
+export declare const searchCommands: Command[];
+//# sourceMappingURL=search.d.ts.map