autoctxd 0.4.1

package/src/cli/doctor.ts

@@ -0,0 +1,171 @@
+// Doctor: verifies install integrity, prints fixable diagnostics
+
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { join, resolve } from "path";
+import { getDb, closeDb } from "../db/sqlite/schema";
+import { getGlobalMetrics } from "../util/metrics";
+
+const CTX_ROOT = resolve(join(import.meta.dir, "..", ".."));
+const CLAUDE_DIR = resolve(join(CTX_ROOT, ".."));
+const SETTINGS = join(CLAUDE_DIR, "settings.json");
+
+interface Check {
+  name: string;
+  status: "ok" | "warn" | "fail";
+  detail: string;
+  fix?: string;
+}
+
+export async function runDoctor(): Promise<number> {
+  const checks: Check[] = [];
+
+  // 1. Bun available
+  try {
+    const proc = Bun.spawnSync(["bun", "--version"], { stdout: "pipe" });
+    if (proc.success) {
+      checks.push({ name: "Bun runtime", status: "ok", detail: proc.stdout.toString().trim() });
+    } else {
+      checks.push({ name: "Bun runtime", status: "fail", detail: "bun command failed" });
+    }
+  } catch {
+    checks.push({
+      name: "Bun runtime",
+      status: "fail",
+      detail: "Bun not on PATH",
+      fix: "Install Bun from https://bun.sh",
+    });
+  }
+
+  // 2. node_modules present
+  checks.push(
+    existsSync(join(CTX_ROOT, "node_modules"))
+      ? { name: "Dependencies", status: "ok", detail: "node_modules exists" }
+      : { name: "Dependencies", status: "fail", detail: "node_modules missing", fix: "Run: bun install" }
+  );
+
+  // 3. SQLite DB accessible
+  try {
+    const db = getDb();
+    const tables = db.prepare("SELECT COUNT(*) as c FROM sqlite_master WHERE type='table'").get() as any;
+    checks.push({
+      name: "SQLite database",
+      status: "ok",
+      detail: `${tables.c} tables initialized`,
+    });
+    closeDb();
+  } catch (e) {
+    checks.push({
+      name: "SQLite database",
+      status: "fail",
+      detail: `Cannot open DB: ${e}`,
+      fix: "Run: bun run src/cli/index.ts init",
+    });
+  }
+
+  // 4. LanceDB module loadable
+  try {
+    await import("@lancedb/lancedb");
+    checks.push({ name: "LanceDB module", status: "ok", detail: "loaded" });
+  } catch (e) {
+    checks.push({
+      name: "LanceDB module",
+      status: "warn",
+      detail: `module load failed: ${String(e).slice(0, 80)}`,
+      fix: "Vector search will be disabled. Re-run: bun install",
+    });
+  }
+
+  // 5. Hooks registered in settings.json
+  if (!existsSync(SETTINGS)) {
+    checks.push({
+      name: "Hooks registration",
+      status: "fail",
+      detail: `${SETTINGS} missing`,
+      fix: "Create settings.json — run: bun run scripts/install-hooks.ts",
+    });
+  } else {
+    try {
+      const raw = readFileSync(SETTINGS, "utf8");
+      const cfg = JSON.parse(raw);
+      const hookNames = ["PreToolUse", "PostToolUse", "Stop"];
+      const missing: string[] = [];
+      for (const name of hookNames) {
+        const hooks = cfg?.hooks?.[name] || [];
+        const found = JSON.stringify(hooks).includes("autoctxd");
+        if (!found) missing.push(name);
+      }
+      if (missing.length === 0) {
+        checks.push({
+          name: "Hooks registration",
+          status: "ok",
+          detail: "all 3 hooks registered",
+        });
+      } else {
+        checks.push({
+          name: "Hooks registration",
+          status: "warn",
+          detail: `missing: ${missing.join(", ")}`,
+          fix: "Run: bun run scripts/install-hooks.ts",
+        });
+      }
+    } catch (e) {
+      checks.push({
+        name: "Hooks registration",
+        status: "warn",
+        detail: `Cannot parse settings.json: ${e}`,
+      });
+    }
+  }
+
+  // 6. Data directory writable
+  const dataDir = process.env.AUTOCTXD_DATA_DIR || join(CTX_ROOT, "data");
+  try {
+    const probe = join(dataDir, ".doctor-probe");
+    writeFileSync(probe, "x");
+    try { unlinkSync(probe); } catch {}
+    checks.push({ name: "Data directory", status: "ok", detail: dataDir });
+  } catch (e) {
+    checks.push({
+      name: "Data directory",
+      status: "fail",
+      detail: `${dataDir} not writable: ${e}`,
+      fix: "Check directory permissions",
+    });
+  }
+
+  // 7. Metrics summary (informational)
+  try {
+    const m = getGlobalMetrics();
+    checks.push({
+      name: "Accumulated metrics",
+      status: "ok",
+      detail: `${m.sessionsWithContext} sessions · ${m.totalInjected} tokens injected · ~${m.totalSaved} tokens saved`,
+    });
+    closeDb();
+  } catch {}
+
+  // Print
+  console.log("\n╔══════════════════════════════════════╗");
+  console.log("║       autoctxd doctor              ║");
+  console.log("╚══════════════════════════════════════╝\n");
+
+  let fails = 0;
+  for (const c of checks) {
+    const icon = c.status === "ok" ? "✓" : c.status === "warn" ? "!" : "✗";
+    const pad = c.name.padEnd(22);
+    console.log(`  [${icon}] ${pad} ${c.detail}`);
+    if (c.fix) {
+      console.log(`        → ${c.fix}`);
+    }
+    if (c.status === "fail") fails++;
+  }
+
+  console.log("");
+  if (fails === 0) {
+    console.log("  All checks passed. autoctxd is healthy.\n");
+    return 0;
+  } else {
+    console.log(`  ${fails} check(s) failed. Run the suggested fixes above.\n`);
+    return 1;
+  }
+}

package/src/cli/embeddings.ts

@@ -0,0 +1,209 @@
+// `autoctxd embeddings` subcommands.
+//
+//   embeddings list                   show all providers and their availability
+//   embeddings status                 show the active provider + diagnostics
+//   embeddings switch <name> [--yes]  change the active provider; rebuilds the
+//                                     vector table by re-embedding every summary
+//                                     and decision in SQLite
+//   embeddings reembed [--yes]        force-rebuild the vector table without
+//                                     changing the provider (use after upgrading
+//                                     the underlying model)
+
+import {
+  ALL_PROVIDER_NAMES,
+  buildProvider,
+  getConfiguredProviderName,
+  setProvider,
+} from "../db/vector/providers/factory";
+import type { EmbeddingProviderName } from "../db/vector/providers/types";
+import { getDb } from "../db/sqlite/schema";
+import { addVector, dropTable } from "../db/vector/client";
+import { generateEmbedding, clearEmbeddingCache } from "../db/vector/embeddings";
+
+export async function runEmbeddingsCommand(args: string[]): Promise<number> {
+  const sub = args[0];
+  switch (sub) {
+    case "list":
+      return await listProviders();
+    case "status":
+      return await showStatus();
+    case "switch":
+      return await switchProvider(args[1], args.includes("--yes"));
+    case "reembed":
+      return await reembedAll(args.includes("--yes"));
+    default:
+      printHelp();
+      return sub ? 1 : 0;
+  }
+}
+
+function printHelp() {
+  console.log(`
+autoctxd embeddings — manage the embedding provider
+
+  list                       list all providers with availability checks
+  status                     show the active provider and diagnostics
+  switch <name> [--yes]      change provider (tfidf | minilm | ollama)
+                             re-embeds all stored summaries automatically
+  reembed [--yes]            re-embed everything without changing provider
+                             (run after upgrading the underlying model)
+
+Environment overrides:
+  AUTOCTXD_EMBEDDING       provider name (overrides config file)
+  AUTOCTXD_OLLAMA_URL      default http://localhost:11434
+  AUTOCTXD_OLLAMA_MODEL    default nomic-embed-text
+  AUTOCTXD_MODEL_DIR       where transformers.js caches MiniLM (default ~/.claude/autoctxd/models)
+`);
+}
+
+async function listProviders(): Promise<number> {
+  const active = getConfiguredProviderName();
+  console.log("");
+  for (const name of ALL_PROVIDER_NAMES) {
+    const p = buildProvider(name);
+    const check = await p.check();
+    const marker = name === active ? "→" : " ";
+    const status = check.ok ? "ready" : "unavailable";
+    console.log(`  ${marker} ${name.padEnd(8)} ${status.padEnd(12)} ${p.label}`);
+    if (!check.ok) {
+      console.log(`    └── ${check.reason}`);
+    }
+    if (p.dispose) await p.dispose().catch(() => {});
+  }
+  console.log("");
+  return 0;
+}
+
+async function showStatus(): Promise<number> {
+  const active = getConfiguredProviderName();
+  const p = buildProvider(active);
+  const check = await p.check();
+
+  console.log("");
+  console.log(`  Active provider: ${active}`);
+  console.log(`  Label:           ${p.label}`);
+  console.log(`  Dim:             ${p.dim}`);
+  console.log(`  Status:          ${check.ok ? "ready" : "unavailable — " + check.reason}`);
+
+  // Cache stats
+  try {
+    const db = getDb();
+    const rows = db
+      .prepare("SELECT provider, COUNT(*) as c FROM embeddings_cache GROUP BY provider")
+      .all() as Array<{ provider: string; c: number }>;
+    if (rows.length > 0) {
+      console.log(`  Cache rows by provider:`);
+      for (const r of rows) console.log(`    ${r.provider.padEnd(8)} ${r.c}`);
+    }
+  } catch {
+    // ignore
+  }
+
+  console.log("");
+  if (p.dispose) await p.dispose().catch(() => {});
+  return check.ok ? 0 : 1;
+}
+
+async function switchProvider(target: string | undefined, yes: boolean): Promise<number> {
+  if (!target || !ALL_PROVIDER_NAMES.includes(target as EmbeddingProviderName)) {
+    console.error(`error: provider name required (one of: ${ALL_PROVIDER_NAMES.join(", ")})`);
+    return 2;
+  }
+  const name = target as EmbeddingProviderName;
+
+  // Verify the target provider is actually usable before we clear data
+  const candidate = buildProvider(name);
+  const check = await candidate.check();
+  if (!check.ok) {
+    console.error(`error: provider '${name}' is not available — ${check.reason}`);
+    if (candidate.dispose) await candidate.dispose().catch(() => {});
+    return 1;
+  }
+  if (candidate.dispose) await candidate.dispose().catch(() => {});
+
+  const current = getConfiguredProviderName();
+  if (current === name) {
+    console.log(`Already using ${name}.`);
+    return 0;
+  }
+
+  if (!yes) {
+    console.log("");
+    console.log(`This will switch from '${current}' to '${name}' and rebuild the vector index.`);
+    console.log("Existing summaries are preserved; only the embeddings are recomputed.");
+    console.log("Re-run with --yes to confirm.");
+    console.log("");
+    return 0;
+  }
+
+  console.log(`Switching ${current} → ${name} ...`);
+  await setProvider(name);
+  return await reembedAll(true);
+}
+
+async function reembedAll(yes: boolean): Promise<number> {
+  const active = getConfiguredProviderName();
+  const provider = buildProvider(active);
+  const check = await provider.check();
+  if (!check.ok) {
+    console.error(`error: active provider '${active}' is not available — ${check.reason}`);
+    if (provider.dispose) await provider.dispose().catch(() => {});
+    return 1;
+  }
+  if (provider.dispose) await provider.dispose().catch(() => {});
+
+  if (!yes) {
+    console.log("");
+    console.log(`This will rebuild the vector index using provider '${active}'.`);
+    console.log("Re-run with --yes to confirm.");
+    console.log("");
+    return 0;
+  }
+
+  const db = getDb();
+  const summaries = db
+    .prepare("SELECT id, session_id, level, text, project_path, created_at FROM summaries ORDER BY id ASC")
+    .all() as Array<{ id: number; session_id: string | null; level: number; text: string; project_path: string | null; created_at: string }>;
+  const decisions = db
+    .prepare("SELECT id, project_path, title, decision_text, created_at FROM decisions ORDER BY id ASC")
+    .all() as Array<{ id: number; project_path: string | null; title: string; decision_text: string; created_at: string }>;
+
+  console.log(`Dropping vector table and re-embedding ${summaries.length} summaries + ${decisions.length} decisions...`);
+  await dropTable();
+  clearEmbeddingCache();
+
+  let n = 0;
+  for (const s of summaries) {
+    const v = await generateEmbedding(s.text);
+    await addVector({
+      id: `summary-${s.id}`,
+      session_id: s.session_id || "",
+      project_path: s.project_path || "",
+      text: s.text,
+      level: s.level,
+      created_at: s.created_at,
+      vector: Array.from(v),
+    });
+    n++;
+    if (n % 25 === 0) process.stdout.write(`  ${n}/${summaries.length + decisions.length}\r`);
+  }
+
+  for (const d of decisions) {
+    const v = await generateEmbedding(`${d.title} ${d.decision_text}`);
+    await addVector({
+      id: `decision-${d.id}`,
+      session_id: "",
+      project_path: d.project_path || "",
+      text: `DECISION: ${d.title} — ${d.decision_text}`,
+      level: 9,
+      created_at: d.created_at,
+      vector: Array.from(v),
+    });
+    n++;
+    if (n % 25 === 0) process.stdout.write(`  ${n}/${summaries.length + decisions.length}\r`);
+  }
+
+  console.log(`  ${n}/${summaries.length + decisions.length}`);
+  console.log(`Done. Provider '${active}' is now active with ${n} re-embedded items.`);
+  return 0;
+}