knit-mcp 0.6.0

package/dist/export-3MA272OR.js

@@ -0,0 +1,238 @@
+import {
+  getRecentGlobalLearnings
+} from "./chunk-FEOG4WTP.js";
+import {
+  loadKnowledgeBase
+} from "./chunk-BAUQEFYY.js";
+import {
+  globalLearningsPath,
+  knitRoot
+} from "./chunk-YI37OAJ7.js";
+
+// src/commands/export.ts
+import { existsSync, mkdirSync, readdirSync, writeFileSync, statSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+async function exportCommand(format, vaultPath, options = {}) {
+  switch (format) {
+    case "obsidian":
+      await exportObsidian(vaultPath, options);
+      return;
+    default:
+      throw new Error(
+        `Unsupported export format: "${format}". Supported formats: obsidian`
+      );
+  }
+}
+async function exportObsidian(vaultPath, options) {
+  const learningsSubdir = join(vaultPath, "learnings");
+  const globalLearningsSubdir = join(vaultPath, "global-learnings");
+  mkdirSync(vaultPath, { recursive: true });
+  mkdirSync(learningsSubdir, { recursive: true });
+  mkdirSync(globalLearningsSubdir, { recursive: true });
+  const filter = options.filter;
+  const exported = [];
+  const projectEntryCounts = /* @__PURE__ */ new Map();
+  const projectsDir = join(knitRoot(), "projects");
+  let projectHashes = [];
+  if (existsSync(projectsDir)) {
+    try {
+      projectHashes = readdirSync(projectsDir).filter((name) => {
+        try {
+          return statSync(join(projectsDir, name)).isDirectory();
+        } catch {
+          return false;
+        }
+      });
+    } catch {
+      projectHashes = [];
+    }
+  }
+  for (const projectHash of projectHashes) {
+    const kbPath = join(projectsDir, projectHash, "knowledgebase.json");
+    if (!existsSync(kbPath)) continue;
+    const kb = loadKnowledgeBase(kbPath, projectHash);
+    const projectName = kb.projectName || projectHash;
+    const seenFilenames = /* @__PURE__ */ new Set();
+    for (const entry of kb.entries) {
+      if (!matchesFilter(entry.tags, filter)) continue;
+      const filename = uniqueFilename(seenFilenames, entry.summary);
+      const filePath = join(learningsSubdir, filename);
+      writeFileSync(filePath, renderProjectLearning(entry, kb, projectName), "utf-8");
+      exported.push({
+        filename,
+        subdir: "learnings",
+        summary: entry.summary,
+        tags: entry.tags,
+        projectName
+      });
+      projectEntryCounts.set(projectName, (projectEntryCounts.get(projectName) || 0) + 1);
+    }
+  }
+  const perProjectCount = exported.length;
+  let globalEntries = [];
+  if (existsSync(globalLearningsPath())) {
+    globalEntries = getRecentGlobalLearnings(1e5);
+  }
+  const seenGlobalFilenames = /* @__PURE__ */ new Set();
+  for (const entry of globalEntries) {
+    if (!matchesFilter(entry.tags, filter)) continue;
+    const filename = uniqueFilename(seenGlobalFilenames, entry.summary);
+    const filePath = join(globalLearningsSubdir, filename);
+    writeFileSync(filePath, renderGlobalLearning(entry), "utf-8");
+    exported.push({
+      filename,
+      subdir: "global-learnings",
+      summary: entry.summary,
+      tags: entry.tags,
+      projectName: entry.projectName
+    });
+  }
+  const globalCount = exported.length - perProjectCount;
+  writeFileSync(
+    join(vaultPath, "Engram Index.md"),
+    renderIndex(exported, perProjectCount, globalCount, projectEntryCounts),
+    "utf-8"
+  );
+  if (!process.env.ENGRAM_EXPORT_QUIET) {
+    console.log(chalk.green("  \u2713"), `Exported ${perProjectCount} per-project + ${globalCount} global learnings to ${vaultPath}`);
+  }
+}
+function matchesFilter(tags, filter) {
+  if (!filter) return true;
+  const wanted = filter.toLowerCase();
+  return tags.some((t) => t.toLowerCase() === wanted);
+}
+function sanitizeFilename(summary) {
+  const base = summary.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+  return base.length > 0 ? base : "entry";
+}
+function uniqueFilename(seen, summary) {
+  const base = sanitizeFilename(summary);
+  let candidate = `${base}.md`;
+  let i = 2;
+  while (seen.has(candidate)) {
+    candidate = `${base}-${i}.md`;
+    i++;
+  }
+  seen.add(candidate);
+  return candidate;
+}
+function stripHash(tag) {
+  return tag.startsWith("#") ? tag.slice(1) : tag;
+}
+function withHash(tag) {
+  return tag.startsWith("#") ? tag : `#${tag}`;
+}
+function renderProjectLearning(entry, _kb, projectName) {
+  const yamlTags = entry.tags.map(stripHash).join(", ");
+  const domains = entry.domains.join(", ");
+  const inlineTags = entry.tags.map(withHash).join(" ");
+  return `---
+date: ${entry.date}
+outcome: ${entry.outcome}
+domains: [${domains}]
+source_project: ${projectName}
+tags: [${yamlTags}]
+---
+
+# ${entry.summary}
+
+**Approach:** ${entry.approach}
+
+**Lesson:** ${entry.lesson}
+
+<!-- Tag links: [[#auth]] [[#stripe]] for Obsidian graph -->
+${inlineTags}
+`;
+}
+function renderGlobalLearning(entry) {
+  const yamlTags = entry.tags.map(stripHash).join(", ");
+  const inlineTags = entry.tags.map(withHash).join(" ");
+  const outcome = entry.outcome ?? "unknown";
+  return `---
+date: ${entry.date}
+outcome: ${outcome}
+source_project: ${entry.projectName}
+tags: [${yamlTags}]
+---
+
+# ${entry.summary}
+
+**Lesson:** ${entry.lesson}
+
+<!-- Tag links: [[#auth]] [[#stripe]] for Obsidian graph -->
+${inlineTags}
+`;
+}
+function renderIndex(exported, perProjectCount, globalCount, projectEntryCounts) {
+  const byTag = /* @__PURE__ */ new Map();
+  for (const e of exported) {
+    if (e.tags.length === 0) {
+      const k = "#untagged";
+      const arr = byTag.get(k) || [];
+      arr.push(e);
+      byTag.set(k, arr);
+      continue;
+    }
+    for (const t of e.tags) {
+      const k = withHash(t);
+      const arr = byTag.get(k) || [];
+      arr.push(e);
+      byTag.set(k, arr);
+    }
+  }
+  const tagSections = [...byTag.entries()].sort((a, b) => {
+    if (b[1].length !== a[1].length) return b[1].length - a[1].length;
+    return a[0].localeCompare(b[0]);
+  });
+  const perProjectByName = /* @__PURE__ */ new Map();
+  for (const e of exported) {
+    if (e.subdir !== "learnings") continue;
+    const arr = perProjectByName.get(e.projectName) || [];
+    arr.push(e);
+    perProjectByName.set(e.projectName, arr);
+  }
+  let out = `# Engram Knowledge Index
+
+Generated ${(/* @__PURE__ */ new Date()).toISOString()}. ${perProjectCount} per-project learnings + ${globalCount} global learnings.
+
+## By tag
+
+`;
+  if (tagSections.length === 0) {
+    out += `_No entries exported._
+
+`;
+  } else {
+    for (const [tag, entries] of tagSections) {
+      out += `### ${tag} (${entries.length} entries)
+`;
+      for (const entry of entries) {
+        const linkPath = `${entry.subdir}/${entry.filename.replace(/\.md$/, "")}`;
+        out += `- [[${linkPath}]]
+`;
+      }
+      out += "\n";
+    }
+  }
+  out += `## All projects
+
+`;
+  if (perProjectByName.size === 0) {
+    out += `_No per-project learnings exported._
+`;
+  } else {
+    const projects = [...perProjectByName.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+    for (const [project, entries] of projects) {
+      const total = projectEntryCounts.get(project) ?? entries.length;
+      const links = entries.map((e) => `[[learnings/${e.filename.replace(/\.md$/, "")}]]`).join(", ");
+      out += `- ${project}: ${total} entries \u2014 ${links}
+`;
+    }
+  }
+  return out;
+}
+export {
+  exportCommand
+};

package/dist/install-agents-2UVEAP2W.js

@@ -0,0 +1,76 @@
+import {
+  getBrain
+} from "./chunk-NZXLCN4Q.js";
+import "./chunk-QMICM263.js";
+import "./chunk-GRSYI2RR.js";
+import {
+  installAgentsForProject
+} from "./chunk-TH5QPD5E.js";
+import "./chunk-LW6NOFHF.js";
+import "./chunk-BAUQEFYY.js";
+import "./chunk-YI37OAJ7.js";
+
+// src/commands/install-agents.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+import ora from "ora";
+async function installAgentsCommand(targetDir, options) {
+  const rootPath = targetDir === "." ? process.cwd() : targetDir;
+  if (!existsSync(join(rootPath, "CLAUDE.md"))) {
+    console.log(chalk.yellow("  No CLAUDE.md found in this directory."));
+    console.log(chalk.dim("  Open this project in Claude Code with engram MCP first \u2014 it auto-initializes on first tool call."));
+    process.exit(1);
+  }
+  const spinner = ora({ text: chalk.dim("Loading brain\u2026"), spinner: "dots" }).start();
+  const brain = getBrain(rootPath);
+  spinner.succeed(chalk.dim(`Brain loaded (${brain.knowledge.summary.totalFiles} files indexed)`));
+  const installSpinner = ora({
+    text: chalk.dim(options.all ? "Installing all known agents\u2026" : "Installing agents for this project\u2026"),
+    spinner: "dots"
+  }).start();
+  const result = await installAgentsForProject(
+    rootPath,
+    brain.config,
+    brain.knowledge,
+    brain.knowledgeBase,
+    { refresh: options.refresh, all: options.all }
+  );
+  installSpinner.succeed(chalk.dim("Install complete"));
+  console.log();
+  if (result.installed.length > 0) {
+    console.log(chalk.bold("  Installed"));
+    for (const name of result.installed) {
+      console.log(`  ${chalk.green("\u2713")} knit-${name}.md`);
+    }
+    console.log();
+  }
+  if (result.alreadyCurrent.length > 0) {
+    console.log(chalk.bold("  Already current"));
+    for (const name of result.alreadyCurrent) {
+      console.log(`  ${chalk.dim("\xB7")} knit-${name}.md ${chalk.dim("(no change)")}`);
+    }
+    console.log();
+  }
+  if (result.skippedUserCurated.length > 0) {
+    console.log(chalk.bold("  Skipped (user-curated files; engram won't clobber)"));
+    for (const name of result.skippedUserCurated) {
+      console.log(`  ${chalk.yellow("!")} knit-${name}.md`);
+    }
+    console.log();
+  }
+  if (result.failed.length > 0) {
+    console.log(chalk.bold(chalk.red("  Failed")));
+    for (const f of result.failed) {
+      console.log(`  ${chalk.red("\u2717")} ${f.name} \u2014 ${chalk.dim(f.error)}`);
+    }
+    console.log();
+  }
+  const total = result.installed.length + result.alreadyCurrent.length;
+  console.log(chalk.dim(`  ${total} agent${total === 1 ? "" : "s"} ready in <project>/.claude/agents/`));
+  console.log(chalk.dim("  Claude Code will find them automatically when teams dispatch."));
+  console.log();
+}
+export {
+  installAgentsCommand
+};

package/dist/refresh-3UK7NS5A.js

@@ -0,0 +1,76 @@
+import {
+  buildKnowledge,
+  generateClaudeMd
+} from "./chunk-QMICM263.js";
+import {
+  findFalsePositives
+} from "./chunk-GRSYI2RR.js";
+import {
+  scanProject
+} from "./chunk-LW6NOFHF.js";
+import {
+  knowledgePath,
+  learningsDir,
+  projectDataDir
+} from "./chunk-YI37OAJ7.js";
+
+// src/commands/refresh.ts
+import { readFileSync, readdirSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+import ora from "ora";
+async function refreshCommand(targetDir) {
+  const rootPath = targetDir === "." ? process.cwd() : targetDir;
+  if (!existsSync(join(rootPath, "CLAUDE.md")) || !existsSync(projectDataDir(rootPath))) {
+    console.log(chalk.red("  No Engram setup found. Open this project in Claude Code with the Knit MCP \u2014 it will auto-initialize."));
+    process.exit(1);
+  }
+  const spinner = ora({ text: chalk.dim("Re-scanning project..."), spinner: "dots" }).start();
+  const scan = scanProject(rootPath);
+  spinner.succeed(chalk.dim("Project re-scanned"));
+  const knowledgeSpinner = ora({ text: chalk.dim("Rebuilding knowledge index..."), spinner: "dots" }).start();
+  const knowledge = buildKnowledge(rootPath, scan);
+  knowledgeSpinner.succeed(
+    `${chalk.bold("Indexed:")} ${chalk.cyan(String(knowledge.summary.totalFiles))} files  ${chalk.dim("|")}  ${chalk.bold("Imports:")} ${chalk.cyan(String(Object.keys(knowledge.importGraph).length))} mapped  ${chalk.dim("|")}  ${chalk.bold("Untested:")} ${chalk.cyan(String(knowledge.summary.untestedFiles.length))} flagged`
+  );
+  const learnDir = learningsDir(rootPath);
+  const learningsFiles = existsSync(learnDir) ? readdirSync(learnDir).filter((f) => f.endsWith(".md")) : [];
+  const falsePositives = learningsFiles.flatMap(
+    (f) => findFalsePositives(join(learnDir, f))
+  );
+  let projectName = "project";
+  try {
+    const pkg = JSON.parse(readFileSync(join(rootPath, "package.json"), "utf-8"));
+    if (pkg.name) projectName = pkg.name;
+  } catch {
+    const parts = rootPath.split("/");
+    projectName = parts[parts.length - 1] || "project";
+  }
+  const config = {
+    name: projectName,
+    packageManager: scan.packageManager,
+    stack: scan.stack,
+    domains: scan.domains,
+    targetAgent: "claude-code",
+    tokenOptimization: "standard"
+  };
+  const genSpinner = ora({ text: chalk.dim("Regenerating CLAUDE.md..."), spinner: "dots" }).start();
+  writeFileSync(join(rootPath, "CLAUDE.md"), generateClaudeMd(config, knowledge, falsePositives), "utf-8");
+  writeFileSync(knowledgePath(rootPath), JSON.stringify(knowledge, null, 2), "utf-8");
+  genSpinner.succeed(chalk.dim("CLAUDE.md + knowledge.json updated"));
+  console.log();
+  console.log(chalk.bold("  Refresh complete"));
+  if (falsePositives.length > 0) {
+    console.log(`  ${chalk.green("\u2713")} ${chalk.dim(`${falsePositives.length} false positives injected into CLAUDE.md`)}`);
+  }
+  if (knowledge.summary.highFanoutFiles.length > 0) {
+    console.log(`  ${chalk.green("\u2713")} ${chalk.dim(`High-fanout files: ${knowledge.summary.highFanoutFiles.join(", ")}`)}`);
+  }
+  if (knowledge.summary.untestedFiles.length > 0) {
+    console.log(`  ${chalk.yellow("!")} ${chalk.dim(`${knowledge.summary.untestedFiles.length} untested files \u2014 see Project Map in CLAUDE.md`)}`);
+  }
+  console.log();
+}
+export {
+  refreshCommand
+};

package/dist/setup-EQMYVVZ6.js

@@ -0,0 +1,104 @@
+// src/commands/setup.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import chalk from "chalk";
+import ora from "ora";
+var MCP_CONFIG = {
+  "knit-brain": {
+    command: "npx",
+    args: ["-y", "@piyushdua/engram-dev@latest"]
+  }
+};
+async function setupCommand(options) {
+  const isGlobal = options.global || !options.local;
+  const settingsPath = isGlobal ? join(homedir(), ".claude.json") : join(process.cwd(), ".claude", "settings.json");
+  const label = isGlobal ? "global (~/.claude.json)" : "local (.claude/settings.json)";
+  console.log(`  Adding Knit MCP to ${chalk.cyan(label)}`);
+  console.log();
+  const spinner = ora({ text: chalk.dim("Configuring..."), spinner: "dots" }).start();
+  if (isGlobal) {
+    const oldPath = join(homedir(), ".claude", "settings.json");
+    if (existsSync(oldPath)) {
+      try {
+        const old = JSON.parse(readFileSync(oldPath, "utf-8"));
+        if (old.mcpServers?.["knit-brain"]) {
+          delete old.mcpServers["knit-brain"];
+          if (Object.keys(old.mcpServers).length === 0) delete old.mcpServers;
+          writeFileSync(oldPath, JSON.stringify(old, null, 2), "utf-8");
+        }
+      } catch {
+      }
+    }
+  }
+  let settings = {};
+  const dir = dirname(settingsPath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    } catch {
+      settings = {};
+    }
+  }
+  if (!settings.mcpServers) settings.mcpServers = {};
+  const mcpServers = settings.mcpServers;
+  if (mcpServers["knit-brain"]) {
+    spinner.succeed(chalk.dim("Knit MCP already configured"));
+    console.log();
+    console.log(chalk.bold("  Already set up. Open any project in Claude Code \u2014 the brain activates automatically."));
+    console.log();
+    return;
+  }
+  mcpServers["knit-brain"] = MCP_CONFIG["knit-brain"];
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+  spinner.succeed(chalk.dim("Knit MCP configured"));
+  console.log();
+  console.log(chalk.bold("  Setup complete"));
+  console.log();
+  console.log(`  ${chalk.green("\u2713")} MCP server added to ${chalk.cyan(label)}`);
+  console.log(`  ${chalk.green("\u2713")} Auto-initializes on first use \u2014 no per-project setup needed`);
+  console.log();
+  const globalClaudeMd = join(homedir(), ".claude", "CLAUDE.md");
+  const engramInstruction = `
+
+## Engram Brain (MCP)
+
+You have the Knit MCP server connected. USE IT on every task:
+
+1. **First:** Call \`knit_classify_task\` with files you plan to touch \u2014 get tier and phases
+2. **Research:** Call \`knit_build_context\` \u2014 get domain context with ripple effects
+3. **During:** Use \`knit_query_imports\`, \`knit_query_exports\`, \`knit_query_tests\` instead of grepping
+4. **End:** Call \`knit_record_learning\` before saying "done" \u2014 persist what you learned
+
+For new projects, call \`knit_brain_status\` first \u2014 triggers auto-initialization.
+`;
+  if (existsSync(globalClaudeMd)) {
+    const existing = readFileSync(globalClaudeMd, "utf-8");
+    if (!existing.includes("Engram Brain (MCP)")) {
+      writeFileSync(globalClaudeMd, existing + engramInstruction, "utf-8");
+      console.log(`  ${chalk.green("\u2713")} Engram instructions added to ${chalk.cyan("~/.claude/CLAUDE.md")}`);
+    }
+  } else {
+    const dir2 = join(homedir(), ".claude");
+    if (!existsSync(dir2)) mkdirSync(dir2, { recursive: true });
+    writeFileSync(globalClaudeMd, `# Claude Code Global Instructions${engramInstruction}`, "utf-8");
+    console.log(`  ${chalk.green("\u2713")} Created ${chalk.cyan("~/.claude/CLAUDE.md")} with Engram instructions`);
+  }
+  console.log();
+  console.log(chalk.bold("  How it works"));
+  console.log(`  ${chalk.cyan("1.")} Open ${chalk.bold("any project")} in Claude Code`);
+  console.log(`  ${chalk.cyan("2.")} Agent calls \`knit_classify_task\` \u2192 brain auto-initializes`);
+  console.log(`  ${chalk.cyan("3.")} Agent gets 20 tools: imports, exports, tests, learnings, teams`);
+  console.log(`  ${chalk.cyan("4.")} Brain compounds with every session \u2014 gets smarter over time`);
+  console.log();
+  console.log(chalk.dim("  No CLI needed after this. The MCP server handles everything."));
+  console.log();
+  if (isGlobal) {
+    console.log(chalk.dim(`  Config written to: ${settingsPath}`));
+  }
+  console.log();
+}
+export {
+  setupCommand
+};

package/dist/status-56MCC7KE.js

@@ -0,0 +1,145 @@
+import {
+  readLearnings
+} from "./chunk-GRSYI2RR.js";
+import {
+  getKBSummary,
+  getStaleEntries,
+  getTopEntries,
+  loadKnowledgeBase
+} from "./chunk-BAUQEFYY.js";
+import {
+  knowledgePath,
+  knowledgebasePath,
+  learningsDir
+} from "./chunk-YI37OAJ7.js";
+
+// src/commands/status.ts
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+async function statusCommand(targetDir) {
+  const rootPath = targetDir === "." ? process.cwd() : targetDir;
+  const kbPath = knowledgebasePath(rootPath);
+  const knowledgeIndexPath = knowledgePath(rootPath);
+  if (!existsSync(kbPath) && !existsSync(knowledgeIndexPath)) {
+    console.log(chalk.yellow("  No Engram data found. The brain will auto-initialize when you open this project in Claude Code."));
+    console.log();
+    return;
+  }
+  if (existsSync(knowledgeIndexPath)) {
+    try {
+      const knowledge = JSON.parse(readFileSync(knowledgeIndexPath, "utf-8"));
+      const s = knowledge.summary;
+      console.log(chalk.bold("  Knowledge Index"));
+      console.log();
+      console.log(`  ${chalk.cyan("Files:")}        ${s.totalFiles} indexed (${s.totalLines.toLocaleString()} lines)`);
+      console.log(`  ${chalk.cyan("Imports:")}      ${Object.keys(knowledge.importGraph || {}).length} edges mapped`);
+      console.log(`  ${chalk.cyan("Exports:")}      ${Object.keys(knowledge.exports || {}).length} files with exports`);
+      console.log(`  ${chalk.cyan("Untested:")}     ${(s.untestedFiles || []).length} files`);
+      console.log(`  ${chalk.cyan("High-fanout:")}  ${(s.highFanoutFiles || []).length} files`);
+      if (s.largestFiles && s.largestFiles.length > 0) {
+        console.log();
+        console.log(chalk.bold("  Largest Files"));
+        console.log();
+        for (const f of s.largestFiles.slice(0, 5)) {
+          const bar = "\u2588".repeat(Math.min(Math.round(f.lines / 20), 30));
+          console.log(`  ${chalk.dim(f.path.padEnd(40))} ${chalk.cyan(bar)} ${f.lines}`);
+        }
+      }
+      if (s.languageBreakdown) {
+        console.log();
+        console.log(chalk.bold("  Language Breakdown"));
+        console.log();
+        for (const [ext, count] of Object.entries(s.languageBreakdown).sort((a, b) => b[1] - a[1])) {
+          const bar = "\u2588".repeat(Math.min(count, 30));
+          console.log(`  ${chalk.dim(String(ext).padEnd(10))} ${chalk.cyan(bar)} ${count}`);
+        }
+      }
+    } catch {
+    }
+  }
+  if (existsSync(kbPath)) {
+    const kb = loadKnowledgeBase(kbPath, "project");
+    const summary = getKBSummary(kb);
+    console.log();
+    console.log(chalk.bold("  Knowledge Base"));
+    console.log();
+    console.log(`  ${chalk.cyan("Learnings:")}      ${summary.totalEntries} total`);
+    console.log(`  ${chalk.green("Accessed:")}       ${summary.accessedEntries} (${summary.hitRate}% hit rate)`);
+    console.log(`  ${chalk.dim("Never used:")}     ${summary.neverAccessed}`);
+    console.log(`  ${chalk.yellow("False positives:")} ${summary.falsePositives}`);
+    const stale = getStaleEntries(kb);
+    if (stale.length > 0) {
+      console.log(`  ${chalk.red("Stale (30d+):")}    ${stale.length} \u2014 candidates for cleanup`);
+    }
+    console.log();
+    console.log(chalk.bold("  Session History"));
+    console.log();
+    console.log(`  ${chalk.cyan("Total sessions:")}  ${summary.totalSessions}`);
+    console.log(`  ${chalk.green("Cache hits:")}      ${summary.cacheHits} (learnings prevented re-investigation)`);
+    if (summary.avgFilesPerSession > 0) {
+      console.log(`  ${chalk.dim("Avg files/session:")} ${summary.avgFilesPerSession}`);
+    }
+    if (kb.metrics.sessions.length > 0) {
+      console.log();
+      console.log(chalk.bold("  Recent Sessions"));
+      console.log();
+      console.log(`  ${chalk.dim("Date".padEnd(12))} ${chalk.dim("Branch".padEnd(20))} ${chalk.dim("Files".padEnd(8))} ${chalk.dim("Learnings")}`);
+      console.log(`  ${chalk.dim("\u2500".repeat(55))}`);
+      for (const session of kb.metrics.sessions.slice(-10).reverse()) {
+        console.log(`  ${chalk.dim(session.date.padEnd(12))} ${(session.branch || "unknown").padEnd(20)} ${String(session.filesModified).padEnd(8)} +${session.learningsAdded}`);
+      }
+    }
+    const top = getTopEntries(kb, 5);
+    if (top.length > 0) {
+      console.log();
+      console.log(chalk.bold("  Most Valuable Learnings"));
+      console.log();
+      for (const entry of top) {
+        const badge = entry.accessCount > 0 ? chalk.green(`${entry.accessCount}x`) : chalk.dim("0x");
+        console.log(`  ${badge} ${chalk.dim(entry.date)} ${entry.summary}`);
+      }
+    }
+    if (summary.topDomains.length > 0) {
+      console.log();
+      console.log(chalk.bold("  Domain Distribution"));
+      console.log();
+      for (const [domain, count] of summary.topDomains) {
+        const bar = "\u2588".repeat(Math.min(count, 20));
+        console.log(`  ${chalk.cyan(domain.padEnd(20))} ${bar} ${count}`);
+      }
+    }
+    if (summary.cacheHits > 0 || summary.accessedEntries > 0) {
+      console.log();
+      console.log(chalk.bold("  Impact"));
+      console.log();
+      if (summary.cacheHits > 0) console.log(`  ${chalk.green("\u2713")} ${summary.cacheHits} re-investigations prevented by learnings`);
+      if (summary.accessedEntries > 0) console.log(`  ${chalk.green("\u2713")} ${summary.accessedEntries} learnings actively used`);
+      if (summary.falsePositives > 0) console.log(`  ${chalk.green("\u2713")} ${summary.falsePositives} false positives suppressing noise`);
+      if (summary.neverAccessed > 0) console.log(`  ${chalk.yellow("!")} ${summary.neverAccessed} learnings never accessed \u2014 review for cleanup`);
+    }
+  }
+  const learnDir = learningsDir(rootPath);
+  if (existsSync(learnDir)) {
+    const files = readdirSync(learnDir).filter((f) => f.endsWith(".md") && f !== "sessions.md");
+    if (files.length > 0) {
+      console.log();
+      console.log(chalk.bold("  Learnings Files"));
+      console.log();
+      for (const file of files) {
+        const entries = readLearnings(join(learnDir, file));
+        console.log(`  ${chalk.dim(file.padEnd(30))} ${entries.length} entries`);
+      }
+    }
+    const sessionsPath = join(learnDir, "sessions.md");
+    if (existsSync(sessionsPath)) {
+      const content = readFileSync(sessionsPath, "utf-8");
+      const sessionCount = (content.match(/^## Session/gm) || []).length;
+      console.log(`  ${chalk.dim("sessions.md".padEnd(30))} ${sessionCount} sessions logged`);
+    }
+  }
+  console.log();
+}
+export {
+  statusCommand
+};