@vpxa/kb 0.1.1

package/packages/tools/dist/data-transform.js

@@ -0,0 +1,124 @@
+function dataTransform(options) {
+  const { input, expression } = options;
+  const data = typeof input === "string" ? JSON.parse(input) : input;
+  let output;
+  if (expression === ".") {
+    output = data;
+  } else if (expression === "keys") {
+    output = Object.keys(asRecord(data));
+  } else if (expression === "values") {
+    output = Object.values(asRecord(data));
+  } else if (expression === "length") {
+    output = Array.isArray(data) ? data.length : Object.keys(asRecord(data)).length;
+  } else if (expression === "flatten") {
+    output = asArray(data).flat();
+  } else if (expression === "unique") {
+    output = [...new Set(asArray(data))];
+  } else if (expression === "sort") {
+    output = [...asArray(data)].sort();
+  } else if (expression === "reverse") {
+    output = [...asArray(data)].reverse();
+  } else if (expression.startsWith(".")) {
+    output = resolvePath(data, expression.slice(1));
+  } else if (expression.startsWith("map(") && expression.endsWith(")")) {
+    const field = expression.slice(4, -1).trim();
+    const path = field.startsWith(".") ? field.slice(1) : field;
+    output = asArray(data).map((item) => resolvePath(item, path));
+  } else if (expression.startsWith("select(") && expression.endsWith(")")) {
+    output = filterByCondition(asArray(data), expression.slice(7, -1).trim());
+  } else if (expression.startsWith("group_by(") && expression.endsWith(")")) {
+    const field = expression.slice(9, -1).trim().replace(/^\./, "");
+    const groups = {};
+    for (const item of asArray(data)) {
+      const key = String(resolvePath(item, field) ?? "null");
+      if (!groups[key]) {
+        groups[key] = [];
+      }
+      groups[key].push(item);
+    }
+    output = groups;
+  } else if (expression.startsWith("pick(") && expression.endsWith(")")) {
+    const fields = expression.slice(5, -1).split(",").map((field) => field.trim().replace(/^\./, "")).filter(Boolean);
+    output = Array.isArray(data) ? asArray(data).map((item) => pickFields(item, fields)) : pickFields(data, fields);
+  } else {
+    throw new Error(
+      `Unsupported expression: ${expression}. Supported: ., .path.to.field, keys, values, length, flatten, unique, sort, reverse, map(.field), select(.field == | != | > | < | >= | <= "value"), group_by(.field), pick(.a, .b)`
+    );
+  }
+  return {
+    output,
+    outputString: typeof output === "string" ? output : JSON.stringify(output, null, 2) ?? "null"
+  };
+}
+function filterByCondition(items, condition) {
+  const match = condition.match(/^\.?([\w.[\]]+)\s*(==|!=|>=|<=|>|<)\s*"?([^"]*)"?$/);
+  if (!match) {
+    throw new Error(`Unsupported select expression: ${condition}`);
+  }
+  const [, field, operator, value] = match;
+  return items.filter((item) => {
+    const resolved = resolvePath(item, field);
+    const resolvedStr = String(resolved);
+    switch (operator) {
+      case "==":
+        return resolvedStr === value;
+      case "!=":
+        return resolvedStr !== value;
+      case ">":
+      case "<":
+      case ">=":
+      case "<=": {
+        const numResolved = Number(resolved);
+        const numValue = Number(value);
+        if (Number.isNaN(numResolved) || Number.isNaN(numValue)) return false;
+        if (operator === ">") return numResolved > numValue;
+        if (operator === "<") return numResolved < numValue;
+        if (operator === ">=") return numResolved >= numValue;
+        return numResolved <= numValue;
+      }
+      default:
+        return false;
+    }
+  });
+}
+function pickFields(input, fields) {
+  const picked = {};
+  for (const field of fields) {
+    picked[field] = resolvePath(input, field);
+  }
+  return picked;
+}
+function resolvePath(input, path) {
+  if (!path) return input;
+  const tokens = [...path.matchAll(/([^.[\]]+)|\[(\d+)\]/g)].map(
+    (match) => match[1] ?? Number.parseInt(match[2], 10)
+  );
+  let current = input;
+  for (const token of tokens) {
+    if (current == null) return void 0;
+    if (typeof token === "number") {
+      if (!Array.isArray(current)) return void 0;
+      current = current[token];
+      continue;
+    }
+    if (typeof current !== "object") return void 0;
+    current = current[token];
+  }
+  return current;
+}
+function asArray(value) {
+  if (!Array.isArray(value)) {
+    throw new Error("Operation requires an array input.");
+  }
+  return value;
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Operation requires an object input.");
+  }
+  return value;
+}
+export {
+  dataTransform
+};
+//# sourceMappingURL=data-transform.js.map

package/packages/tools/dist/dead-symbols.d.ts

@@ -0,0 +1,21 @@
+import type { IEmbedder } from '@kb/embeddings';
+import type { IKnowledgeStore } from '@kb/store';
+export interface DeadSymbolOptions {
+    /** Root path to scope the search */
+    rootPath?: string;
+    /** Max symbols to scan (default: 100) */
+    limit?: number;
+}
+export interface DeadSymbol {
+    name: string;
+    path: string;
+    line: number;
+    kind: string;
+}
+export interface DeadSymbolResult {
+    deadSymbols: DeadSymbol[];
+    totalExports: number;
+    totalDead: number;
+}
+export declare function findDeadSymbols(embedder: IEmbedder, store: IKnowledgeStore, options?: DeadSymbolOptions): Promise<DeadSymbolResult>;
+//# sourceMappingURL=dead-symbols.d.ts.map

package/packages/tools/dist/dead-symbols.js

@@ -0,0 +1,71 @@
+async function findDeadSymbols(embedder, store, options = {}) {
+  const { rootPath, limit = 100 } = options;
+  const exportVector = await embedder.embed("export function class const type interface enum");
+  const exportChunks = await store.search(exportVector, { limit: limit * 3 });
+  const exportPattern = /^export\s+(?:async\s+)?(?:function|class|const|let|interface|type|enum)\s+(\w+)/gm;
+  const exports = [];
+  for (const chunk of exportChunks) {
+    if (!matchesRootPath(chunk.record.sourcePath, rootPath)) continue;
+    const content = chunk.record.content;
+    exportPattern.lastIndex = 0;
+    for (const match of content.matchAll(exportPattern)) {
+      const matchIndex = match.index ?? 0;
+      const linesBefore = content.slice(0, matchIndex).split("\n").length - 1;
+      const kindMatch = content.slice(matchIndex).match(/export\s+(?:async\s+)?(\w+)/);
+      exports.push({
+        name: match[1],
+        path: chunk.record.sourcePath,
+        line: chunk.record.startLine + linesBefore,
+        kind: kindMatch?.[1] ?? "unknown"
+      });
+    }
+  }
+  const uniqueExports = /* @__PURE__ */ new Map();
+  for (const exportedSymbol of exports) {
+    const key = `${exportedSymbol.path}:${exportedSymbol.name}`;
+    if (!uniqueExports.has(key)) uniqueExports.set(key, exportedSymbol);
+  }
+  const deadSymbols = [];
+  for (const exportedSymbol of uniqueExports.values()) {
+    const escapedName = escapeRegExp(exportedSymbol.name);
+    const importPattern = new RegExp(`import\\s+.*\\b${escapedName}\\b.*from`, "m");
+    const reexportPattern = new RegExp(`export\\s+\\{[^}]*\\b${escapedName}\\b`, "m");
+    const importResults = await store.ftsSearch(`import ${exportedSymbol.name}`, { limit: 10 });
+    const isImported = importResults.some(
+      (result) => result.record.sourcePath !== exportedSymbol.path && importPattern.test(result.record.content)
+    );
+    const isReexported = importResults.some(
+      (result) => result.record.sourcePath !== exportedSymbol.path && reexportPattern.test(result.record.content)
+    );
+    if (!isImported && !isReexported) {
+      deadSymbols.push(exportedSymbol);
+    }
+  }
+  deadSymbols.sort(
+    (left, right) => left.path === right.path ? left.line - right.line : left.path.localeCompare(right.path)
+  );
+  return {
+    deadSymbols,
+    totalExports: uniqueExports.size,
+    totalDead: deadSymbols.length
+  };
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function matchesRootPath(sourcePath, rootPath) {
+  if (!rootPath) return true;
+  const normalizedRoot = normalizePath(rootPath).replace(/\/+$/, "");
+  if (/^[A-Za-z]:\//.test(normalizedRoot) || normalizedRoot.startsWith("/")) {
+    return true;
+  }
+  const normalizedSource = normalizePath(sourcePath);
+  return normalizedSource === normalizedRoot || normalizedSource.startsWith(`${normalizedRoot}/`);
+}
+function normalizePath(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+export {
+  findDeadSymbols
+};
+//# sourceMappingURL=dead-symbols.js.map

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

@@ -0,0 +1,34 @@
+export interface DelegateOptions {
+    /** The prompt / task to send to the local model. */
+    prompt: string;
+    /** Model to use (default: the first available model). */
+    model?: string;
+    /** Optional system prompt. */
+    system?: string;
+    /** Optional context to include before the prompt. */
+    context?: string;
+    /** Temperature (0-2, default: 0.3 for deterministic-ish output). */
+    temperature?: number;
+    /** Timeout in milliseconds (default: 120_000). */
+    timeout?: number;
+    /** Ollama base URL (default: http://localhost:11434). */
+    baseUrl?: string;
+}
+export interface DelegateResult {
+    model: string;
+    response: string;
+    durationMs: number;
+    tokenCount?: number;
+    error?: string;
+}
+/**
+ * Check if Ollama is running and return available models.
+ */
+export declare function delegateListModels(baseUrl?: string): Promise<string[]>;
+/**
+ * Delegate a task to a local Ollama model.
+ *
+ * Fails fast if Ollama is not running or no models are available.
+ */
+export declare function delegate(options: DelegateOptions): Promise<DelegateResult>;
+//# sourceMappingURL=delegate.d.ts.map

package/packages/tools/dist/delegate.js

@@ -0,0 +1,130 @@
+import { request } from "node:http";
+const DEFAULT_BASE_URL = "http://localhost:11434";
+const DEFAULT_TIMEOUT = 12e4;
+async function delegateListModels(baseUrl = DEFAULT_BASE_URL) {
+  const body = await ollamaGet(`${baseUrl}/api/tags`);
+  const parsed = JSON.parse(body);
+  return (parsed.models ?? []).map((m) => m.name);
+}
+async function delegate(options) {
+  const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  let models;
+  try {
+    models = await delegateListModels(baseUrl);
+  } catch {
+    return {
+      model: options.model ?? "unknown",
+      response: "",
+      durationMs: 0,
+      error: `Ollama is not running at ${baseUrl}. Start it with: ollama serve`
+    };
+  }
+  if (models.length === 0) {
+    return {
+      model: "none",
+      response: "",
+      durationMs: 0,
+      error: "No Ollama models available. Pull one with: ollama pull qwen2.5-coder:7b"
+    };
+  }
+  const model = options.model ?? models[0];
+  if (!models.includes(model)) {
+    return {
+      model,
+      response: "",
+      durationMs: 0,
+      error: `Model "${model}" not found. Available: ${models.join(", ")}`
+    };
+  }
+  let fullPrompt = "";
+  if (options.context) {
+    fullPrompt += `<context>
+${options.context}
+</context>
+
+`;
+  }
+  fullPrompt += options.prompt;
+  const start = Date.now();
+  const payload = JSON.stringify({
+    model,
+    prompt: fullPrompt,
+    system: options.system,
+    stream: false,
+    options: {
+      temperature: options.temperature ?? 0.3
+    }
+  });
+  try {
+    const body = await ollamaPost(`${baseUrl}/api/generate`, payload, timeout);
+    const parsed = JSON.parse(body);
+    if (parsed.error) {
+      return { model, response: "", durationMs: Date.now() - start, error: parsed.error };
+    }
+    return {
+      model,
+      response: (parsed.response ?? "").trim(),
+      durationMs: Date.now() - start,
+      tokenCount: parsed.eval_count
+    };
+  } catch (err) {
+    return {
+      model,
+      response: "",
+      durationMs: Date.now() - start,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function ollamaGet(url) {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const req = request(
+      { hostname: u.hostname, port: u.port, path: u.pathname, method: "GET", timeout: 5e3 },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Connection timeout"));
+    });
+    req.end();
+  });
+}
+function ollamaPost(url, body, timeout) {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const req = request(
+      {
+        hostname: u.hostname,
+        port: u.port,
+        path: u.pathname,
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
+        timeout
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error(`Ollama request timed out after ${timeout}ms`));
+    });
+    req.write(body);
+    req.end();
+  });
+}
+export {
+  delegate,
+  delegateListModels
+};
+//# sourceMappingURL=delegate.js.map

package/packages/tools/dist/diff-parse.d.ts

@@ -0,0 +1,26 @@
+export interface DiffFile {
+    path: string;
+    oldPath?: string;
+    status: 'added' | 'modified' | 'deleted' | 'renamed';
+    hunks: DiffHunk[];
+    additions: number;
+    deletions: number;
+}
+export interface DiffHunk {
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    header: string;
+    changes: DiffChange[];
+}
+export interface DiffChange {
+    type: 'add' | 'delete' | 'context';
+    line: number;
+    content: string;
+}
+export interface DiffParseOptions {
+    diff: string;
+}
+export declare function diffParse(options: DiffParseOptions): DiffFile[];
+//# sourceMappingURL=diff-parse.d.ts.map

package/packages/tools/dist/diff-parse.js

@@ -0,0 +1,153 @@
+function diffParse(options) {
+  const { diff } = options;
+  const fileBlocks = diff.split(/^diff --git /m).filter(Boolean);
+  if (fileBlocks.length > 0 && /^a\//.test(fileBlocks[0])) {
+    return parseGitDiff(fileBlocks);
+  }
+  return parseUnifiedDiff(diff);
+}
+function parseGitDiff(fileBlocks) {
+  const files = [];
+  for (const block of fileBlocks) {
+    const lines = block.split("\n");
+    const headerMatch = lines[0]?.match(/a\/(.+?)\s+b\/(.+)/);
+    if (!headerMatch) continue;
+    const oldPath = headerMatch[1];
+    const newPath = headerMatch[2];
+    let status = "modified";
+    if (block.includes("new file mode")) status = "added";
+    else if (block.includes("deleted file mode")) status = "deleted";
+    else if (oldPath !== newPath) status = "renamed";
+    const hunks = [];
+    let additions = 0;
+    let deletions = 0;
+    let currentHunk = null;
+    let oldLine = 0;
+    let newLine = 0;
+    for (const line of lines) {
+      const hunkMatch = line.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@(.*)$/);
+      if (hunkMatch) {
+        currentHunk = {
+          oldStart: Number(hunkMatch[1]),
+          oldLines: Number(hunkMatch[2] ?? 1),
+          newStart: Number(hunkMatch[3]),
+          newLines: Number(hunkMatch[4] ?? 1),
+          header: hunkMatch[5]?.trim() ?? "",
+          changes: []
+        };
+        hunks.push(currentHunk);
+        oldLine = currentHunk.oldStart;
+        newLine = currentHunk.newStart;
+        continue;
+      }
+      if (!currentHunk || line.startsWith("\\")) continue;
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        currentHunk.changes.push({ type: "add", line: newLine, content: line.slice(1) });
+        additions += 1;
+        newLine += 1;
+        continue;
+      }
+      if (line.startsWith("-") && !line.startsWith("---")) {
+        currentHunk.changes.push({ type: "delete", line: oldLine, content: line.slice(1) });
+        deletions += 1;
+        oldLine += 1;
+        continue;
+      }
+      if (line.startsWith(" ")) {
+        currentHunk.changes.push({ type: "context", line: newLine, content: line.slice(1) });
+        oldLine += 1;
+        newLine += 1;
+      }
+    }
+    files.push({
+      path: newPath,
+      oldPath: status === "renamed" ? oldPath : void 0,
+      status,
+      hunks,
+      additions,
+      deletions
+    });
+  }
+  return files;
+}
+function parseUnifiedDiff(diff) {
+  const files = [];
+  const lines = diff.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const oldMatch = lines[i]?.match(/^---\s+(?:a\/)?(.+)/);
+    const newMatch = lines[i + 1]?.match(/^\+\+\+\s+(?:b\/)?(.+)/);
+    if (!oldMatch || !newMatch) {
+      i++;
+      continue;
+    }
+    const oldPath = oldMatch[1].trim();
+    const newPath = newMatch[1].trim();
+    let status = "modified";
+    if (oldPath === "/dev/null") status = "added";
+    else if (newPath === "/dev/null") status = "deleted";
+    else if (oldPath !== newPath) status = "renamed";
+    i += 2;
+    const hunks = [];
+    let additions = 0;
+    let deletions = 0;
+    while (i < lines.length && !lines[i]?.startsWith("--- ")) {
+      const hunkMatch = lines[i]?.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@(.*)$/);
+      if (hunkMatch) {
+        const currentHunk = {
+          oldStart: Number(hunkMatch[1]),
+          oldLines: Number(hunkMatch[2] ?? 1),
+          newStart: Number(hunkMatch[3]),
+          newLines: Number(hunkMatch[4] ?? 1),
+          header: hunkMatch[5]?.trim() ?? "",
+          changes: []
+        };
+        hunks.push(currentHunk);
+        let oldLine = currentHunk.oldStart;
+        let newLine = currentHunk.newStart;
+        i++;
+        while (i < lines.length) {
+          const line = lines[i];
+          if (line?.startsWith("@@") || line?.startsWith("--- ") || line?.startsWith("diff "))
+            break;
+          if (line?.startsWith("\\")) {
+            i++;
+            continue;
+          }
+          if (line?.startsWith("+")) {
+            currentHunk.changes.push({ type: "add", line: newLine, content: line.slice(1) });
+            additions++;
+            newLine++;
+          } else if (line?.startsWith("-")) {
+            currentHunk.changes.push({ type: "delete", line: oldLine, content: line.slice(1) });
+            deletions++;
+            oldLine++;
+          } else if (line?.startsWith(" ")) {
+            currentHunk.changes.push({ type: "context", line: newLine, content: line.slice(1) });
+            oldLine++;
+            newLine++;
+          } else {
+            break;
+          }
+          i++;
+        }
+      } else {
+        i++;
+      }
+    }
+    const effectivePath = status === "deleted" ? oldPath : newPath;
+    files.push({
+      path: effectivePath,
+      oldPath: status === "renamed" ? oldPath : void 0,
+      status,
+      hunks,
+      additions,
+      deletions
+    });
+  }
+  return files;
+}
+export {
+  diffParse
+};
+//# sourceMappingURL=diff-parse.js.map

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

@@ -0,0 +1,53 @@
+/**
+ * kb_digest — Multi-source context compressor.
+ *
+ * Compress N text blocks into a token-budgeted digest with source attribution
+ * and pinned structured fields. Uses embedding similarity — no LLM needed.
+ */
+import type { IEmbedder } from '@kb/embeddings';
+export interface DigestSource {
+    /** Unique identifier for this source */
+    id: string;
+    /** The text to compress */
+    text: string;
+    /** Priority weight (default: 1). Higher = more budget share */
+    weight?: number;
+}
+export interface DigestOptions {
+    /** Source texts to compress */
+    sources: DigestSource[];
+    /** Focus query — what matters for the next step? */
+    query: string;
+    /** Target budget in characters (default: 4000) */
+    maxChars?: number;
+    /** Key fields to always extract via keyword matching */
+    pinFields?: string[];
+    /** Segmentation strategy (default: 'paragraph') */
+    segmentation?: 'paragraph' | 'sentence' | 'line';
+}
+export interface DigestFieldEntry {
+    sourceId: string;
+    value: string;
+}
+export interface DigestResult {
+    /** Compressed narrative (all sources merged, reading order maintained) */
+    text: string;
+    /** Extracted structured fields */
+    fields: Record<string, DigestFieldEntry[]>;
+    /** Per-source compression stats */
+    sourceStats: Array<{
+        id: string;
+        originalChars: number;
+        keptChars: number;
+        segmentsKept: number;
+        segmentsTotal: number;
+    }>;
+    totalOriginalChars: number;
+    totalCompressedChars: number;
+    ratio: number;
+}
+/**
+ * Compress multiple text sources into a single digest.
+ */
+export declare function digest(embedder: IEmbedder, options: DigestOptions): Promise<DigestResult>;
+//# sourceMappingURL=digest.d.ts.map