@vpxa/kb 0.1.1

package/packages/tools/dist/index.js

@@ -0,0 +1,273 @@
+import {
+  batch
+} from "./batch.js";
+import {
+  changelog,
+  formatChangelog
+} from "./changelog.js";
+import { check } from "./check.js";
+import {
+  checkpointLatest,
+  checkpointList,
+  checkpointLoad,
+  checkpointSave
+} from "./checkpoint.js";
+import {
+  codemod
+} from "./codemod.js";
+import { compact } from "./compact.js";
+import {
+  dataTransform
+} from "./data-transform.js";
+import {
+  findDeadSymbols
+} from "./dead-symbols.js";
+import {
+  delegate,
+  delegateListModels
+} from "./delegate.js";
+import {
+  diffParse
+} from "./diff-parse.js";
+import {
+  digest
+} from "./digest.js";
+import {
+  encode
+} from "./encode.js";
+import {
+  envInfo
+} from "./env-info.js";
+import { evaluate } from "./eval.js";
+import {
+  evidenceMap
+} from "./evidence-map.js";
+import {
+  fileSummary
+} from "./file-summary.js";
+import { find } from "./find.js";
+import {
+  findExamples
+} from "./find-examples.js";
+import {
+  forgeClassify
+} from "./forge-classify.js";
+import {
+  forgeGround
+} from "./forge-ground.js";
+import {
+  gitContext
+} from "./git-context.js";
+import {
+  graphAugmentSearch,
+  graphQuery
+} from "./graph-query.js";
+import {
+  health
+} from "./health.js";
+import {
+  httpRequest
+} from "./http-request.js";
+import {
+  laneCreate,
+  laneDiff,
+  laneDiscard,
+  laneList,
+  laneMerge,
+  laneStatus
+} from "./lane.js";
+import {
+  analyzeFile,
+  measure
+} from "./measure.js";
+import {
+  onboard
+} from "./onboard.js";
+import {
+  parseBiome,
+  parseGitStatus,
+  parseOutput,
+  parseTsc,
+  parseVitest
+} from "./parse-output.js";
+import {
+  processList,
+  processLogs,
+  processStart,
+  processStatus,
+  processStop
+} from "./process-manager.js";
+import {
+  queueClear,
+  queueCreate,
+  queueDelete,
+  queueDone,
+  queueFail,
+  queueGet,
+  queueList,
+  queueNext,
+  queuePush
+} from "./queue.js";
+import {
+  regexTest
+} from "./regex-test.js";
+import {
+  rename
+} from "./rename.js";
+import {
+  replayAppend,
+  replayCapture,
+  replayClear,
+  replayList,
+  replayTrim
+} from "./replay.js";
+import {
+  schemaValidate
+} from "./schema-validate.js";
+import {
+  scopeMap
+} from "./scope-map.js";
+import {
+  snippet
+} from "./snippet.js";
+import {
+  stashClear,
+  stashDelete,
+  stashGet,
+  stashList,
+  stashSet
+} from "./stash.js";
+import {
+  stratumCard
+} from "./stratum-card.js";
+import { symbol } from "./symbol.js";
+import { classifyExitCode, testRun } from "./test-run.js";
+import {
+  cosineSimilarity,
+  estimateTokens,
+  segment
+} from "./text-utils.js";
+import {
+  timeUtils
+} from "./time-utils.js";
+import { trace } from "./trace.js";
+import { headTailTruncate, paragraphTruncate } from "./truncation.js";
+import {
+  watchList,
+  watchStart,
+  watchStop
+} from "./watch.js";
+import {
+  webFetch
+} from "./web-fetch.js";
+import {
+  parseSearchResults,
+  webSearch
+} from "./web-search.js";
+import {
+  addToWorkset,
+  deleteWorkset,
+  getWorkset,
+  listWorksets,
+  removeFromWorkset,
+  saveWorkset
+} from "./workset.js";
+export {
+  addToWorkset,
+  analyzeFile,
+  batch,
+  changelog,
+  check,
+  checkpointLatest,
+  checkpointList,
+  checkpointLoad,
+  checkpointSave,
+  classifyExitCode,
+  codemod,
+  compact,
+  cosineSimilarity,
+  dataTransform,
+  delegate,
+  delegateListModels,
+  deleteWorkset,
+  diffParse,
+  digest,
+  encode,
+  envInfo,
+  estimateTokens,
+  evaluate,
+  evidenceMap,
+  fileSummary,
+  find,
+  findDeadSymbols,
+  findExamples,
+  forgeClassify,
+  forgeGround,
+  formatChangelog,
+  getWorkset,
+  gitContext,
+  graphAugmentSearch,
+  graphQuery,
+  headTailTruncate,
+  health,
+  httpRequest,
+  laneCreate,
+  laneDiff,
+  laneDiscard,
+  laneList,
+  laneMerge,
+  laneStatus,
+  listWorksets,
+  measure,
+  onboard,
+  paragraphTruncate,
+  parseBiome,
+  parseGitStatus,
+  parseOutput,
+  parseSearchResults,
+  parseTsc,
+  parseVitest,
+  processList,
+  processLogs,
+  processStart,
+  processStatus,
+  processStop,
+  queueClear,
+  queueCreate,
+  queueDelete,
+  queueDone,
+  queueFail,
+  queueGet,
+  queueList,
+  queueNext,
+  queuePush,
+  regexTest,
+  removeFromWorkset,
+  rename,
+  replayAppend,
+  replayCapture,
+  replayClear,
+  replayList,
+  replayTrim,
+  saveWorkset,
+  schemaValidate,
+  scopeMap,
+  segment,
+  snippet,
+  stashClear,
+  stashDelete,
+  stashGet,
+  stashList,
+  stashSet,
+  stratumCard,
+  symbol,
+  testRun,
+  timeUtils,
+  trace,
+  watchList,
+  watchStart,
+  watchStop,
+  webFetch,
+  webSearch
+};
+//# sourceMappingURL=index.js.map

package/packages/tools/dist/lane.d.ts

@@ -0,0 +1,39 @@
+export interface LaneMeta {
+    name: string;
+    createdAt: string;
+    sourceFiles: string[];
+    rootPath: string;
+}
+export interface LaneDiffEntry {
+    file: string;
+    status: 'modified' | 'added' | 'deleted' | 'unchanged';
+    diff?: string;
+}
+export interface LaneDiffResult {
+    name: string;
+    entries: LaneDiffEntry[];
+    modified: number;
+    added: number;
+    deleted: number;
+}
+export interface LaneMergeResult {
+    name: string;
+    filesMerged: number;
+    files: string[];
+}
+/**
+ * Create an isolated lane by copying specified files into `.kb-state/lanes/<name>/`.
+ * Files are stored with their relative paths preserved.
+ */
+export declare function laneCreate(name: string, files: string[], cwd?: string): LaneMeta;
+/** List all active lanes. */
+export declare function laneList(cwd?: string): LaneMeta[];
+/** Get the status of a lane — which files are modified, added, deleted. */
+export declare function laneStatus(name: string, cwd?: string): LaneDiffResult;
+/** Generate a unified diff for modified files in a lane. */
+export declare function laneDiff(name: string, cwd?: string): LaneDiffResult;
+/** Merge lane files back to the original locations. */
+export declare function laneMerge(name: string, cwd?: string): LaneMergeResult;
+/** Discard a lane entirely. */
+export declare function laneDiscard(name: string, cwd?: string): boolean;
+//# sourceMappingURL=lane.d.ts.map

package/packages/tools/dist/lane.js

@@ -0,0 +1,227 @@
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { join, relative, resolve } from "node:path";
+const LANES_DIR = ".kb-state/lanes";
+const LANE_META = ".lane-meta.json";
+function lanesRoot(cwd) {
+  return resolve(cwd ?? process.cwd(), LANES_DIR);
+}
+function laneDir(name, cwd) {
+  const root = lanesRoot(cwd);
+  const dir = resolve(root, name);
+  if (!dir.startsWith(resolve(root))) {
+    throw new Error(`Invalid lane name: "${name}"`);
+  }
+  return dir;
+}
+function readMeta(name, cwd) {
+  const metaPath = join(laneDir(name, cwd), LANE_META);
+  if (!existsSync(metaPath)) {
+    throw new Error(`Lane "${name}" does not exist`);
+  }
+  return JSON.parse(readFileSync(metaPath, "utf-8"));
+}
+function laneCreate(name, files, cwd) {
+  const root = cwd ?? process.cwd();
+  const dir = laneDir(name, cwd);
+  if (existsSync(dir)) {
+    throw new Error(`Lane "${name}" already exists`);
+  }
+  mkdirSync(dir, { recursive: true });
+  const resolvedFiles = [];
+  for (const file of files) {
+    const absSource = resolve(root, file);
+    if (!existsSync(absSource)) {
+      throw new Error(`Source file does not exist: ${file}`);
+    }
+    const rel = relative(root, absSource).replace(/\\/g, "/");
+    const dest = join(dir, rel);
+    mkdirSync(join(dest, ".."), { recursive: true });
+    cpSync(absSource, dest);
+    resolvedFiles.push(rel);
+  }
+  const meta = {
+    name,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sourceFiles: resolvedFiles,
+    rootPath: root
+  };
+  writeFileSync(join(dir, LANE_META), `${JSON.stringify(meta, null, 2)}
+`, "utf-8");
+  return meta;
+}
+function laneList(cwd) {
+  const root = lanesRoot(cwd);
+  if (!existsSync(root)) return [];
+  const entries = readdirSync(root);
+  const result = [];
+  for (const entry of entries) {
+    const metaPath = join(root, entry, LANE_META);
+    if (existsSync(metaPath)) {
+      result.push(JSON.parse(readFileSync(metaPath, "utf-8")));
+    }
+  }
+  return result;
+}
+function laneStatus(name, cwd) {
+  const meta = readMeta(name, cwd);
+  const dir = laneDir(name, cwd);
+  const root = meta.rootPath;
+  const entries = [];
+  for (const file of meta.sourceFiles) {
+    const originalPath = resolve(root, file);
+    const lanePath = join(dir, file);
+    if (!existsSync(lanePath)) {
+      entries.push({ file, status: "deleted" });
+      continue;
+    }
+    if (!existsSync(originalPath)) {
+      entries.push({ file, status: "added" });
+      continue;
+    }
+    const original = readFileSync(originalPath, "utf-8");
+    const laneContent = readFileSync(lanePath, "utf-8");
+    if (original === laneContent) {
+      entries.push({ file, status: "unchanged" });
+    } else {
+      entries.push({ file, status: "modified" });
+    }
+  }
+  const laneFiles = collectLaneFiles(dir);
+  for (const laneFile of laneFiles) {
+    if (!meta.sourceFiles.includes(laneFile)) {
+      entries.push({ file: laneFile, status: "added" });
+    }
+  }
+  return {
+    name,
+    entries,
+    modified: entries.filter((e) => e.status === "modified").length,
+    added: entries.filter((e) => e.status === "added").length,
+    deleted: entries.filter((e) => e.status === "deleted").length
+  };
+}
+function laneDiff(name, cwd) {
+  const meta = readMeta(name, cwd);
+  const dir = laneDir(name, cwd);
+  const root = meta.rootPath;
+  const entries = [];
+  const allFiles = new Set(meta.sourceFiles);
+  for (const f of collectLaneFiles(dir)) allFiles.add(f);
+  for (const file of allFiles) {
+    const originalPath = resolve(root, file);
+    const lanePath = join(dir, file);
+    const origExists = existsSync(originalPath);
+    const laneExists = existsSync(lanePath);
+    if (!laneExists && origExists) {
+      entries.push({ file, status: "deleted" });
+      continue;
+    }
+    if (laneExists && !origExists) {
+      const content = readFileSync(lanePath, "utf-8");
+      entries.push({
+        file,
+        status: "added",
+        diff: content.split("\n").map((l) => `+${l}`).join("\n")
+      });
+      continue;
+    }
+    if (!laneExists || !origExists) continue;
+    const original = readFileSync(originalPath, "utf-8");
+    const laneContent = readFileSync(lanePath, "utf-8");
+    if (original === laneContent) {
+      entries.push({ file, status: "unchanged" });
+    } else {
+      entries.push({
+        file,
+        status: "modified",
+        diff: simpleDiff(original, laneContent)
+      });
+    }
+  }
+  return {
+    name,
+    entries,
+    modified: entries.filter((e) => e.status === "modified").length,
+    added: entries.filter((e) => e.status === "added").length,
+    deleted: entries.filter((e) => e.status === "deleted").length
+  };
+}
+function laneMerge(name, cwd) {
+  const meta = readMeta(name, cwd);
+  const dir = laneDir(name, cwd);
+  const root = meta.rootPath;
+  const merged = [];
+  const allFiles = new Set(meta.sourceFiles);
+  for (const f of collectLaneFiles(dir)) allFiles.add(f);
+  for (const file of allFiles) {
+    const lanePath = join(dir, file);
+    if (!existsSync(lanePath)) continue;
+    const destPath = resolve(root, file);
+    mkdirSync(join(destPath, ".."), { recursive: true });
+    cpSync(lanePath, destPath);
+    merged.push(file);
+  }
+  rmSync(dir, { recursive: true, force: true });
+  return {
+    name,
+    filesMerged: merged.length,
+    files: merged
+  };
+}
+function laneDiscard(name, cwd) {
+  const dir = laneDir(name, cwd);
+  if (!existsSync(dir)) return false;
+  rmSync(dir, { recursive: true, force: true });
+  return true;
+}
+function collectLaneFiles(dir) {
+  const files = [];
+  function visit(current) {
+    for (const entry of readdirSync(current)) {
+      if (entry === LANE_META) continue;
+      const full = join(current, entry);
+      if (statSync(full).isDirectory()) {
+        visit(full);
+      } else {
+        files.push(relative(dir, full).replace(/\\/g, "/"));
+      }
+    }
+  }
+  if (existsSync(dir)) visit(dir);
+  return files.sort();
+}
+function simpleDiff(original, modified) {
+  const origLines = original.split("\n");
+  const modLines = modified.split("\n");
+  const result = [];
+  const maxLen = Math.max(origLines.length, modLines.length);
+  for (let i = 0; i < maxLen; i++) {
+    const orig = origLines[i];
+    const mod = modLines[i];
+    if (orig === mod) {
+      result.push(` ${orig ?? ""}`);
+    } else {
+      if (orig !== void 0) result.push(`-${orig}`);
+      if (mod !== void 0) result.push(`+${mod}`);
+    }
+  }
+  return result.join("\n");
+}
+export {
+  laneCreate,
+  laneDiff,
+  laneDiscard,
+  laneList,
+  laneMerge,
+  laneStatus
+};
+//# sourceMappingURL=lane.js.map

package/packages/tools/dist/measure.d.ts

@@ -0,0 +1,38 @@
+/**
+ * kb_measure — Code complexity and size metrics.
+ */
+export interface MeasureOptions {
+    path: string;
+    extensions?: string[];
+}
+export interface FileMetrics {
+    path: string;
+    lines: {
+        total: number;
+        code: number;
+        blank: number;
+        comment: number;
+    };
+    complexity: number;
+    functions: number;
+    imports: number;
+    exports: number;
+}
+export interface MeasureResult {
+    files: FileMetrics[];
+    summary: {
+        totalFiles: number;
+        totalLines: number;
+        totalCodeLines: number;
+        avgComplexity: number;
+        maxComplexity: {
+            file: string;
+            value: number;
+        };
+        totalFunctions: number;
+    };
+}
+export declare function measure(options: MeasureOptions): MeasureResult;
+/** Exported for unit testing */
+export declare function analyzeFile(path: string, content: string): FileMetrics;
+//# sourceMappingURL=measure.d.ts.map

package/packages/tools/dist/measure.js

@@ -0,0 +1,119 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { extname, join, relative } from "node:path";
+const EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  ".turbo",
+  "cdk.out",
+  ".cache"
+]);
+const BRANCH_PATTERNS = [
+  /\bif\s*\(/g,
+  /\belse\s+if\b/g,
+  /\bfor\s*\(/g,
+  /\bwhile\s*\(/g,
+  /\bcase\s+/g,
+  /\bcatch\s*\(/g,
+  /&&/g,
+  /\|\|/g,
+  /\?\?/g
+];
+function measure(options) {
+  const { path: inputPath, extensions = [".ts", ".tsx", ".js", ".jsx"] } = options;
+  const filePaths = collectFiles(inputPath, extensions);
+  const files = filePaths.map((fp) => {
+    const content = readFileSync(fp, "utf8");
+    return analyzeFile(relative(process.cwd(), fp), content);
+  });
+  files.sort((a, b) => b.complexity - a.complexity);
+  const totalLines = files.reduce((s, f) => s + f.lines.total, 0);
+  const totalCode = files.reduce((s, f) => s + f.lines.code, 0);
+  const totalComplexity = files.reduce((s, f) => s + f.complexity, 0);
+  const totalFunctions = files.reduce((s, f) => s + f.functions, 0);
+  const maxFile = files[0] ?? { path: "", complexity: 0 };
+  return {
+    files,
+    summary: {
+      totalFiles: files.length,
+      totalLines,
+      totalCodeLines: totalCode,
+      avgComplexity: files.length > 0 ? Math.round(totalComplexity / files.length * 10) / 10 : 0,
+      maxComplexity: { file: maxFile.path, value: maxFile.complexity },
+      totalFunctions
+    }
+  };
+}
+function analyzeFile(path, content) {
+  const lines = content.split("\n");
+  let blank = 0;
+  let comment = 0;
+  let inBlock = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      blank++;
+      continue;
+    }
+    if (inBlock) {
+      comment++;
+      if (trimmed.includes("*/")) inBlock = false;
+      continue;
+    }
+    if (trimmed.startsWith("//")) {
+      comment++;
+      continue;
+    }
+    if (trimmed.startsWith("/*")) {
+      comment++;
+      inBlock = !trimmed.includes("*/");
+    }
+  }
+  let complexity = 1;
+  for (const pattern of BRANCH_PATTERNS) {
+    const matches = content.match(pattern);
+    if (matches) complexity += matches.length;
+  }
+  const fnKeyword = content.match(/\bfunction\b/g)?.length ?? 0;
+  const arrowFns = content.match(/=>\s*[{(]/g)?.length ?? 0;
+  const functions = fnKeyword + arrowFns;
+  const imports = content.match(/^\s*import\s/gm)?.length ?? 0;
+  const exports = content.match(/^\s*export\s/gm)?.length ?? 0;
+  return {
+    path,
+    lines: { total: lines.length, code: lines.length - blank - comment, blank, comment },
+    complexity,
+    functions,
+    imports,
+    exports
+  };
+}
+function collectFiles(inputPath, extensions) {
+  try {
+    if (statSync(inputPath).isFile()) return [inputPath];
+  } catch {
+    throw new Error(`Path not found: ${inputPath}`);
+  }
+  const files = [];
+  function walk(dir) {
+    for (const entry of readdirSync(dir)) {
+      if (EXCLUDE_DIRS.has(entry)) continue;
+      const full = join(dir, entry);
+      if (statSync(full).isDirectory()) {
+        walk(full);
+      } else if (extensions.includes(extname(entry).toLowerCase())) {
+        files.push(full);
+      }
+    }
+  }
+  walk(inputPath);
+  files.sort();
+  return files;
+}
+export {
+  analyzeFile,
+  measure
+};
+//# sourceMappingURL=measure.js.map