knit-mcp 0.6.0

package/dist/chunk-TH5QPD5E.js

@@ -0,0 +1,399 @@
+import {
+  VOLTAGENT_PINNED_SHA,
+  VOLTAGENT_REF,
+  categoryOf,
+  isBundledCore,
+  knownAgents,
+  rawAgentUrl
+} from "./chunk-LW6NOFHF.js";
+import {
+  agentsCacheFile,
+  projectAgentFile,
+  projectAgentsDir,
+  sessionsJsonlPath
+} from "./chunk-YI37OAJ7.js";
+
+// src/engine/install-agents.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+
+// src/engine/agent-fetcher.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function bareName(name) {
+  return name.replace(/^(knit|engram)-/, "");
+}
+function attributionComment(name, category, ref) {
+  return `<!--
+  Vendored by engram from:
+    https://github.com/VoltAgent/awesome-claude-code-subagents
+    @${ref}/categories/${category}/${name}.md
+  License: MIT (see github.com/VoltAgent/awesome-claude-code-subagents/blob/main/LICENSE).
+  This file was copied verbatim with this header prepended; the original
+  YAML frontmatter and prompt content are unchanged.
+-->
+`;
+}
+function injectAttribution(body, name, category, ref) {
+  const fmEnd = body.indexOf("\n---", 3);
+  if (fmEnd < 0) return body;
+  const head = body.slice(0, fmEnd + 4);
+  const tail = body.slice(fmEnd + 4);
+  return `${head}
+${attributionComment(name, category, ref)}${tail}`;
+}
+var AgentFetchError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "AgentFetchError";
+  }
+  cause;
+};
+async function fetchAgent(name, opts = {}) {
+  const bare = bareName(name);
+  if (isBundledCore(bare)) {
+    const bundled = readBundledCore(bare, opts.bundledCoreDir);
+    if (bundled !== null) return bundled;
+  }
+  const ref = opts.ref || VOLTAGENT_REF;
+  const cat = categoryOf(bare);
+  if (!cat) {
+    throw new AgentFetchError(`Unknown agent: "${name}". Not in engram's registry.`);
+  }
+  const cachePath = agentsCacheFile(ref, cat, bare);
+  if (existsSync(cachePath)) {
+    return readFileSync(cachePath, "utf-8");
+  }
+  if (process.env.ENGRAM_OFFLINE === "1") {
+    throw new AgentFetchError(
+      `Agent "${name}" not bundled and not cached, and ENGRAM_OFFLINE=1 is set. Either unset ENGRAM_OFFLINE or run \`engram install-agents\` when online to populate the cache.`
+    );
+  }
+  const url = rawAgentUrl(bare, ref);
+  if (!url) {
+    throw new AgentFetchError(`Cannot construct URL for agent "${name}".`);
+  }
+  const fetchFn = opts.fetchFn || defaultFetch;
+  let res;
+  try {
+    res = await fetchFn(url);
+  } catch (err) {
+    throw new AgentFetchError(`Network error fetching "${name}" from ${url}`, err);
+  }
+  if (!res.ok) {
+    throw new AgentFetchError(`Fetch failed for "${name}" (HTTP ${res.status}) \u2014 ${url}`);
+  }
+  const body = await res.text();
+  if (!body || body.length < 20) {
+    throw new AgentFetchError(`Fetched body for "${name}" is empty or suspiciously short.`);
+  }
+  const refForAttribution = ref === VOLTAGENT_REF ? VOLTAGENT_PINNED_SHA : ref;
+  const augmented = injectAttribution(body, bare, cat, refForAttribution);
+  mkdirSync(dirname(cachePath), { recursive: true });
+  writeFileSync(cachePath, augmented, "utf-8");
+  return augmented;
+}
+var defaultFetch = (url) => {
+  if (typeof globalThis.fetch !== "function") {
+    return Promise.reject(new Error("Global fetch unavailable. Requires Node 18+."));
+  }
+  return globalThis.fetch(url);
+};
+function readBundledCore(name, customDir) {
+  const dir = customDir || bundledCoreDir();
+  const file = join(dir, `${name}.md`);
+  if (!existsSync(file)) return null;
+  try {
+    return readFileSync(file, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function bundledCoreDir() {
+  const here = fileURLToPath(import.meta.url);
+  let dir = dirname(here);
+  for (let i = 0; i < 8; i++) {
+    const candidate = join(dir, "dist", "agents", "core");
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return join(process.cwd(), "dist", "agents", "core");
+}
+
+// src/generators/agent-md.ts
+var ENGRAM_AGENT_MARKER_START = "<!-- engram:context:start -->";
+var ENGRAM_AGENT_MARKER_END = "<!-- engram:context:end -->";
+function personalizeAgent(baseMd, inputs) {
+  const block = buildContextBlock(inputs);
+  const startIdx = baseMd.indexOf(ENGRAM_AGENT_MARKER_START);
+  const endIdx = baseMd.indexOf(ENGRAM_AGENT_MARKER_END);
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    const before = baseMd.slice(0, startIdx);
+    const after = baseMd.slice(endIdx + ENGRAM_AGENT_MARKER_END.length);
+    return `${before.trimEnd()}
+
+${block}
+${after.trimStart() ? "\n" + after.trimStart() : ""}`;
+  }
+  return `${baseMd.trimEnd()}
+
+${block}
+`;
+}
+function buildContextBlock(inputs) {
+  const { config, knowledge, relevantLearnings, falsePositives } = inputs;
+  const lines = [];
+  lines.push(ENGRAM_AGENT_MARKER_START);
+  lines.push("");
+  lines.push("## Project context (knit-managed; do not edit by hand)");
+  lines.push("");
+  const stack = [config.stack.language, config.stack.framework].filter(Boolean).join(" + ");
+  lines.push(`**Project:** ${config.name}`);
+  if (stack) lines.push(`**Stack:** ${stack}`);
+  if (config.stack.testFramework) lines.push(`**Tests:** ${config.stack.testFramework}`);
+  lines.push("");
+  if (knowledge && knowledge.summary.highFanoutFiles.length > 0) {
+    const top = knowledge.summary.highFanoutFiles.slice(0, 10);
+    lines.push(`**High-fanout files (change carefully):**`);
+    for (const f of top) lines.push(`- \`${f}\``);
+    lines.push("");
+  }
+  if (knowledge && knowledge.summary.untestedFiles.length > 0) {
+    const top = knowledge.summary.untestedFiles.slice(0, 5);
+    lines.push(`**Untested source files (sample):**`);
+    for (const f of top) lines.push(`- \`${f}\``);
+    if (knowledge.summary.untestedFiles.length > 5) {
+      lines.push(`- (+${knowledge.summary.untestedFiles.length - 5} more)`);
+    }
+    lines.push("");
+  }
+  if (relevantLearnings && relevantLearnings.length > 0) {
+    lines.push(`**Recent relevant learnings:**`);
+    for (const l of relevantLearnings.slice(0, 5)) {
+      lines.push(`- ${l.summary} \u2014 ${l.lesson}`);
+    }
+    lines.push("");
+  }
+  if (falsePositives && falsePositives.length > 0) {
+    lines.push(`**Known false positives \u2014 DO NOT flag these:**`);
+    for (const fp of falsePositives.slice(0, 5)) {
+      lines.push(`- ${fp.summary} (${fp.lesson})`);
+    }
+    lines.push("");
+  }
+  lines.push("## Knit MCP tools you can call");
+  lines.push("");
+  lines.push("You have access to engram's MCP. Call these when you need depth:");
+  lines.push("- `knit_query_dependents(file_path)` \u2014 what depends on a file");
+  lines.push("- `knit_get_false_positives()` \u2014 full FP list, not just what's above");
+  lines.push("- `knit_search_learnings(domains)` \u2014 search past lessons by tag");
+  lines.push("- `knit_search_sessions(query)` \u2014 has a past session touched this area?");
+  lines.push("");
+  lines.push(ENGRAM_AGENT_MARKER_END);
+  return lines.join("\n");
+}
+function selectRelevantLearnings(allLearnings, agentName, limit = 5) {
+  const interests = inferInterestTags(agentName);
+  const scored = allLearnings.map((entry) => {
+    let score = 0;
+    for (const tag of entry.tags) {
+      const tagLower = tag.toLowerCase();
+      for (const interest of interests) {
+        if (tagLower.includes(interest)) score += 1;
+      }
+    }
+    return { entry, score, date: entry.date };
+  });
+  return scored.filter((s) => s.score > 0).sort((a, b) => b.score - a.score || (b.date > a.date ? 1 : -1)).slice(0, limit).map((s) => s.entry);
+}
+function inferInterestTags(agentName) {
+  const base = agentName.replace(/^(knit|engram)-/, "");
+  const parts = base.split("-");
+  return [base, ...parts].map((s) => s.toLowerCase());
+}
+
+// src/engine/install-agents.ts
+async function installAgentsForProject(rootPath, config, knowledge, knowledgeBase, opts = {}) {
+  const targets = opts.only ? opts.only : opts.all ? knownAgents() : agentsNeededByProject(config);
+  const result = {
+    installed: [],
+    alreadyCurrent: [],
+    skippedUserCurated: [],
+    failed: []
+  };
+  mkdirSync2(projectAgentsDir(rootPath), { recursive: true });
+  const fps = knowledgeBase ? knowledgeBase.entries.filter((e) => e.tags.includes("#false-positive")) : [];
+  for (const name of targets) {
+    const outFile = projectAgentFile(rootPath, name);
+    if (existsSync2(outFile) && !opts.refresh) {
+      try {
+        const existing = readFileSync2(outFile, "utf-8");
+        if (!existing.includes(ENGRAM_AGENT_MARKER_START)) {
+          result.skippedUserCurated.push(name);
+          continue;
+        }
+      } catch {
+        result.skippedUserCurated.push(name);
+        continue;
+      }
+    }
+    try {
+      const baseMd = await fetchAgent(name, opts.refresh ? { ref: void 0 } : {});
+      const relevant = knowledgeBase ? selectRelevantLearnings(knowledgeBase.entries, name) : [];
+      const personalized = personalizeAgent(baseMd, {
+        config,
+        knowledge,
+        relevantLearnings: relevant,
+        falsePositives: fps
+      });
+      if (existsSync2(outFile)) {
+        try {
+          const existing = readFileSync2(outFile, "utf-8");
+          if (existing.trim() === personalized.trim()) {
+            result.alreadyCurrent.push(name);
+            continue;
+          }
+        } catch {
+        }
+      }
+      writeFileSync2(outFile, personalized, "utf-8");
+      result.installed.push(name);
+    } catch (err) {
+      const msg = err instanceof AgentFetchError ? err.message : String(err);
+      result.failed.push({ name, error: msg });
+    }
+  }
+  return result;
+}
+function agentsNeededByProject(config) {
+  const names = /* @__PURE__ */ new Set();
+  for (const domain of config.domains) {
+    for (const agent of domain.agents) names.add(agent);
+  }
+  return Array.from(names);
+}
+
+// src/engine/sessions.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, appendFileSync, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync3, renameSync } from "fs";
+import { dirname as dirname2 } from "path";
+function appendSession(rootPath, entry) {
+  const path = sessionsJsonlPath(rootPath);
+  mkdirSync3(dirname2(path), { recursive: true });
+  appendFileSync(path, JSON.stringify(entry) + "\n", "utf-8");
+}
+function searchSessions(rootPath, query, limit = 10) {
+  const lines = readAllLines(rootPath);
+  if (lines.length === 0) return [];
+  const q = query.toLowerCase();
+  const matches = [];
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const entry = parseLine(lines[i]);
+    if (!entry) continue;
+    const haystack = [
+      entry.summary ?? "",
+      (entry.tags ?? []).join(" "),
+      entry.branch ?? ""
+    ].join(" ").toLowerCase();
+    if (haystack.includes(q)) {
+      matches.push(entry);
+      if (matches.length >= limit) break;
+    }
+  }
+  return matches;
+}
+function getRecentSessions(rootPath, n = 3) {
+  const lines = readAllLines(rootPath);
+  if (lines.length === 0) return [];
+  const start = Math.max(0, lines.length - n);
+  const recent = [];
+  for (let i = lines.length - 1; i >= start; i--) {
+    const entry = parseLine(lines[i]);
+    if (entry) recent.push(entry);
+  }
+  return recent;
+}
+function sessionCount(rootPath) {
+  return readAllLines(rootPath).length;
+}
+function pruneSessionsByAge(rootPath, maxAgeDays) {
+  const path = sessionsJsonlPath(rootPath);
+  if (!existsSync3(path)) return { kept: 0, pruned: 0 };
+  const lines = readAllLines(rootPath);
+  if (lines.length === 0) return { kept: 0, pruned: 0 };
+  const cutoffMs = Date.now() - maxAgeDays * 864e5;
+  const keptLines = [];
+  let pruned = 0;
+  for (const line of lines) {
+    const entry = parseLine(line);
+    if (!entry) {
+      keptLines.push(line);
+      continue;
+    }
+    const dateMs = parseDateUtc(entry.date);
+    if (dateMs === null) {
+      keptLines.push(line);
+      continue;
+    }
+    if (dateMs >= cutoffMs) {
+      keptLines.push(line);
+    } else {
+      pruned++;
+    }
+  }
+  if (pruned === 0) {
+    return { kept: keptLines.length, pruned: 0 };
+  }
+  const tmpPath = `${path}.tmp-${process.pid}-${Date.now()}`;
+  const body = keptLines.length === 0 ? "" : keptLines.join("\n") + "\n";
+  mkdirSync3(dirname2(path), { recursive: true });
+  writeFileSync3(tmpPath, body, "utf-8");
+  renameSync(tmpPath, path);
+  return { kept: keptLines.length, pruned };
+}
+function readAllLines(rootPath) {
+  const path = sessionsJsonlPath(rootPath);
+  if (!existsSync3(path)) return [];
+  try {
+    const stat = statSync(path);
+    if (stat.size === 0) return [];
+    if (stat.size > 100 * 1024 * 1024) return [];
+    return readFileSync3(path, "utf-8").split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function parseDateUtc(date) {
+  if (typeof date !== "string") return null;
+  const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(date);
+  if (!m) return null;
+  const y = Number(m[1]);
+  const mo = Number(m[2]);
+  const d = Number(m[3]);
+  if (!Number.isFinite(y) || !Number.isFinite(mo) || !Number.isFinite(d)) return null;
+  if (mo < 1 || mo > 12 || d < 1 || d > 31) return null;
+  const ms = Date.UTC(y, mo - 1, d);
+  return Number.isFinite(ms) ? ms : null;
+}
+function parseLine(line) {
+  try {
+    const obj = JSON.parse(line);
+    if (typeof obj !== "object" || obj === null) return null;
+    if (typeof obj.id !== "string" || typeof obj.date !== "string") return null;
+    if (!obj.outcome) obj.outcome = "unknown";
+    return obj;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  installAgentsForProject,
+  appendSession,
+  searchSessions,
+  getRecentSessions,
+  sessionCount,
+  pruneSessionsByAge
+};

package/dist/chunk-YI37OAJ7.js

@@ -0,0 +1,145 @@
+// src/engine/paths.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// src/engine/project-id.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync, statSync } from "fs";
+import { resolve, dirname, join } from "path";
+function projectId(rootPath) {
+  const canonical = canonicalRepoRoot(rootPath);
+  return createHash("sha256").update(canonical).digest("hex").slice(0, 16);
+}
+function canonicalRepoRoot(rootPath) {
+  const dotGit = join(rootPath, ".git");
+  if (!existsSync(dotGit)) return resolve(rootPath);
+  try {
+    if (statSync(dotGit).isDirectory()) {
+      return resolve(rootPath);
+    }
+  } catch {
+    return resolve(rootPath);
+  }
+  try {
+    const content = readFileSync(dotGit, "utf-8");
+    const match = content.match(/^gitdir:\s*(.+)$/m);
+    if (!match) return resolve(rootPath);
+    const gitDir = resolve(dirname(dotGit), match[1].trim());
+    const marker = `${join(".git", "worktrees")}`;
+    const idx = gitDir.lastIndexOf(`/${marker}/`);
+    if (idx === -1) return resolve(rootPath);
+    return gitDir.slice(0, idx);
+  } catch {
+    return resolve(rootPath);
+  }
+}
+
+// src/engine/paths.ts
+function knitRoot() {
+  return process.env.KNIT_HOME || process.env.ENGRAM_HOME || join2(homedir(), ".knit");
+}
+function projectDataDir(rootPath) {
+  return join2(knitRoot(), "projects", projectId(rootPath));
+}
+function knowledgePath(rootPath) {
+  return join2(projectDataDir(rootPath), "knowledge.json");
+}
+function knowledgebasePath(rootPath) {
+  return join2(projectDataDir(rootPath), "knowledgebase.json");
+}
+function teamsPath(rootPath) {
+  return join2(projectDataDir(rootPath), "teams.json");
+}
+function worktreesRegistryPath(rootPath) {
+  return join2(projectDataDir(rootPath), "worktrees.json");
+}
+function globalDataDir() {
+  return join2(knitRoot(), "global");
+}
+function globalLearningsPath() {
+  return join2(globalDataDir(), "learnings.jsonl");
+}
+function agentsCacheDir(ref) {
+  return join2(knitRoot(), "agents", "cache", sanitizeRef(ref));
+}
+function agentsCacheFile(ref, category, name) {
+  return join2(agentsCacheDir(ref), category, `${name}.md`);
+}
+function projectAgentsDir(rootPath) {
+  return join2(rootPath, ".claude", "agents");
+}
+function projectAgentFile(rootPath, name) {
+  const bare = name.replace(/^(knit|engram)-/, "");
+  return join2(projectAgentsDir(rootPath), `knit-${bare}.md`);
+}
+function sanitizeRef(ref) {
+  return ref.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function sessionsJsonlPath(rootPath) {
+  return join2(projectDataDir(rootPath), "sessions.jsonl");
+}
+function protocolConfigPath(rootPath) {
+  return join2(projectDataDir(rootPath), "protocol-config.json");
+}
+function classificationMarkerPath(rootPath) {
+  return join2(projectDataDir(rootPath), ".classified-current");
+}
+function sessionMarkerPath(rootPath) {
+  return join2(projectDataDir(rootPath), ".session-loaded");
+}
+function learningsDir(rootPath) {
+  return join2(projectDataDir(rootPath), "learnings");
+}
+function learningsFilePath(rootPath, projectName) {
+  const slug = projectName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  return join2(learningsDir(rootPath), `${slug}.md`);
+}
+function sessionsLogPath(rootPath) {
+  return join2(learningsDir(rootPath), "sessions.md");
+}
+function legacyClaudeDir(rootPath) {
+  return join2(rootPath, ".claude");
+}
+function legacyKnowledgePath(rootPath) {
+  return join2(legacyClaudeDir(rootPath), "knowledge.json");
+}
+function legacyKnowledgebasePath(rootPath) {
+  return join2(legacyClaudeDir(rootPath), "knowledgebase.json");
+}
+function legacyTeamsPath(rootPath) {
+  return join2(legacyClaudeDir(rootPath), "teams.json");
+}
+function legacyLearningsDir(rootPath) {
+  return join2(legacyClaudeDir(rootPath), "learnings");
+}
+function migrationBreadcrumbPath(rootPath) {
+  return join2(legacyClaudeDir(rootPath), "MIGRATED.txt");
+}
+
+export {
+  projectId,
+  canonicalRepoRoot,
+  knitRoot,
+  projectDataDir,
+  knowledgePath,
+  knowledgebasePath,
+  teamsPath,
+  worktreesRegistryPath,
+  globalLearningsPath,
+  agentsCacheFile,
+  projectAgentsDir,
+  projectAgentFile,
+  sessionsJsonlPath,
+  protocolConfigPath,
+  classificationMarkerPath,
+  sessionMarkerPath,
+  learningsDir,
+  learningsFilePath,
+  sessionsLogPath,
+  legacyClaudeDir,
+  legacyKnowledgePath,
+  legacyKnowledgebasePath,
+  legacyTeamsPath,
+  legacyLearningsDir,
+  migrationBreadcrumbPath
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+var args = process.argv.slice(2);
+var hasSubcommand = args.length > 0 && ["setup", "status", "refresh", "install-agents", "export", "--help", "-h", "--version", "-V"].includes(args[0]);
+var isTTY = process.stdin.isTTY;
+if (hasSubcommand) {
+  runCLI();
+} else if (isTTY) {
+  process.argv.push("--help");
+  runCLI();
+} else {
+  runMCP();
+}
+async function runCLI() {
+  const gradient = (await import("gradient-string")).default;
+  const chalk = (await import("chalk")).default;
+  const { setupCommand } = await import("./setup-EQMYVVZ6.js");
+  const { statusCommand } = await import("./status-56MCC7KE.js");
+  const { refreshCommand } = await import("./refresh-3UK7NS5A.js");
+  const { installAgentsCommand } = await import("./install-agents-2UVEAP2W.js");
+  const { exportCommand } = await import("./export-3MA272OR.js");
+  const ENGRAM_GRADIENT = gradient(["#7c3aed", "#2563eb", "#06b6d4"]);
+  const banner = `
+  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+  \u2551                                       \u2551
+  \u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557         \u2551
+  \u2551   \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D         \u2551
+  \u2551   \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2588\u2557        \u2551
+  \u2551   \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551        \u2551
+  \u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D        \u2551
+  \u2551   \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D         \u2551
+  \u2551                                       \u2551
+  \u2551   knit \u2014 the second brain           \u2551
+  \u2551                                       \u2551
+  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D`;
+  const program = new Command();
+  program.name("knit").description("The second brain for Claude Code \u2014 MCP server + analytics dashboard").version("0.4.1").hook("preAction", () => {
+    console.log(ENGRAM_GRADIENT.multiline(banner));
+    console.log();
+  });
+  program.command("setup").description("Add Knit MCP to your Claude Code settings (one time)").option("--global", "Add to global ~/.claude/settings.json (default)", true).option("--local", "Add to project .claude/settings.json only", false).action(async (options) => {
+    try {
+      await setupCommand(options);
+    } catch (error) {
+      console.error(chalk.red("  Error:"), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+  program.command("status").description("Dashboard: sessions, learnings, hit rate, knowledge health").argument("[directory]", "Project directory", ".").action(async (directory) => {
+    try {
+      await statusCommand(directory);
+    } catch (error) {
+      console.error(chalk.red("  Error:"), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+  program.command("refresh").description("Force rebuild knowledge brain and CLAUDE.md").argument("[directory]", "Project directory", ".").action(async (directory) => {
+    try {
+      await refreshCommand(directory);
+    } catch (error) {
+      console.error(chalk.red("  Error:"), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+  program.command("install-agents").description("Install VoltAgent subagents into <project>/.claude/agents/, personalized with project context").argument("[directory]", "Project directory", ".").option("--refresh", "Re-fetch from network even if cached", false).option("--all", "Install every known agent (not just ones referenced by current domains)", false).action(async (directory, options) => {
+    try {
+      await installAgentsCommand(directory, options);
+    } catch (error) {
+      console.error(chalk.red("  Error:"), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+  program.command("export").description("Export knit learnings into a target format (e.g. an Obsidian vault)").argument("<format>", "Export format (currently only: obsidian)").argument("<vault-path>", "Output directory (Obsidian vault path)").option("--filter <tag>", "Only export entries tagged with this tag (e.g. #auth)").action(async (format, vaultPath, options) => {
+    try {
+      await exportCommand(format, vaultPath, options);
+    } catch (error) {
+      console.error(chalk.red("  Error:"), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+  program.parse();
+}
+async function runMCP() {
+  const { Server } = await import("@modelcontextprotocol/sdk/server/index.js");
+  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+  const { ListToolsRequestSchema, CallToolRequestSchema } = await import("@modelcontextprotocol/sdk/types.js");
+  const { getBrain, detectProjectRoot, refreshBrain } = await import("./cache-C6LI7UVN.js");
+  const { getToolDefinitions, handleToolCall } = await import("./tools-VHBH4PPR.js");
+  const ROOT_PATH = detectProjectRoot();
+  const server = new Server(
+    { name: "knit-brain", version: "0.4.1" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: getToolDefinitions()
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: params } = request.params;
+    try {
+      if (name === "knit_refresh_index") {
+        refreshBrain(ROOT_PATH);
+        return {
+          content: [{ type: "text", text: JSON.stringify({ status: "refreshed", root: ROOT_PATH }) }]
+        };
+      }
+      const brain = getBrain(ROOT_PATH);
+      const result = handleToolCall(name, params || {}, brain);
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: `Internal error: ${message}` }) }]
+      };
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}