@klhapp/skillmux 1.12.0 → 1.13.0

package/src/context.ts

@@ -1,188 +0,0 @@
-import { existsSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { expandHome } from "./config";
-
-export interface ContextRecord {
-  server: string;
-  token_env?: string;
-}
-
-export interface ContextConfig {
-  default_context: string;
-  contexts: Record<string, ContextRecord>;
-}
-
-/**
- * Context resolution: `local` = this CLI process has the Skillmux runtime (vault,
- * index, audit db, embeddings/reranker clients) loaded in-process; `remote` = this
- * CLI process is a thin network client to a separate process elsewhere that owns that runtime.
- */
-export type ResolvedContext =
-  | { type: "local"; name: "local" }
-  | { type: "remote"; name: string; server: string; token_env?: string };
-
-export const DEFAULT_CONTEXTS_PATH = "~/.config/skillmux/contexts.toml";
-
-export async function loadContextConfig(filePath?: string): Promise<ContextConfig> {
-  const targetPath = expandHome(filePath ?? DEFAULT_CONTEXTS_PATH);
-  const base: ContextConfig = {
-    default_context: "local",
-    contexts: { local: { server: "local" } },
-  };
-
-  if (!existsSync(targetPath)) {
-    return base;
-  }
-
-  try {
-    const text = await Bun.file(targetPath).text();
-    const parsed = Bun.TOML.parse(text) as Partial<ContextConfig>;
-    const default_context = typeof parsed.default_context === "string" ? parsed.default_context : "local";
-    const contexts: Record<string, ContextRecord> = { local: { server: "local" } };
-
-    if (parsed.contexts && typeof parsed.contexts === "object") {
-      for (const [name, rec] of Object.entries(parsed.contexts)) {
-        if (name === "local") continue;
-        if (rec && typeof rec === "object" && typeof (rec as ContextRecord).server === "string") {
-          contexts[name] = {
-            server: (rec as ContextRecord).server,
-            ...(typeof (rec as ContextRecord).token_env === "string" ? { token_env: (rec as ContextRecord).token_env } : {}),
-          };
-        }
-      }
-    }
-
-    return { default_context, contexts };
-  } catch {
-    return base;
-  }
-}
-
-export async function saveContextConfig(config: ContextConfig, filePath?: string): Promise<void> {
-  const targetPath = expandHome(filePath ?? DEFAULT_CONTEXTS_PATH);
-  const dir = dirname(targetPath);
-  mkdirSync(dir, { recursive: true });
-
-  // Serialize to TOML
-  let tomlStr = `default_context = "${config.default_context}"\n\n[contexts]\n`;
-  for (const [name, rec] of Object.entries(config.contexts)) {
-    if (name === "local") {
-      tomlStr += `[contexts.local]\nserver = "local"\n\n`;
-      continue;
-    }
-    tomlStr += `[contexts.${name}]\nserver = "${rec.server}"\n`;
-    if (rec.token_env) {
-      tomlStr += `token_env = "${rec.token_env}"\n`;
-    }
-    tomlStr += `\n`;
-  }
-
-  const tmpPath = join(dir, `.contexts-${Math.random().toString(36).slice(2)}.tmp`);
-  writeFileSync(tmpPath, tomlStr, "utf-8");
-  renameSync(tmpPath, targetPath);
-}
-
-export async function listContexts(filePath?: string): Promise<Array<{ name: string; server: string; token_env?: string; isDefault: boolean }>> {
-  const config = await loadContextConfig(filePath);
-  return Object.entries(config.contexts).map(([name, rec]) => ({
-    name,
-    server: rec.server,
-    token_env: rec.token_env,
-    isDefault: name === config.default_context,
-  }));
-}
-
-export async function getCurrentContext(filePath?: string): Promise<{ name: string; server: string; token_env?: string }> {
-  const config = await loadContextConfig(filePath);
-  const name = config.contexts[config.default_context] ? config.default_context : "local";
-  const rec = config.contexts[name] ?? { server: "local" };
-  return { name, server: rec.server, token_env: rec.token_env };
-}
-
-export async function addContext(name: string, record: ContextRecord, filePath?: string): Promise<void> {
-  if (name === "local") {
-    throw new Error('Context "local" is reserved and cannot be added or modified');
-  }
-  const config = await loadContextConfig(filePath);
-  config.contexts[name] = record;
-  await saveContextConfig(config, filePath);
-}
-
-export async function removeContext(name: string, filePath?: string): Promise<void> {
-  if (name === "local") {
-    throw new Error('Context "local" is reserved and cannot be removed');
-  }
-  const config = await loadContextConfig(filePath);
-  if (!config.contexts[name]) {
-    throw new Error(`Context "${name}" does not exist`);
-  }
-  delete config.contexts[name];
-  if (config.default_context === name) {
-    config.default_context = "local";
-  }
-  await saveContextConfig(config, filePath);
-}
-
-export async function useContext(name: string, filePath?: string): Promise<void> {
-  const config = await loadContextConfig(filePath);
-  if (!config.contexts[name]) {
-    throw new Error(`Context "${name}" does not exist`);
-  }
-  config.default_context = name;
-  await saveContextConfig(config, filePath);
-}
-
-export async function resolveContext(
-  flags: { context?: string; server?: string },
-  filePath?: string
-): Promise<ResolvedContext> {
-  // Precedence 1: Explicit flags
-  if (flags.context && flags.server) {
-    throw new Error("Cannot specify both --context and --server");
-  }
-  if (flags.context) {
-    if (flags.context === "local") return { type: "local", name: "local" };
-    const config = await loadContextConfig(filePath);
-    const rec = config.contexts[flags.context];
-    if (!rec) {
-      throw new Error(`Specified context "${flags.context}" does not exist`);
-    }
-    if (rec.server === "local") return { type: "local", name: "local" };
-    return { type: "remote", name: flags.context, server: rec.server, token_env: rec.token_env };
-  }
-  if (flags.server) {
-    if (flags.server === "local") return { type: "local", name: "local" };
-    return { type: "remote", name: "custom", server: flags.server };
-  }
-
-  // Precedence 2: Environment variables
-  const envContext = process.env.SKILLMUX_CONTEXT;
-  const envServer = process.env.SKILLMUX_SERVER;
-  if (envContext && envServer) {
-    throw new Error("Cannot specify both SKILLMUX_CONTEXT and SKILLMUX_SERVER");
-  }
-  if (envContext) {
-    if (envContext === "local") return { type: "local", name: "local" };
-    const config = await loadContextConfig(filePath);
-    const rec = config.contexts[envContext];
-    if (!rec) {
-      throw new Error(`Configured SKILLMUX_CONTEXT "${envContext}" does not exist`);
-    }
-    if (rec.server === "local") return { type: "local", name: "local" };
-    return { type: "remote", name: envContext, server: rec.server, token_env: rec.token_env };
-  }
-  if (envServer) {
-    if (envServer === "local") return { type: "local", name: "local" };
-    return { type: "remote", name: "custom", server: envServer };
-  }
-
-  // Precedence 3 & 4: Configured default context -> local
-  const config = await loadContextConfig(filePath);
-  const defName = config.contexts[config.default_context] ? config.default_context : "local";
-  const defRec = config.contexts[defName] ?? { server: "local" };
-
-  if (defName === "local" || defRec.server === "local") {
-    return { type: "local", name: "local" };
-  }
-  return { type: "remote", name: defName, server: defRec.server, token_env: defRec.token_env };
-}

package/src/db-audit.ts

@@ -1,286 +0,0 @@
-import { Database } from "bun:sqlite";
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import type { AuditCandidate, AuditRow } from "./types";
-
-export function openAudit(stateDir: string): Database {
-  mkdirSync(stateDir, { recursive: true });
-  const db = new Database(join(stateDir, "audit.sqlite3"), { create: true });
-  // auto_vacuum only takes on an empty database, so it must precede both the
-  // journal-mode switch and any CREATE TABLE. It is what lets a retention
-  // prune reclaim space without a full VACUUM.
-  db.run("PRAGMA auto_vacuum = INCREMENTAL");
-  db.run("PRAGMA journal_mode = WAL");
-  db.run("PRAGMA busy_timeout = 2000");
-  db.run(`CREATE TABLE IF NOT EXISTS audit (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    ts TEXT NOT NULL,
-    request_id TEXT,
-    query TEXT NOT NULL,
-    retrieval TEXT NOT NULL DEFAULT 'lexical',
-    degraded_from TEXT,
-    degradation_reason TEXT,
-    candidates TEXT NOT NULL,
-    latency_ms INTEGER NOT NULL
-  )`);
-  // CREATE TABLE IF NOT EXISTS no-ops on a table opened from before request_id
-  // existed (AC4), so add it explicitly when missing.
-  const auditColumns = new Set(
-    (db.query("PRAGMA table_info(audit)").all() as { name: string }[]).map((c) => c.name),
-  );
-  if (!auditColumns.has("request_id")) {
-    db.run("ALTER TABLE audit ADD COLUMN request_id TEXT");
-  }
-  db.run(`CREATE TABLE IF NOT EXISTS fetch (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    ts TEXT NOT NULL,
-    skill_id TEXT NOT NULL,
-    request_id TEXT,
-    resolve_audit_id INTEGER,
-    rank_at_resolve INTEGER
-  )`);
-  db.run(`CREATE TABLE IF NOT EXISTS admin_audit (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    ts TEXT NOT NULL,
-    changes TEXT NOT NULL,
-    resulting_revision TEXT NOT NULL,
-    row_hash TEXT NOT NULL,
-    prev_row_hash TEXT
-  )`);
-  adoptAuditFromIndex(db, stateDir);
-  return db;
-}
-
-// Audit rows used to live in index.sqlite3. Move any that remain there into the
-// audit store, then drop the old table so the index carries no user queries.
-function adoptAuditFromIndex(db: Database, stateDir: string): void {
-  const indexPath = join(stateDir, "index.sqlite3");
-  if (!existsSync(indexPath)) return;
-
-  db.run("ATTACH DATABASE ? AS legacy", [indexPath]);
-  try {
-    const legacyAudit = db
-      .query("SELECT name FROM legacy.sqlite_master WHERE type = 'table' AND name = 'audit'")
-      .get();
-    if (!legacyAudit) return;
-
-    // Older audit tables predate the retrieval columns and carry outcome /
-    // degraded / selected_skill_id instead. Select what is actually there and
-    // let the canonical defaults stand in for the rest.
-    const legacyColumns = new Set(
-      (db.query("PRAGMA legacy.table_info(audit)").all() as { name: string }[]).map((c) => c.name),
-    );
-    const retrieval = legacyColumns.has("retrieval") ? "COALESCE(retrieval, 'lexical')" : "'lexical'";
-    const degradedFrom = legacyColumns.has("degraded_from") ? "degraded_from" : "NULL";
-    const degradationReason = legacyColumns.has("degradation_reason") ? "degradation_reason" : "NULL";
-
-    // SQLite commits atomically across attached databases, so the copy and the
-    // drop either both land or neither does.
-    db.transaction(() => {
-      db.run(`INSERT INTO audit (ts, query, retrieval, degraded_from, degradation_reason, candidates, latency_ms)
-        SELECT ts, query, ${retrieval}, ${degradedFrom}, ${degradationReason}, candidates, latency_ms FROM legacy.audit`);
-      db.run("DROP TABLE legacy.audit");
-    })();
-  } finally {
-    db.run("DETACH DATABASE legacy");
-  }
-}
-
-export interface AuditInsert {
-  ts: string;
-  request_id?: string | null;
-  query: string;
-  retrieval: AuditRow["retrieval"];
-  degraded_from?: string | null;
-  degradation_reason?: string | null;
-  candidates: AuditCandidate[];
-  latency_ms: number;
-}
-
-export function insertAudit(db: Database, row: AuditInsert): void {
-  db.run(
-    `INSERT INTO audit (ts, request_id, query, retrieval, degraded_from, degradation_reason, candidates, latency_ms)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-    [
-      row.ts,
-      row.request_id ?? null,
-      row.query,
-      row.retrieval,
-      row.degraded_from ?? null,
-      row.degradation_reason ?? null,
-      JSON.stringify(row.candidates),
-      row.latency_ms,
-    ],
-  );
-}
-
-/**
- * Correlation lookup for AC5/AC7: looks up the resolve that produced
- * `requestId`, or null when it names no known resolve (including malformed
- * input, which is never validated at the boundary per AC7).
- */
-export function getAuditRowByRequestId(
-  db: Database,
-  requestId: string,
-): { id: number; candidates: AuditCandidate[] } | null {
-  const row = db
-    .query("SELECT id, candidates FROM audit WHERE request_id = ?")
-    .get(requestId) as { id: number; candidates: string } | null;
-  if (!row) return null;
-  return { id: row.id, candidates: JSON.parse(row.candidates) as AuditCandidate[] };
-}
-
-export interface FetchInsert {
-  ts: string;
-  skill_id: string;
-  request_id?: string | null;
-  resolve_audit_id?: number | null;
-  rank_at_resolve?: number | null;
-}
-
-export function insertFetch(db: Database, row: FetchInsert): void {
-  db.run(
-    `INSERT INTO fetch (ts, skill_id, request_id, resolve_audit_id, rank_at_resolve)
-     VALUES (?, ?, ?, ?, ?)`,
-    [
-      row.ts,
-      row.skill_id,
-      row.request_id ?? null,
-      row.resolve_audit_id ?? null,
-      row.rank_at_resolve ?? null,
-    ],
-  );
-}
-
-export interface PruneResult {
-  audit_deleted: number;
-  fetch_deleted: number;
-  admin_audit_deleted: number;
-}
-
-/**
- * Deletes resolve, fetch, and admin_audit rows with ts before `cutoffIso`,
- * each by its own timestamp; no FK ties them, so a fetch outliving its
- * resolve row simply reads back uncorrelated (AC7's existing null path).
- * admin_audit shares this cutoff rather than a separate retention config
- * (AC10) — its hash chain is unaffected since pruning only ever removes the
- * oldest rows, never rows in the middle of the chain. Reclaims the freed
- * pages with an incremental vacuum, which only touches audit.sqlite3 (AC16).
- */
-export function pruneAuditBefore(db: Database, cutoffIso: string): PruneResult {
-  const auditResult = db.run("DELETE FROM audit WHERE ts < ?", [cutoffIso]);
-  const fetchResult = db.run("DELETE FROM fetch WHERE ts < ?", [cutoffIso]);
-  const adminAuditResult = db.run("DELETE FROM admin_audit WHERE ts < ?", [cutoffIso]);
-  db.run("PRAGMA incremental_vacuum");
-
-  return {
-    audit_deleted: auditResult.changes,
-    fetch_deleted: fetchResult.changes,
-    admin_audit_deleted: adminAuditResult.changes,
-  };
-}
-
-/** AC12: retentionDays <= 0 disables pruning entirely. */
-export function pruneAudit(db: Database, retentionDays: number, now: Date = new Date()): PruneResult {
-  if (retentionDays <= 0) return { audit_deleted: 0, fetch_deleted: 0, admin_audit_deleted: 0 };
-  const cutoff = new Date(now.getTime() - retentionDays * 86_400_000).toISOString();
-  return pruneAuditBefore(db, cutoff);
-}
-
-export interface AdminAuditChange {
-  key: string;
-  old_value: unknown;
-  new_value: unknown;
-}
-
-export interface AdminAuditInsert {
-  ts: string;
-  changes: AdminAuditChange[];
-  resulting_revision: string;
-}
-
-export interface AdminAuditRow {
-  id: number;
-  ts: string;
-  changes: AdminAuditChange[];
-  resulting_revision: string;
-  row_hash: string;
-  prev_row_hash: string | null;
-}
-
-function computeAdminAuditRowHash(
-  prevRowHash: string | null,
-  fields: { ts: string; changes: AdminAuditChange[]; resulting_revision: string },
-): string {
-  const payload = JSON.stringify({ prev_row_hash: prevRowHash, ...fields });
-  return createHash("sha256").update(payload).digest("hex");
-}
-
-/**
- * Appends one tamper-evident admin_audit row, chaining its hash to the
- * previous row's hash (or null for the first row) so any out-of-band
- * edit/delete breaks the chain — see verifyAdminAuditChain.
- */
-export function insertAdminAuditRow(db: Database, row: AdminAuditInsert): AdminAuditRow {
-  const prevRow = db
-    .query("SELECT row_hash FROM admin_audit ORDER BY id DESC LIMIT 1")
-    .get() as { row_hash: string } | null;
-  const prevRowHash = prevRow?.row_hash ?? null;
-  const rowHash = computeAdminAuditRowHash(prevRowHash, row);
-
-  db.run(
-    `INSERT INTO admin_audit (ts, changes, resulting_revision, row_hash, prev_row_hash)
-     VALUES (?, ?, ?, ?, ?)`,
-    [row.ts, JSON.stringify(row.changes), row.resulting_revision, rowHash, prevRowHash],
-  );
-
-  const inserted = db.query("SELECT last_insert_rowid() AS id").get() as { id: number };
-  return {
-    id: inserted.id,
-    ts: row.ts,
-    changes: row.changes,
-    resulting_revision: row.resulting_revision,
-    row_hash: rowHash,
-    prev_row_hash: prevRowHash,
-  };
-}
-
-export interface AdminAuditChainResult {
-  valid: boolean;
-  broken_at_id: number | null;
-}
-
-/** Walks admin_audit in insertion order and reports whether the hash chain is unbroken. */
-export function verifyAdminAuditChain(db: Database): AdminAuditChainResult {
-  const rows = db
-    .query("SELECT id, ts, changes, resulting_revision, row_hash, prev_row_hash FROM admin_audit ORDER BY id ASC")
-    .all() as { id: number; ts: string; changes: string; resulting_revision: string; row_hash: string; prev_row_hash: string | null }[];
-
-  let expectedPrevHash: string | null = null;
-  for (const row of rows) {
-    if (row.prev_row_hash !== expectedPrevHash) {
-      return { valid: false, broken_at_id: row.id };
-    }
-    const recomputed = computeAdminAuditRowHash(expectedPrevHash, {
-      ts: row.ts,
-      changes: JSON.parse(row.changes),
-      resulting_revision: row.resulting_revision,
-    });
-    if (recomputed !== row.row_hash) {
-      return { valid: false, broken_at_id: row.id };
-    }
-    expectedPrevHash = row.row_hash;
-  }
-  return { valid: true, broken_at_id: null };
-}
-
-/** Dry-run counterpart of pruneAuditBefore: counts without deleting (AC15). */
-export function countPrunable(db: Database, cutoffIso: string): PruneResult {
-  const auditRow = db.query("SELECT count(*) AS n FROM audit WHERE ts < ?").get(cutoffIso) as { n: number };
-  const fetchRow = db.query("SELECT count(*) AS n FROM fetch WHERE ts < ?").get(cutoffIso) as { n: number };
-  const adminAuditRow = db
-    .query("SELECT count(*) AS n FROM admin_audit WHERE ts < ?")
-    .get(cutoffIso) as { n: number };
-  return { audit_deleted: auditRow.n, fetch_deleted: fetchRow.n, admin_audit_deleted: adminAuditRow.n };
-}