@vpxa/kb 0.1.1

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

@@ -0,0 +1,388 @@
+import {
+  addToWorkset,
+  deleteWorkset,
+  getWorkset,
+  laneCreate,
+  laneDiff,
+  laneDiscard,
+  laneList,
+  laneMerge,
+  laneStatus,
+  listWorksets,
+  queueClear,
+  queueCreate,
+  queueDelete,
+  queueDone,
+  queueFail,
+  queueGet,
+  queueList,
+  queueNext,
+  queuePush,
+  removeFromWorkset,
+  saveWorkset,
+  stashClear,
+  stashDelete,
+  stashGet,
+  stashList,
+  stashSet
+} from "@kb/tools";
+import {
+  extractStrFlag,
+  parseMaybeJsonString,
+  printWorkset,
+  readStdin,
+  splitCsv
+} from "../helpers.js";
+const workspaceCommands = [
+  {
+    name: "workset",
+    description: "Manage saved file sets",
+    usage: "kb workset <action> [name] [--files f1,f2] [--description desc]",
+    run: async (args) => {
+      const action = args.shift()?.trim();
+      const files = splitCsv(extractStrFlag(args, "--files", ""));
+      const description = extractStrFlag(args, "--description", "").trim() || void 0;
+      const name = args.shift()?.trim();
+      if (!action) {
+        console.error("Usage: kb workset <action> [name] [--files f1,f2] [--description desc]");
+        console.error("Actions: save, get, list, delete, add, remove");
+        process.exit(1);
+      }
+      switch (action) {
+        case "save": {
+          if (!name || files.length === 0) {
+            console.error("Usage: kb workset save <name> --files f1,f2 [--description desc]");
+            process.exit(1);
+          }
+          const workset = saveWorkset(name, files, { description });
+          console.log(`Saved workset: ${workset.name}`);
+          printWorkset(workset);
+          return;
+        }
+        case "get": {
+          if (!name) {
+            console.error("Usage: kb workset get <name>");
+            process.exit(1);
+          }
+          const workset = getWorkset(name);
+          if (!workset) {
+            console.log(`No workset found: ${name}`);
+            return;
+          }
+          printWorkset(workset);
+          return;
+        }
+        case "list": {
+          const worksets = listWorksets();
+          if (worksets.length === 0) {
+            console.log("No worksets saved.");
+            return;
+          }
+          console.log(`Worksets (${worksets.length})`);
+          console.log("\u2500".repeat(60));
+          for (const workset of worksets) {
+            printWorkset(workset);
+            console.log("");
+          }
+          return;
+        }
+        case "delete": {
+          if (!name) {
+            console.error("Usage: kb workset delete <name>");
+            process.exit(1);
+          }
+          const deleted = deleteWorkset(name);
+          console.log(deleted ? `Deleted workset: ${name}` : `No workset found: ${name}`);
+          return;
+        }
+        case "add": {
+          if (!name || files.length === 0) {
+            console.error("Usage: kb workset add <name> --files f1,f2");
+            process.exit(1);
+          }
+          const workset = addToWorkset(name, files);
+          console.log(`Updated workset: ${workset.name}`);
+          printWorkset(workset);
+          return;
+        }
+        case "remove": {
+          if (!name || files.length === 0) {
+            console.error("Usage: kb workset remove <name> --files f1,f2");
+            process.exit(1);
+          }
+          const workset = removeFromWorkset(name, files);
+          if (!workset) {
+            console.log(`No workset found: ${name}`);
+            return;
+          }
+          console.log(`Updated workset: ${workset.name}`);
+          printWorkset(workset);
+          return;
+        }
+        default:
+          console.error(`Unknown workset action: ${action}`);
+          console.error("Actions: save, get, list, delete, add, remove");
+          process.exit(1);
+      }
+    }
+  },
+  {
+    name: "stash",
+    description: "Persist and retrieve named intermediate values",
+    usage: "kb stash <set|get|list|delete|clear> [key] [value]",
+    run: async (args) => {
+      const action = args.shift()?.trim();
+      const key = args.shift()?.trim();
+      if (!action) {
+        console.error("Usage: kb stash <set|get|list|delete|clear> [key] [value]");
+        process.exit(1);
+      }
+      switch (action) {
+        case "set": {
+          if (!key) {
+            console.error("Usage: kb stash set <key> <value>");
+            process.exit(1);
+          }
+          const inlineValue = args.join(" ");
+          const stdinValue = inlineValue.trim() ? "" : await readStdin();
+          const rawValue = inlineValue || stdinValue;
+          const entry = stashSet(key, parseMaybeJsonString(rawValue));
+          console.log(`Stored stash entry: ${entry.key}`);
+          console.log(`  Type: ${entry.type}`);
+          console.log(`  Stored: ${entry.storedAt}`);
+          return;
+        }
+        case "get": {
+          if (!key) {
+            console.error("Usage: kb stash get <key>");
+            process.exit(1);
+          }
+          const entry = stashGet(key);
+          if (!entry) {
+            console.log(`No stash entry found: ${key}`);
+            return;
+          }
+          console.log(JSON.stringify(entry, null, 2));
+          return;
+        }
+        case "list": {
+          const entries = stashList();
+          if (entries.length === 0) {
+            console.log("No stash entries saved.");
+            return;
+          }
+          console.log(`Stash entries (${entries.length})`);
+          console.log("\u2500".repeat(60));
+          for (const entry of entries) {
+            console.log(`${entry.key} (${entry.type})`);
+            console.log(`  Stored: ${entry.storedAt}`);
+          }
+          return;
+        }
+        case "delete": {
+          if (!key) {
+            console.error("Usage: kb stash delete <key>");
+            process.exit(1);
+          }
+          const deleted = stashDelete(key);
+          console.log(deleted ? `Deleted stash entry: ${key}` : `No stash entry found: ${key}`);
+          return;
+        }
+        case "clear": {
+          const count = stashClear();
+          console.log(`Cleared ${count} stash entr${count === 1 ? "y" : "ies"}.`);
+          return;
+        }
+        default:
+          console.error(`Unknown stash action: ${action}`);
+          console.error("Actions: set, get, list, delete, clear");
+          process.exit(1);
+      }
+    }
+  },
+  {
+    name: "lane",
+    description: "Manage verified lanes \u2014 isolated file copies for parallel exploration",
+    usage: "kb lane <create|list|status|diff|merge|discard> [name] [--files f1,f2]",
+    run: async (args) => {
+      const action = args.shift();
+      if (!action || !["create", "list", "status", "diff", "merge", "discard"].includes(action)) {
+        console.error(
+          "Usage: kb lane <create|list|status|diff|merge|discard> [name] [--files f1,f2]"
+        );
+        process.exit(1);
+      }
+      if (action === "list") {
+        const lanes = laneList();
+        if (lanes.length === 0) {
+          console.log("No active lanes.");
+          return;
+        }
+        for (const lane of lanes) {
+          console.log(
+            `${lane.name}  (${lane.sourceFiles.length} files, created ${lane.createdAt})`
+          );
+        }
+        return;
+      }
+      const name = args.shift();
+      if (!name) {
+        console.error(`Lane name is required for "${action}".`);
+        process.exit(1);
+      }
+      switch (action) {
+        case "create": {
+          const filesStr = extractStrFlag(args, "--files", "");
+          if (!filesStr) {
+            console.error("Usage: kb lane create <name> --files file1.ts,file2.ts");
+            process.exit(1);
+          }
+          const files = filesStr.split(",").map((f) => f.trim());
+          const meta = laneCreate(name, files);
+          console.log(`Lane "${meta.name}" created with ${meta.sourceFiles.length} files.`);
+          break;
+        }
+        case "status": {
+          const result = laneStatus(name);
+          console.log(`Lane: ${result.name}`);
+          console.log(
+            `Modified: ${result.modified} | Added: ${result.added} | Deleted: ${result.deleted}`
+          );
+          for (const entry of result.entries) {
+            console.log(`  ${entry.status.padEnd(10)} ${entry.file}`);
+          }
+          break;
+        }
+        case "diff": {
+          const result = laneDiff(name);
+          console.log(
+            `Lane: ${result.name} \u2014 ${result.modified} modified, ${result.added} added, ${result.deleted} deleted`
+          );
+          for (const entry of result.entries) {
+            if (entry.diff) {
+              console.log(`
+--- ${entry.file} (${entry.status})`);
+              console.log(entry.diff);
+            }
+          }
+          break;
+        }
+        case "merge": {
+          const result = laneMerge(name);
+          console.log(`Merged ${result.filesMerged} files from lane "${result.name}".`);
+          for (const f of result.files) console.log(`  ${f}`);
+          break;
+        }
+        case "discard": {
+          const ok = laneDiscard(name);
+          console.log(ok ? `Lane "${name}" discarded.` : `Lane "${name}" not found.`);
+          break;
+        }
+      }
+    }
+  },
+  {
+    name: "queue",
+    description: "Manage task queues for sequential agent operations",
+    usage: "kb queue <create|push|next|done|fail|get|list|clear|delete> [name] [args]",
+    run: async (args) => {
+      const action = args.shift();
+      if (!action || !["create", "push", "next", "done", "fail", "get", "list", "clear", "delete"].includes(
+        action
+      )) {
+        console.error(
+          "Usage: kb queue <create|push|next|done|fail|get|list|clear|delete> [name] [args]"
+        );
+        process.exit(1);
+      }
+      if (action === "list") {
+        const queues = queueList();
+        if (queues.length === 0) {
+          console.log("No queues.");
+          return;
+        }
+        for (const q of queues) {
+          console.log(
+            `${q.name}  pending:${q.pending} done:${q.done} failed:${q.failed} total:${q.total}`
+          );
+        }
+        return;
+      }
+      const name = args.shift();
+      if (!name) {
+        console.error(`Queue name is required for "${action}".`);
+        process.exit(1);
+      }
+      switch (action) {
+        case "create": {
+          const q = queueCreate(name);
+          console.log(`Queue "${q.name}" created.`);
+          break;
+        }
+        case "push": {
+          const title = args.join(" ") || "Untitled task";
+          const item = queuePush(name, title);
+          console.log(`Pushed "${item.title}" (${item.id}) to queue "${name}".`);
+          break;
+        }
+        case "next": {
+          const item = queueNext(name);
+          if (!item) {
+            console.log(`No pending items in queue "${name}".`);
+          } else {
+            console.log(`Next: ${item.title} (${item.id})`);
+          }
+          break;
+        }
+        case "done": {
+          const id = args.shift();
+          if (!id) {
+            console.error("Usage: kb queue done <name> <id>");
+            process.exit(1);
+          }
+          const item = queueDone(name, id);
+          console.log(`Marked "${item.title}" as done.`);
+          break;
+        }
+        case "fail": {
+          const id = args.shift();
+          const error = args.join(" ") || "Unknown error";
+          if (!id) {
+            console.error("Usage: kb queue fail <name> <id> [error message]");
+            process.exit(1);
+          }
+          const item = queueFail(name, id, error);
+          console.log(`Marked "${item.title}" as failed: ${error}`);
+          break;
+        }
+        case "get": {
+          const q = queueGet(name);
+          if (!q) {
+            console.log(`Queue "${name}" not found.`);
+            return;
+          }
+          console.log(`Queue: ${q.name} (${q.items.length} items)`);
+          for (const item of q.items) {
+            const extra = item.error ? ` \u2014 ${item.error}` : "";
+            console.log(`  ${item.status.padEnd(12)} ${item.id}  ${item.title}${extra}`);
+          }
+          break;
+        }
+        case "clear": {
+          const removed = queueClear(name);
+          console.log(`Cleared ${removed} completed/failed items from queue "${name}".`);
+          break;
+        }
+        case "delete": {
+          const ok = queueDelete(name);
+          console.log(ok ? `Queue "${name}" deleted.` : `Queue "${name}" not found.`);
+          break;
+        }
+      }
+    }
+  }
+];
+export {
+  workspaceCommands
+};
+//# sourceMappingURL=workspace.js.map

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

@@ -0,0 +1,5 @@
+import { type KBContext } from './kb-init.js';
+export declare function ctx(): Promise<KBContext>;
+export declare function getCtx(): KBContext | null;
+export type { KBContext } from './kb-init.js';
+//# sourceMappingURL=context.d.ts.map

package/packages/cli/dist/context.js

@@ -0,0 +1,14 @@
+import { initKB } from "./kb-init.js";
+let _ctx = null;
+async function ctx() {
+  if (!_ctx) _ctx = await initKB();
+  return _ctx;
+}
+function getCtx() {
+  return _ctx;
+}
+export {
+  ctx,
+  getCtx
+};
+//# sourceMappingURL=context.js.map

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

@@ -0,0 +1,52 @@
+import type { SearchResult } from '@kb/core';
+import { type BatchOperation, check, type checkpointSave, type diffParse, type fileSummary, type findDeadSymbols, type findExamples, type gitContext, type ManagedProcess, type parseOutput, type symbol, type testRun, type trace } from '@kb/tools';
+import type { KBContext } from './context.js';
+export declare function extractNumFlag(args: string[], flag: string, defaultValue: number): number;
+export declare function extractStrFlag(args: string[], flag: string, defaultValue: string): string;
+export declare function extractBoolFlag(args: string[], flag: string): boolean;
+export declare function readStdin(): Promise<string>;
+export declare function readInput(filePath?: string): Promise<string>;
+export declare function splitCsv(value: string): string[];
+export declare function parseBatchPayload(input: string): {
+    operations: BatchOperation[];
+    concurrency?: number;
+};
+export declare function validateBatchOperations(value: unknown): BatchOperation[];
+export declare function formatFocusRanges(ranges: Array<{
+    start: number;
+    end: number;
+    heading?: string;
+}>): string;
+export declare function printParsedOutput(result: ReturnType<typeof parseOutput>): void;
+export declare function printCheckResult(result: Awaited<ReturnType<typeof check>>): void;
+export declare function printCheckSection(label: string, passed: boolean, errors: Array<{
+    file: string;
+    line?: number;
+    column?: number;
+    severity: 'error' | 'warning' | 'info';
+    code?: string;
+    message: string;
+}>): void;
+export declare function printTestRunResult(result: Awaited<ReturnType<typeof testRun>>): void;
+export declare function printGitContext(result: Awaited<ReturnType<typeof gitContext>>): void;
+export declare function printDiffFiles(files: ReturnType<typeof diffParse>): void;
+export declare function printTraceResult(result: Awaited<ReturnType<typeof trace>>): void;
+export declare function printExamplesResult(result: Awaited<ReturnType<typeof findExamples>>): void;
+export declare function printManagedProcess(info: ManagedProcess): void;
+export declare function printDeadSymbolsResult(result: Awaited<ReturnType<typeof findDeadSymbols>>): void;
+export declare function printFileSummary(summary: Awaited<ReturnType<typeof fileSummary>>): void;
+export declare function printSymbolInfo(result: Awaited<ReturnType<typeof symbol>>): void;
+export declare function printWorkset(workset: {
+    name: string;
+    files: string[];
+    created: string;
+    updated: string;
+    description?: string;
+}): void;
+export declare function printCheckpoint(checkpoint: ReturnType<typeof checkpointSave>): void;
+export declare function printSection(label: string, items: string[]): void;
+export declare function parseMaybeJsonString(value: string): unknown;
+export declare function parseRecordString(value: string): Record<string, unknown>;
+export declare function rrf(vecResults: SearchResult[], ftsResults: SearchResult[], k?: number): SearchResult[];
+export declare function executeCliBatchOperation(operation: BatchOperation, context: KBContext | null): Promise<unknown>;
+//# sourceMappingURL=helpers.d.ts.map