knit-mcp 0.6.0

package/dist/chunk-NZXLCN4Q.js

@@ -0,0 +1,720 @@
+import {
+  KNIT_MARKER_START,
+  buildKnowledge,
+  buildReverseDependencies,
+  generateClaudeMd,
+  spliceKnitBlock
+} from "./chunk-QMICM263.js";
+import {
+  readLearnings
+} from "./chunk-GRSYI2RR.js";
+import {
+  installAgentsForProject,
+  pruneSessionsByAge
+} from "./chunk-TH5QPD5E.js";
+import {
+  scanProject
+} from "./chunk-LW6NOFHF.js";
+import {
+  importFromMarkdown,
+  loadKnowledgeBase,
+  saveKnowledgeBase
+} from "./chunk-BAUQEFYY.js";
+import {
+  classificationMarkerPath,
+  knowledgePath,
+  knowledgebasePath,
+  learningsDir,
+  learningsFilePath,
+  legacyClaudeDir,
+  legacyKnowledgePath,
+  legacyKnowledgebasePath,
+  legacyLearningsDir,
+  legacyTeamsPath,
+  migrationBreadcrumbPath,
+  projectDataDir,
+  protocolConfigPath,
+  sessionMarkerPath,
+  sessionsJsonlPath,
+  sessionsLogPath,
+  teamsPath
+} from "./chunk-YI37OAJ7.js";
+
+// src/mcp/cache.ts
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, copyFileSync, readdirSync, statSync } from "fs";
+import { join, basename, dirname } from "path";
+
+// src/generators/learnings.ts
+function generateLearningsContent(config) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `# Project Learnings \u2014 ${config.name}
+
+> Recursive learning log. Check this BEFORE starting any task.
+> Grep by \`#tag\` to find relevant lessons for the domain you're working in.
+
+---
+
+## ${date} Project initialized with Engram workflow
+**Domain(s):** All \u2014 workflow infrastructure
+**Approach:** Auto-detected stack (${config.stack.language}${config.stack.framework ? " + " + config.stack.framework : ""}), generated ${config.domains.length} domains, wired hooks for ${config.targetAgent}.
+**Outcome:** Success \u2014 workflow infrastructure in place
+**Lesson:** This learnings file is the institutional memory. Every task should append an entry. Every session should check relevant tags before starting work. The LEARN phase is a hard exit gate \u2014 no task completes without updating this file.
+**Tags:** #workflow #all #bootstrap
+`;
+}
+
+// src/generators/settings.ts
+var HOOKS_VERSION = 3;
+function generateSettings(config, rootPath) {
+  return {
+    mcpServers: {
+      "knit-brain": {
+        command: "npx",
+        args: ["-y", "@piyushdua/engram-dev@latest"]
+      }
+    },
+    hooks: generateHooks(config, rootPath),
+    _knitHooks: { version: HOOKS_VERSION, generatedAt: (/* @__PURE__ */ new Date()).toISOString() }
+  };
+}
+function jsLit(s) {
+  return JSON.stringify(s.replace(/\\/g, "/"));
+}
+function nodeHook(script) {
+  const compact = script.split("\n").map((l) => l.replace(/\/\/.*$/, "").trim()).filter((l) => l.length > 0).join(" ");
+  return `node -e '${compact}'`;
+}
+var REPO_ROOT_JS = `
+  const __getRoot = () => {
+    try {
+      return require("child_process").execSync("git rev-parse --show-toplevel", { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+    } catch { return process.cwd(); }
+  };
+`;
+var GIT_GET_JS = `
+  const __git = (cmd, root, fallback) => {
+    try {
+      return require("child_process").execSync(cmd, { cwd: root, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+    } catch { return fallback === undefined ? "" : fallback; }
+  };
+`;
+function generateHooks(config, rootPath) {
+  const KB_PATH = knowledgebasePath(rootPath);
+  const LEARN_FILE = learningsFilePath(rootPath, config.name);
+  const SESSIONS_MD = sessionsLogPath(rootPath);
+  const SESSIONS_JSONL = sessionsJsonlPath(rootPath);
+  const LEARN_DIR = learningsDir(rootPath);
+  const ENGRAM_DIR = projectDataDir(rootPath);
+  const PROTOCOL_CONFIG = protocolConfigPath(rootPath);
+  const CLASSIFIED_MARKER = classificationMarkerPath(rootPath);
+  const SESSION_MARKER = sessionMarkerPath(rootPath);
+  const hooks = {
+    SessionStart: [
+      // Protocol Guard layer 1: drop a marker that knit_load_session
+      // should be the first MCP call. Hook itself is best-effort; it doesn't
+      // BLOCK on missing load_session, only the per-turn classification gate blocks.
+      {
+        _knitOwned: true,
+        hooks: [
+          {
+            type: "command",
+            command: nodeHook(`
+              try {
+                const fs = require("fs");
+                const path = require("path");
+                const p = ${jsLit(SESSION_MARKER)};
+                fs.mkdirSync(path.dirname(p), { recursive: true });
+                fs.writeFileSync(p, new Date().toISOString());
+                console.error("[knit] session marker written. Call knit_load_session as your first MCP call.");
+              } catch (e) {}
+            `),
+            timeout: 5
+          }
+        ]
+      }
+    ],
+    UserPromptSubmit: [
+      // Protocol Guard: each user turn invalidates the previous classification.
+      // knit_classify_task must be called fresh per turn before Edit/Write.
+      {
+        _knitOwned: true,
+        hooks: [
+          {
+            type: "command",
+            command: nodeHook(`
+              try {
+                const fs = require("fs");
+                const p = ${jsLit(CLASSIFIED_MARKER)};
+                if (fs.existsSync(p)) fs.rmSync(p, { force: true });
+              } catch (e) {}
+            `),
+            timeout: 5
+          }
+        ]
+      }
+    ],
+    PreToolUse: [
+      {
+        _knitOwned: true,
+        matcher: "Bash",
+        hooks: [
+          {
+            type: "command",
+            command: nodeHook(`
+              let d = "";
+              process.stdin.on("data", (c) => d += c);
+              process.stdin.on("end", () => {
+                try {
+                  const i = JSON.parse(d);
+                  const c = (i.tool_input && i.tool_input.command) || "";
+                  if (/^git\\s+(push\\b.*\\s(--force|-f)|reset\\s+--hard|commit.*--no-verify)/.test(c)) {
+                    console.log(JSON.stringify({ decision: "block", reason: "Destructive git operation blocked by Engram. Ask the user first." }));
+                  }
+                } catch (e) {}
+              });
+            `),
+            timeout: 5
+          }
+        ]
+      },
+      // Protocol Guard layer 2: gate Edit/Write/MultiEdit on prior knit_classify_task.
+      {
+        _knitOwned: true,
+        matcher: "Edit|Write|MultiEdit",
+        hooks: [
+          {
+            type: "command",
+            command: nodeHook(`
+              try {
+                const fs = require("fs");
+                const cfgPath = ${jsLit(PROTOCOL_CONFIG)};
+                const markerPath = ${jsLit(CLASSIFIED_MARKER)};
+                let level = "warn";
+                if (fs.existsSync(cfgPath)) {
+                  try {
+                    const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+                    if (cfg && (cfg.level === "off" || cfg.level === "warn" || cfg.level === "block")) level = cfg.level;
+                  } catch (parseErr) {
+                    console.error("[knit] protocol-config.json unreadable, defaulting strictness=warn:", parseErr && parseErr.message ? parseErr.message : parseErr);
+                  }
+                }
+                if (level === "off") return;
+                const hasMarker = fs.existsSync(markerPath);
+                if (hasMarker) return;
+                if (level === "block") {
+                  console.error("[knit] BLOCKED: call knit_classify_task before Edit/Write. The Protocol Guard prevents implementation without classification.");
+                  process.exit(2);
+                }
+                console.error("[knit] reminder: call knit_classify_task before Edit/Write. Set strictness=block via knit_set_protocol_strictness to make this a hard gate.");
+              } catch (hookErr) {
+                console.error("[knit] protocol-guard hook crashed, allowing tool through:", hookErr && hookErr.message ? hookErr.message : hookErr);
+              }
+            `),
+            timeout: 5
+          }
+        ]
+      }
+    ],
+    PostToolUse: [],
+    Stop: []
+  };
+  if (config.stack.language === "typescript" && config.stack.typecheckCommand) {
+    hooks.PostToolUse.push({
+      _knitOwned: true,
+      matcher: "Write|Edit",
+      hooks: [
+        {
+          type: "command",
+          command: nodeHook(`
+            let d = "";
+            process.stdin.on("data", (c) => d += c);
+            process.stdin.on("end", () => {
+              try {
+                const i = JSON.parse(d);
+                const f = (i.tool_input && i.tool_input.file_path) || (i.tool_response && i.tool_response.filePath) || "";
+                if (!/\\.tsx?$/.test(f)) return;
+                ${REPO_ROOT_JS}
+                require("child_process").execSync("npx tsc --noEmit --pretty false", { cwd: __getRoot(), stdio: "inherit" });
+              } catch (e) {}
+            });
+          `),
+          timeout: 30,
+          statusMessage: "Type checking..."
+        }
+      ]
+    });
+  }
+  if (config.stack.language === "python") {
+    hooks.PostToolUse.push({
+      _knitOwned: true,
+      matcher: "Write|Edit",
+      hooks: [
+        {
+          type: "command",
+          command: nodeHook(`
+            let d = "";
+            process.stdin.on("data", (c) => d += c);
+            process.stdin.on("end", () => {
+              try {
+                const i = JSON.parse(d);
+                const f = (i.tool_input && i.tool_input.file_path) || (i.tool_response && i.tool_response.filePath) || "";
+                if (!/\\.py$/.test(f)) return;
+                ${REPO_ROOT_JS}
+                require("child_process").execSync("python3 -m py_compile " + JSON.stringify(f), { cwd: __getRoot(), stdio: "inherit" });
+              } catch (e) {}
+            });
+          `),
+          timeout: 15,
+          statusMessage: "Checking Python syntax..."
+        }
+      ]
+    });
+  }
+  if (config.stack.language === "go") {
+    hooks.PostToolUse.push({
+      _knitOwned: true,
+      matcher: "Write|Edit",
+      hooks: [
+        {
+          type: "command",
+          command: nodeHook(`
+            let d = "";
+            process.stdin.on("data", (c) => d += c);
+            process.stdin.on("end", () => {
+              try {
+                const i = JSON.parse(d);
+                const f = (i.tool_input && i.tool_input.file_path) || (i.tool_response && i.tool_response.filePath) || "";
+                if (!/\\.go$/.test(f)) return;
+                ${REPO_ROOT_JS}
+                require("child_process").execSync("go vet ./...", { cwd: __getRoot(), stdio: "inherit" });
+              } catch (e) {}
+            });
+          `),
+          timeout: 30,
+          statusMessage: "Running go vet..."
+        }
+      ]
+    });
+  }
+  if (config.stack.language === "rust") {
+    hooks.PostToolUse.push({
+      _knitOwned: true,
+      matcher: "Write|Edit",
+      hooks: [
+        {
+          type: "command",
+          command: nodeHook(`
+            let d = "";
+            process.stdin.on("data", (c) => d += c);
+            process.stdin.on("end", () => {
+              try {
+                const i = JSON.parse(d);
+                const f = (i.tool_input && i.tool_input.file_path) || (i.tool_response && i.tool_response.filePath) || "";
+                if (!/\\.rs$/.test(f)) return;
+                ${REPO_ROOT_JS}
+                require("child_process").execSync("cargo check", { cwd: __getRoot(), stdio: "inherit" });
+              } catch (e) {}
+            });
+          `),
+          timeout: 60,
+          statusMessage: "Running cargo check..."
+        }
+      ]
+    });
+  }
+  const steps = [];
+  if (config.stack.typecheckCommand) steps.push(["TYPECHECK", config.stack.typecheckCommand]);
+  if (config.stack.lintCommand) steps.push(["LINT", config.stack.lintCommand]);
+  if (config.stack.buildCommand) steps.push(["BUILD", config.stack.buildCommand]);
+  if (steps.length > 0) {
+    hooks.Stop.push({
+      _knitOwned: true,
+      hooks: [
+        {
+          type: "command",
+          command: nodeHook(`
+            ${REPO_ROOT_JS}
+            const steps = ${JSON.stringify(steps)};
+            for (const [name, cmd] of steps) {
+              console.log("--- " + name + " ---");
+              try {
+                require("child_process").execSync(cmd, { cwd: __getRoot(), stdio: "inherit" });
+              } catch (e) { break; }
+            }
+          `),
+          timeout: 120,
+          statusMessage: "Engram: final build verification..."
+        }
+      ]
+    });
+  }
+  hooks.Stop.push({
+    _knitOwned: true,
+    hooks: [
+      {
+        type: "command",
+        command: nodeHook(`
+          try {
+            const fs = require("fs");
+            ${REPO_ROOT_JS}
+            ${GIT_GET_JS}
+            const dir = ${jsLit(LEARN_DIR)};
+            const file = ${jsLit(SESSIONS_MD)};
+            fs.mkdirSync(dir, { recursive: true });
+            if (!fs.existsSync(file)) fs.writeFileSync(file, "# Session Log\\n");
+            const root = __getRoot();
+            const branch = __git("git branch --show-current", root);
+            const commits = __git("git log --oneline -3", root).split("\\n").filter(Boolean).map((l) => "  - " + l).join("\\n");
+            const changed = __git("git diff --stat HEAD", root).split("\\n").filter(Boolean).pop() || "";
+            const ts = new Date().toISOString().replace("T", " ").slice(0, 19) + " UTC";
+            let out = "\\n## Session " + ts + "\\n- Branch: " + branch + "\\n- Recent commits:\\n" + commits + "\\n";
+            if (changed) out += "- Uncommitted: " + changed + "\\n";
+            out += "\\n";
+            fs.appendFileSync(file, out);
+          } catch (e) {}
+        `),
+        timeout: 10,
+        statusMessage: "Engram: capturing session state..."
+      }
+    ]
+  });
+  hooks.Stop.push({
+    _knitOwned: true,
+    hooks: [
+      {
+        type: "command",
+        command: nodeHook(`
+          try {
+            const fs = require("fs");
+            ${REPO_ROOT_JS}
+            ${GIT_GET_JS}
+            const dir = ${jsLit(ENGRAM_DIR)};
+            const file = ${jsLit(SESSIONS_JSONL)};
+            fs.mkdirSync(dir, { recursive: true });
+            const root = __getRoot();
+            const branch = __git("git branch --show-current", root, null);
+            const filesMod = __git("git diff --name-only HEAD", root).split("\\n").filter(Boolean).length;
+            const commits = __git("git log --oneline -3", root).split("\\n").filter(Boolean).map((l) => l.split(" ")[0]).join(" ");
+            const now = new Date();
+            const entry = {
+              id: now.getTime() + "-" + process.pid,
+              date: now.toISOString().slice(0, 10),
+              timestamp: now.toISOString(),
+              branch: branch,
+              filesModified: filesMod,
+              commits: commits,
+            };
+            fs.appendFileSync(file, JSON.stringify(entry) + "\\n");
+          } catch (e) {}
+        `),
+        timeout: 10,
+        statusMessage: "Engram: recording session tuple..."
+      }
+    ]
+  });
+  hooks.Stop.push({
+    _knitOwned: true,
+    hooks: [
+      {
+        type: "command",
+        command: nodeHook(`
+          try {
+            const fs = require("fs");
+            const file = ${jsLit(LEARN_FILE)};
+            if (!fs.existsSync(file)) return;
+            const ageSec = (Date.now() - fs.statSync(file).mtimeMs) / 1000;
+            if (ageSec > 300) {
+              console.log("");
+              console.log("[Engram] LEARN was not recorded this session. That's fine if nothing reusable surfaced.");
+              console.log("         If something did, call knit_record_learning in your next session.");
+              console.log("");
+            }
+          } catch (e) {}
+        `),
+        timeout: 5,
+        statusMessage: "Engram: checking LEARN compliance..."
+      }
+    ]
+  });
+  hooks.Stop.push({
+    _knitOwned: true,
+    hooks: [
+      {
+        type: "command",
+        command: nodeHook(`
+          try {
+            const fs = require("fs");
+            ${REPO_ROOT_JS}
+            ${GIT_GET_JS}
+            const p = ${jsLit(KB_PATH)};
+            if (!fs.existsSync(p)) return;
+            const kb = JSON.parse(fs.readFileSync(p, "utf-8"));
+            const root = __getRoot();
+            const files = __git("git diff --name-only HEAD", root).split("\\n").filter(Boolean).length;
+            const branch = __git("git branch --show-current", root, null) || null;
+            kb.metrics.totalSessions++;
+            kb.metrics.sessions.push({
+              date: new Date().toISOString().split("T")[0],
+              branch: branch,
+              filesModified: files,
+              learningsAccessed: 0,
+              learningsAdded: 0,
+              domainsTouched: [],
+            });
+            if (kb.metrics.sessions.length > 20) kb.metrics.sessions = kb.metrics.sessions.slice(-20);
+            fs.writeFileSync(p, JSON.stringify(kb, null, 2));
+          } catch (e) {}
+        `),
+        timeout: 10,
+        statusMessage: "Engram: updating session metrics..."
+      }
+    ]
+  });
+  return hooks;
+}
+
+// src/mcp/cache.ts
+var cache = null;
+var hooksRefreshed = /* @__PURE__ */ new Set();
+function maybeRefreshHooks(rootPath, config) {
+  if (hooksRefreshed.has(rootPath)) return;
+  hooksRefreshed.add(rootPath);
+  const settingsPath = join(rootPath, ".claude", "settings.local.json");
+  if (!existsSync(settingsPath)) return;
+  try {
+    const existing = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    const storedVersion = existing?._knitHooks?.version ?? 0;
+    if (storedVersion < HOOKS_VERSION) {
+      writeKnitHooks(rootPath, config);
+    }
+  } catch {
+  }
+}
+function getBrain(rootPath) {
+  if (cache && cache.rootPath === rootPath) {
+    return cache;
+  }
+  let autoInitialized = false;
+  const haveCentralized = existsSync(knowledgePath(rootPath));
+  const haveLegacy = existsSync(legacyKnowledgePath(rootPath));
+  if (!haveCentralized) {
+    if (haveLegacy) {
+      migrateLegacyData(rootPath);
+    } else {
+      autoInitialize(rootPath);
+      autoInitialized = true;
+    }
+  }
+  const scan = scanProject(rootPath);
+  const knowledge = buildKnowledge(rootPath, scan);
+  const reverseDeps = buildReverseDependencies(knowledge.importGraph);
+  const projectName = detectProjectName(rootPath);
+  const knowledgeBase = loadKnowledgeBase(knowledgebasePath(rootPath), projectName);
+  const config = {
+    name: projectName,
+    packageManager: scan.packageManager,
+    stack: scan.stack,
+    domains: scan.domains,
+    targetAgent: "claude-code",
+    tokenOptimization: "standard"
+  };
+  writeFileSync(knowledgePath(rootPath), JSON.stringify(knowledge, null, 2), "utf-8");
+  saveKnowledgeBase(knowledgebasePath(rootPath), knowledgeBase);
+  if (!autoInitialized) {
+    maybeRefreshHooks(rootPath, config);
+  }
+  cache = {
+    rootPath,
+    knowledge,
+    reverseDeps,
+    knowledgeBase,
+    config,
+    loadedAt: Date.now(),
+    autoInitialized
+  };
+  return cache;
+}
+function autoInitialize(rootPath) {
+  const scan = scanProject(rootPath);
+  const knowledge = buildKnowledge(rootPath, scan);
+  const projectName = detectProjectName(rootPath);
+  const config = {
+    name: projectName,
+    packageManager: scan.packageManager,
+    stack: scan.stack,
+    domains: scan.domains,
+    targetAgent: "claude-code",
+    tokenOptimization: "standard"
+  };
+  mkdirSync(projectDataDir(rootPath), { recursive: true });
+  mkdirSync(learningsDir(rootPath), { recursive: true });
+  writeProjectClaudeMd(rootPath, config, knowledge);
+  writeKnitHooks(rootPath, config);
+  installAgentsForProject(rootPath, config, knowledge, null).catch((err) => {
+    process.stderr.write(`[knit] agent install background error: ${err?.message ?? err}
+`);
+  });
+  Promise.resolve().then(() => {
+    try {
+      pruneSessionsByAge(rootPath, 90);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      process.stderr.write(`[knit] session prune background error: ${msg}
+`);
+    }
+  });
+  const learningsPath = learningsFilePath(rootPath, projectName);
+  if (!existsSync(learningsPath)) {
+    writeFileSync(learningsPath, generateLearningsContent(config), "utf-8");
+  }
+  const kbPath = knowledgebasePath(rootPath);
+  const kb = loadKnowledgeBase(kbPath, projectName);
+  const entries = readLearnings(learningsPath);
+  importFromMarkdown(kb, entries);
+  saveKnowledgeBase(kbPath, kb);
+  writeFileSync(knowledgePath(rootPath), JSON.stringify(knowledge, null, 2), "utf-8");
+}
+function migrateLegacyData(rootPath) {
+  mkdirSync(projectDataDir(rootPath), { recursive: true });
+  mkdirSync(learningsDir(rootPath), { recursive: true });
+  copyIfExists(legacyKnowledgePath(rootPath), knowledgePath(rootPath));
+  copyIfExists(legacyKnowledgebasePath(rootPath), knowledgebasePath(rootPath));
+  copyIfExists(legacyTeamsPath(rootPath), teamsPath(rootPath));
+  const legacyLearn = legacyLearningsDir(rootPath);
+  if (existsSync(legacyLearn)) {
+    for (const file of readdirSync(legacyLearn)) {
+      const src = join(legacyLearn, file);
+      const dst = join(learningsDir(rootPath), file);
+      try {
+        if (statSync(src).isFile() && !existsSync(dst)) {
+          copyFileSync(src, dst);
+        }
+      } catch {
+      }
+    }
+  }
+  const breadcrumb = migrationBreadcrumbPath(rootPath);
+  const newPath = projectDataDir(rootPath);
+  if (!existsSync(breadcrumb) && existsSync(legacyClaudeDir(rootPath))) {
+    const note = `Knit data migrated to ~/.knit/ on ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.
+
+Centralized location for this project:
+  ${newPath}
+
+The legacy files in this .claude/ directory are no longer read by engram and
+can be deleted at your discretion. Future learnings, knowledge indexes, and
+session memory live in the new path.
+`;
+    try {
+      writeFileSync(breadcrumb, note, "utf-8");
+    } catch {
+    }
+  }
+}
+function writeProjectClaudeMd(rootPath, config, knowledge) {
+  const claudeMdPath = join(rootPath, "CLAUDE.md");
+  const block = generateClaudeMd(config, knowledge);
+  if (!existsSync(claudeMdPath)) {
+    writeFileSync(claudeMdPath, block, "utf-8");
+    return;
+  }
+  const existing = readFileSync(claudeMdPath, "utf-8");
+  if (existing.includes(KNIT_MARKER_START)) {
+    const { content } = spliceKnitBlock(existing, block);
+    writeFileSync(claudeMdPath, content, "utf-8");
+    return;
+  }
+  const sidecarDir = join(rootPath, ".claude");
+  const sidecarPath = join(sidecarDir, "KNIT.md");
+  mkdirSync(sidecarDir, { recursive: true });
+  const sidecar = `<!-- This file is engram's per-project workflow. -->
+<!-- Your CLAUDE.md exists without engram markers, so engram wrote here instead of clobbering it. -->
+<!-- To include this content in CLAUDE.md, add: @.claude/KNIT.md -->
+
+${block}`;
+  writeFileSync(sidecarPath, sidecar, "utf-8");
+}
+function copyIfExists(src, dst) {
+  if (existsSync(src) && !existsSync(dst)) {
+    mkdirSync(dirname(dst), { recursive: true });
+    copyFileSync(src, dst);
+  }
+}
+function writeKnitHooks(rootPath, config) {
+  const claudeDir = join(rootPath, ".claude");
+  const settingsPath = join(claudeDir, "settings.local.json");
+  const fresh = generateSettings(config, rootPath);
+  if (!existsSync(settingsPath)) {
+    mkdirSync(claudeDir, { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(fresh, null, 2), "utf-8");
+    return;
+  }
+  let existing;
+  try {
+    const parsed = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return;
+    }
+    existing = parsed;
+  } catch {
+    return;
+  }
+  if ("_knitHooks" in existing) {
+    mkdirSync(claudeDir, { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(fresh, null, 2), "utf-8");
+    return;
+  }
+  const userHooksRaw = existing.hooks;
+  let userHooks;
+  if (userHooksRaw === void 0) {
+    userHooks = {};
+  } else if (userHooksRaw && typeof userHooksRaw === "object" && !Array.isArray(userHooksRaw)) {
+    for (const v of Object.values(userHooksRaw)) {
+      if (!Array.isArray(v)) return;
+    }
+    userHooks = { ...userHooksRaw };
+  } else {
+    return;
+  }
+  for (const event of Object.keys(fresh.hooks)) {
+    const userEntries = Array.isArray(userHooks[event]) ? userHooks[event] : [];
+    const preserved = userEntries.filter((entry) => {
+      return !(entry && typeof entry === "object" && entry._knitOwned === true);
+    });
+    userHooks[event] = [...preserved, ...fresh.hooks[event]];
+  }
+  const merged = {
+    ...existing,
+    hooks: userHooks,
+    _knitHooks: { ...fresh._knitHooks, merged: true }
+  };
+  mkdirSync(claudeDir, { recursive: true });
+  writeFileSync(settingsPath, JSON.stringify(merged, null, 2), "utf-8");
+}
+function detectProjectName(rootPath) {
+  let name = basename(rootPath);
+  try {
+    const pkg = JSON.parse(readFileSync(join(rootPath, "package.json"), "utf-8"));
+    if (pkg.name) name = pkg.name;
+  } catch {
+  }
+  return name;
+}
+function refreshBrain(rootPath) {
+  cache = null;
+  return getBrain(rootPath);
+}
+function detectProjectRoot() {
+  try {
+    return execSync("git rev-parse --show-toplevel 2>/dev/null", { encoding: "utf-8" }).trim();
+  } catch {
+    return process.cwd();
+  }
+}
+
+export {
+  getBrain,
+  refreshBrain,
+  detectProjectRoot
+};