codecortex-ai 0.1.0

package/dist/chunk-F4WTE7R3.js

@@ -0,0 +1,962 @@
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/tools/read.ts
+import { z } from "zod";
+
+// src/utils/files.ts
+import { readFile as fsRead, writeFile as fsWrite, mkdir, readdir, stat } from "fs/promises";
+import { existsSync, createWriteStream } from "fs";
+import { join, dirname } from "path";
+async function readFile(path) {
+  try {
+    return await fsRead(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function writeFile(path, content) {
+  await ensureDir(dirname(path));
+  await fsWrite(path, content, "utf-8");
+}
+async function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+}
+async function listFiles(dir, extension) {
+  if (!existsSync(dir)) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      if (!extension || entry.name.endsWith(extension)) {
+        files.push(join(dir, entry.name));
+      }
+    }
+  }
+  return files;
+}
+function cortexPath(projectRoot, ...segments) {
+  return join(projectRoot, ".codecortex", ...segments);
+}
+async function writeJsonStream(path, obj, arrayKey) {
+  await ensureDir(dirname(path));
+  const arr = obj[arrayKey];
+  const stream = createWriteStream(path);
+  stream.setMaxListeners(0);
+  let streamError = null;
+  stream.on("error", (err) => {
+    streamError = err;
+  });
+  function waitDrain() {
+    return new Promise((resolve) => stream.once("drain", resolve));
+  }
+  const header = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (k !== arrayKey) header[k] = v;
+  }
+  const headerJson = JSON.stringify(header);
+  stream.write(headerJson.slice(0, -1) + `,"${arrayKey}":[`);
+  const BATCH_SIZE = 1e3;
+  for (let i = 0; i < arr.length; i += BATCH_SIZE) {
+    if (streamError) throw streamError;
+    const end = Math.min(i + BATCH_SIZE, arr.length);
+    const chunks = [];
+    for (let j = i; j < end; j++) {
+      chunks.push((j > 0 ? "," : "") + JSON.stringify(arr[j]));
+    }
+    if (!stream.write(chunks.join(""))) {
+      await waitDrain();
+    }
+  }
+  stream.write("]}");
+  return new Promise((resolve, reject) => {
+    if (streamError) {
+      reject(streamError);
+      return;
+    }
+    stream.on("finish", resolve);
+    stream.on("error", reject);
+    stream.end();
+  });
+}
+
+// src/utils/yaml.ts
+import { parse, stringify } from "yaml";
+function parseYaml(content) {
+  return parse(content);
+}
+function stringifyYaml(data) {
+  return stringify(data, { lineWidth: 120 });
+}
+
+// src/core/manifest.ts
+async function readManifest(projectRoot) {
+  const content = await readFile(cortexPath(projectRoot, "cortex.yaml"));
+  if (!content) return null;
+  return parseYaml(content);
+}
+async function writeManifest(projectRoot, manifest) {
+  const content = stringifyYaml(manifest);
+  await writeFile(cortexPath(projectRoot, "cortex.yaml"), content);
+}
+function createManifest(opts) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: "1.0.0",
+    project: opts.project,
+    root: opts.root,
+    generated: now,
+    lastUpdated: now,
+    languages: opts.languages,
+    totalFiles: opts.totalFiles,
+    totalSymbols: opts.totalSymbols,
+    totalModules: opts.totalModules,
+    tiers: {
+      hot: ["cortex.yaml", "constitution.md", "overview.md", "graph.json", "symbols.json", "temporal.json"],
+      warm: ["modules/"],
+      cold: ["decisions/", "sessions/", "patterns.md"]
+    }
+  };
+}
+async function updateManifest(projectRoot, updates) {
+  const manifest = await readManifest(projectRoot);
+  if (!manifest) return null;
+  const updated = {
+    ...manifest,
+    ...updates,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeManifest(projectRoot, updated);
+  return updated;
+}
+
+// src/core/graph.ts
+import { createWriteStream as createWriteStream2 } from "fs";
+import { dirname as dirname2 } from "path";
+async function readGraph(projectRoot) {
+  const content = await readFile(cortexPath(projectRoot, "graph.json"));
+  if (!content) return null;
+  return JSON.parse(content);
+}
+async function writeGraph(projectRoot, graph) {
+  const path = cortexPath(projectRoot, "graph.json");
+  await ensureDir(dirname2(path));
+  const stream = createWriteStream2(path);
+  stream.setMaxListeners(0);
+  function waitDrain() {
+    return new Promise((resolve) => stream.once("drain", resolve));
+  }
+  async function writeArray(arr) {
+    stream.write("[");
+    const BATCH = 1e3;
+    for (let i = 0; i < arr.length; i += BATCH) {
+      const end = Math.min(i + BATCH, arr.length);
+      const chunks = [];
+      for (let j = i; j < end; j++) {
+        chunks.push((j > 0 ? "," : "") + JSON.stringify(arr[j]));
+      }
+      if (!stream.write(chunks.join(""))) await waitDrain();
+    }
+    stream.write("]");
+  }
+  stream.write(`{"generated":${JSON.stringify(graph.generated)},"modules":`);
+  await writeArray(graph.modules);
+  stream.write(',"imports":');
+  await writeArray(graph.imports);
+  stream.write(',"calls":');
+  await writeArray(graph.calls);
+  stream.write(`,"entryPoints":${JSON.stringify(graph.entryPoints)}`);
+  stream.write(`,"externalDeps":${JSON.stringify(graph.externalDeps)}`);
+  stream.write("}");
+  return new Promise((resolve, reject) => {
+    stream.on("finish", resolve);
+    stream.on("error", reject);
+    stream.end();
+  });
+}
+function buildGraph(opts) {
+  return {
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    modules: opts.modules,
+    imports: opts.imports,
+    calls: opts.calls,
+    entryPoints: opts.entryPoints,
+    externalDeps: opts.externalDeps
+  };
+}
+function getModuleDependencies(graph, moduleName) {
+  const moduleFiles = new Set(
+    graph.modules.find((m) => m.name === moduleName)?.files || []
+  );
+  return {
+    imports: graph.imports.filter((e) => moduleFiles.has(e.source)),
+    importedBy: graph.imports.filter((e) => moduleFiles.has(e.target)),
+    calls: graph.calls.filter((e) => moduleFiles.has(e.file))
+  };
+}
+function getMostImportedFiles(graph, limit = 10) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const edge of graph.imports) {
+    counts.set(edge.target, (counts.get(edge.target) || 0) + 1);
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit).map(([file, importCount]) => ({ file, importCount }));
+}
+function enrichCouplingWithImports(graph, coupling) {
+  const importPairs = /* @__PURE__ */ new Set();
+  for (const edge of graph.imports) {
+    importPairs.add([edge.source, edge.target].sort().join("|"));
+  }
+  for (const pair of coupling) {
+    const key = [pair.fileA, pair.fileB].sort().join("|");
+    pair.hasImport = importPairs.has(key);
+  }
+}
+
+// src/utils/markdown.ts
+function generateModuleDoc(analysis) {
+  const lines = [
+    `# Module: ${analysis.name}`,
+    "",
+    `## Purpose`,
+    analysis.purpose,
+    "",
+    `## Data Flow`,
+    analysis.dataFlow,
+    "",
+    `## Public API`,
+    ...analysis.publicApi.map((api) => `- \`${api}\``),
+    "",
+    `## Dependencies`,
+    ...analysis.dependencies.map((dep) => `- ${dep}`)
+  ];
+  if (analysis.gotchas.length > 0) {
+    lines.push("", `## Gotchas`, ...analysis.gotchas.map((g) => `- ${g}`));
+  }
+  if (analysis.temporalSignals) {
+    const t = analysis.temporalSignals;
+    lines.push(
+      "",
+      `## Temporal Signals`,
+      `- **Churn:** ${t.churn}`,
+      `- **Coupled with:** ${t.coupledWith.join(", ") || "none"}`,
+      `- **Stability:** ${t.stability}`
+    );
+    if (t.bugHistory.length > 0) {
+      lines.push(`- **Bug history:** ${t.bugHistory.join("; ")}`);
+    }
+    lines.push(`- **Last changed:** ${t.lastChanged}`);
+  }
+  return lines.join("\n") + "\n";
+}
+function generateDecisionDoc(decision) {
+  const lines = [
+    `# Decision: ${decision.title}`,
+    "",
+    `**Date:** ${decision.date}`,
+    `**Status:** ${decision.status}`,
+    "",
+    `## Context`,
+    decision.context,
+    "",
+    `## Decision`,
+    decision.decision
+  ];
+  if (decision.alternatives.length > 0) {
+    lines.push("", `## Alternatives Considered`, ...decision.alternatives.map((a) => `- ${a}`));
+  }
+  if (decision.consequences.length > 0) {
+    lines.push("", `## Consequences`, ...decision.consequences.map((c) => `- ${c}`));
+  }
+  return lines.join("\n") + "\n";
+}
+function generatePatternEntry(pattern) {
+  const lines = [
+    `### ${pattern.name}`,
+    "",
+    pattern.description,
+    "",
+    "```",
+    pattern.example,
+    "```"
+  ];
+  if (pattern.files.length > 0) {
+    lines.push("", `Files: ${pattern.files.map((f) => `\`${f}\``).join(", ")}`);
+  }
+  return lines.join("\n");
+}
+
+// src/core/modules.ts
+async function readModuleDoc(projectRoot, moduleName) {
+  return readFile(cortexPath(projectRoot, "modules", `${moduleName}.md`));
+}
+async function writeModuleDoc(projectRoot, analysis) {
+  const dir = cortexPath(projectRoot, "modules");
+  await ensureDir(dir);
+  const content = generateModuleDoc(analysis);
+  await writeFile(cortexPath(projectRoot, "modules", `${analysis.name}.md`), content);
+}
+async function listModuleDocs(projectRoot) {
+  const dir = cortexPath(projectRoot, "modules");
+  const files = await listFiles(dir, ".md");
+  return files.map((f) => {
+    const name = f.split("/").pop() || "";
+    return name.replace(".md", "");
+  });
+}
+function buildAnalysisPrompt(moduleName, sourceFiles) {
+  const fileList = sourceFiles.map((f) => `### ${f.path}
+\`\`\`
+${f.content}
+\`\`\``).join("\n\n");
+  return `Analyze the "${moduleName}" module. Return a JSON object with this exact structure:
+
+{
+  "name": "${moduleName}",
+  "purpose": "One paragraph describing what this module does and why it exists",
+  "dataFlow": "How data flows through this module \u2014 inputs, transformations, outputs",
+  "publicApi": ["list", "of", "exported", "functions", "and", "types"],
+  "gotchas": ["Things that are surprising or could cause bugs"],
+  "dependencies": ["What this module depends on and why"]
+}
+
+Source files:
+
+${fileList}`;
+}
+
+// src/core/sessions.ts
+async function writeSession(projectRoot, session) {
+  const dir = cortexPath(projectRoot, "sessions");
+  await ensureDir(dir);
+  const lines = [
+    `# Session: ${session.date}`,
+    "",
+    `**ID:** ${session.id}`,
+    session.previousSession ? `**Previous:** ${session.previousSession}` : null,
+    "",
+    `## Summary`,
+    session.summary,
+    "",
+    `## Files Changed`,
+    ...session.filesChanged.map((f) => `- \`${f}\``),
+    "",
+    `## Modules Affected`,
+    ...session.modulesAffected.map((m) => `- ${m}`)
+  ].filter(Boolean);
+  if (session.decisionsRecorded.length > 0) {
+    lines.push("", `## Decisions Recorded`, ...session.decisionsRecorded.map((d) => `- ${d}`));
+  }
+  await writeFile(cortexPath(projectRoot, "sessions", `${session.id}.md`), lines.join("\n") + "\n");
+}
+async function readSession(projectRoot, id) {
+  return readFile(cortexPath(projectRoot, "sessions", `${id}.md`));
+}
+async function listSessions(projectRoot) {
+  const dir = cortexPath(projectRoot, "sessions");
+  const files = await listFiles(dir, ".md");
+  return files.map((f) => (f.split("/").pop() || "").replace(".md", "")).sort().reverse();
+}
+async function getLatestSession(projectRoot) {
+  const sessions = await listSessions(projectRoot);
+  return sessions[0] ?? null;
+}
+function createSession(opts) {
+  const now = /* @__PURE__ */ new Date();
+  const id = now.toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  return {
+    id,
+    date: now.toISOString(),
+    previousSession: opts.previousSession,
+    filesChanged: opts.filesChanged,
+    modulesAffected: opts.modulesAffected,
+    decisionsRecorded: opts.decisionsRecorded || [],
+    summary: opts.summary
+  };
+}
+
+// src/core/decisions.ts
+async function readDecision(projectRoot, id) {
+  return readFile(cortexPath(projectRoot, "decisions", `${id}.md`));
+}
+async function writeDecision(projectRoot, decision) {
+  const dir = cortexPath(projectRoot, "decisions");
+  await ensureDir(dir);
+  const content = generateDecisionDoc(decision);
+  await writeFile(cortexPath(projectRoot, "decisions", `${decision.id}.md`), content);
+}
+async function listDecisions(projectRoot) {
+  const dir = cortexPath(projectRoot, "decisions");
+  const files = await listFiles(dir, ".md");
+  return files.map((f) => {
+    const name = f.split("/").pop() || "";
+    return name.replace(".md", "");
+  });
+}
+function createDecision(input) {
+  const id = input.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+  return {
+    id,
+    date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0] ?? "",
+    title: input.title,
+    context: input.context,
+    decision: input.decision,
+    alternatives: input.alternatives || [],
+    consequences: input.consequences || [],
+    status: "accepted"
+  };
+}
+
+// src/core/search.ts
+import { readdir as readdir2 } from "fs/promises";
+import { join as join2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+async function searchKnowledge(projectRoot, query) {
+  const cortexRoot = cortexPath(projectRoot);
+  if (!existsSync2(cortexRoot)) return [];
+  const results = [];
+  const queryLower = query.toLowerCase();
+  const allFiles = await getAllCortexFiles(cortexRoot);
+  for (const filePath of allFiles) {
+    const content = await readFile(filePath);
+    if (!content) continue;
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line?.toLowerCase().includes(queryLower)) {
+        const start = Math.max(0, i - 2);
+        const end = Math.min(lines.length - 1, i + 2);
+        const context = lines.slice(start, end + 1).join("\n");
+        results.push({
+          file: filePath.replace(cortexRoot + "/", ""),
+          line: i + 1,
+          content: line.trim(),
+          context
+        });
+      }
+    }
+  }
+  return results;
+}
+async function getAllCortexFiles(dir) {
+  const files = [];
+  if (!existsSync2(dir)) return files;
+  const entries = await readdir2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      const subFiles = await getAllCortexFiles(fullPath);
+      files.push(...subFiles);
+    } else if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".json") || entry.name.endsWith(".yaml"))) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+// src/mcp/tools/read.ts
+function textResult(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function registerReadTools(server, projectRoot) {
+  server.registerTool(
+    "get_project_overview",
+    {
+      description: "Get the full project overview: constitution (architecture, risk map, available knowledge), overview narrative, and dependency graph summary. This is the starting point for understanding any codebase. Always call this first.",
+      inputSchema: {}
+    },
+    async () => {
+      const constitution = await readFile(cortexPath(projectRoot, "constitution.md"));
+      const overview = await readFile(cortexPath(projectRoot, "overview.md"));
+      const manifest = await readManifest(projectRoot);
+      const graph = await readGraph(projectRoot);
+      let graphSummary = null;
+      if (graph) {
+        graphSummary = {
+          modules: graph.modules.length,
+          imports: graph.imports.length,
+          entryPoints: graph.entryPoints,
+          mostImported: getMostImportedFiles(graph, 5)
+        };
+      }
+      return textResult({
+        constitution,
+        overview,
+        manifest,
+        graphSummary
+      });
+    }
+  );
+  server.registerTool(
+    "get_module_context",
+    {
+      description: "Get deep context for a specific module: purpose, data flow, public API, gotchas, dependencies, and temporal signals (churn, coupling, bug history). Use after get_project_overview when you need to work on a specific module.",
+      inputSchema: {
+        name: z.string().describe('Module name (e.g., "scoring", "api", "indexer")')
+      }
+    },
+    async ({ name }) => {
+      const doc = await readModuleDoc(projectRoot, name);
+      if (!doc) {
+        const available = await listModuleDocs(projectRoot);
+        return textResult({ found: false, name, available, message: `Module "${name}" not found. Available modules: ${available.join(", ")}` });
+      }
+      const graph = await readGraph(projectRoot);
+      let deps = null;
+      if (graph) {
+        deps = getModuleDependencies(graph, name);
+      }
+      return textResult({ found: true, name, doc, dependencies: deps });
+    }
+  );
+  server.registerTool(
+    "get_session_briefing",
+    {
+      description: "Get a briefing of what changed since the last session. Shows files changed, modules affected, and decisions recorded. Use at the start of a new session to catch up.",
+      inputSchema: {}
+    },
+    async () => {
+      const latestId = await getLatestSession(projectRoot);
+      if (!latestId) {
+        return textResult({ hasSession: false, message: "No previous sessions recorded." });
+      }
+      const session = await readSession(projectRoot, latestId);
+      const allSessions = await listSessions(projectRoot);
+      return textResult({
+        hasSession: true,
+        latest: session,
+        totalSessions: allSessions.length,
+        recentSessionIds: allSessions.slice(0, 5)
+      });
+    }
+  );
+  server.registerTool(
+    "search_knowledge",
+    {
+      description: "Search across all CodeCortex knowledge files (modules, decisions, patterns, sessions, constitution) for a keyword or phrase. Returns matching lines with context.",
+      inputSchema: {
+        query: z.string().describe("Search term or phrase")
+      }
+    },
+    async ({ query }) => {
+      const results = await searchKnowledge(projectRoot, query);
+      return textResult({
+        query,
+        totalResults: results.length,
+        results: results.slice(0, 20)
+      });
+    }
+  );
+  server.registerTool(
+    "get_decision_history",
+    {
+      description: "Get architectural decision records. Shows WHY the codebase is built the way it is. Filter by topic keyword.",
+      inputSchema: {
+        topic: z.string().optional().describe("Optional keyword to filter decisions")
+      }
+    },
+    async ({ topic }) => {
+      const ids = await listDecisions(projectRoot);
+      const decisions = [];
+      for (const id of ids) {
+        const content = await readDecision(projectRoot, id);
+        if (content) {
+          if (!topic || content.toLowerCase().includes(topic.toLowerCase())) {
+            decisions.push(content);
+          }
+        }
+      }
+      return textResult({
+        total: decisions.length,
+        topic: topic || "all",
+        decisions
+      });
+    }
+  );
+  server.registerTool(
+    "get_dependency_graph",
+    {
+      description: "Get the import/export dependency graph. Shows which files import which, external dependencies, and entry points. Optionally filter to a specific file or module.",
+      inputSchema: {
+        file: z.string().optional().describe("Filter to edges involving this file path"),
+        module: z.string().optional().describe("Filter to edges involving this module name")
+      }
+    },
+    async ({ file, module }) => {
+      const graph = await readGraph(projectRoot);
+      if (!graph) return textResult({ found: false, message: "No graph data. Run codecortex init first." });
+      if (module) {
+        const deps = getModuleDependencies(graph, module);
+        return textResult({ module, ...deps });
+      }
+      if (file) {
+        const imports = graph.imports.filter((e) => e.source.includes(file) || e.target.includes(file));
+        const calls = graph.calls.filter((e) => e.file.includes(file));
+        return textResult({ file, imports, calls });
+      }
+      return textResult(graph);
+    }
+  );
+  server.registerTool(
+    "lookup_symbol",
+    {
+      description: "Look up a symbol (function, class, type, interface, const) by name. Returns file path, line numbers, signature, and whether it's exported. Use to find where something is defined.",
+      inputSchema: {
+        name: z.string().describe("Symbol name to search for"),
+        kind: z.enum(["function", "class", "interface", "type", "const", "enum", "method", "property", "variable"]).optional().describe("Filter by symbol kind"),
+        file: z.string().optional().describe("Filter by file path (partial match)")
+      }
+    },
+    async ({ name, kind, file }) => {
+      const content = await readFile(cortexPath(projectRoot, "symbols.json"));
+      if (!content) return textResult({ found: false, message: "No symbol index. Run codecortex init first." });
+      const index = JSON.parse(content);
+      let matches = index.symbols.filter(
+        (s) => s.name.toLowerCase().includes(name.toLowerCase())
+      );
+      if (kind) matches = matches.filter((s) => s.kind === kind);
+      if (file) matches = matches.filter((s) => s.file.includes(file));
+      return textResult({
+        query: { name, kind, file },
+        totalMatches: matches.length,
+        symbols: matches.slice(0, 30)
+      });
+    }
+  );
+  server.registerTool(
+    "get_change_coupling",
+    {
+      description: "CRITICAL: Call this BEFORE editing any file. Shows files that historically change together. If file A is coupled with file B, editing A without B will likely cause a bug. Hidden couplings (no import between files) are especially dangerous.",
+      inputSchema: {
+        file: z.string().optional().describe("Show coupling for this specific file"),
+        minStrength: z.number().min(0).max(1).default(0.3).describe("Minimum coupling strength (0-1). Default 0.3.")
+      }
+    },
+    async ({ file, minStrength }) => {
+      const content = await readFile(cortexPath(projectRoot, "temporal.json"));
+      if (!content) return textResult({ found: false, message: "No temporal data. Run codecortex init first." });
+      const temporal = JSON.parse(content);
+      let coupling = temporal.coupling.filter((c) => c.strength >= minStrength);
+      if (file) {
+        coupling = coupling.filter(
+          (c) => c.fileA.includes(file) || c.fileB.includes(file)
+        );
+      }
+      return textResult({
+        file: file || "all",
+        minStrength,
+        couplings: coupling,
+        warning: coupling.filter((c) => !c.hasImport).length > 0 ? "HIDDEN DEPENDENCIES FOUND \u2014 some coupled files have NO import between them" : null
+      });
+    }
+  );
+  server.registerTool(
+    "get_hotspots",
+    {
+      description: "Get files ranked by risk: change frequency (churn), coupling count, and bug history. Volatile files with many couplings need extra care when editing.",
+      inputSchema: {
+        limit: z.number().int().min(1).max(50).default(10).describe("Number of files to return")
+      }
+    },
+    async ({ limit }) => {
+      const content = await readFile(cortexPath(projectRoot, "temporal.json"));
+      if (!content) return textResult({ found: false, message: "No temporal data. Run codecortex init first." });
+      const temporal = JSON.parse(content);
+      const riskMap = /* @__PURE__ */ new Map();
+      for (const h of temporal.hotspots) {
+        riskMap.set(h.file, { churn: h.changes, couplings: 0, bugs: 0, risk: h.changes });
+      }
+      for (const c of temporal.coupling) {
+        for (const f of [c.fileA, c.fileB]) {
+          const entry = riskMap.get(f) || { churn: 0, couplings: 0, bugs: 0, risk: 0 };
+          entry.couplings++;
+          entry.risk += c.strength * 2;
+          riskMap.set(f, entry);
+        }
+      }
+      for (const b of temporal.bugHistory) {
+        const entry = riskMap.get(b.file) || { churn: 0, couplings: 0, bugs: 0, risk: 0 };
+        entry.bugs = b.fixCommits;
+        entry.risk += b.fixCommits * 3;
+        riskMap.set(b.file, entry);
+      }
+      const ranked = [...riskMap.entries()].sort((a, b) => b[1].risk - a[1].risk).slice(0, limit).map(([file, data]) => ({ file, ...data, risk: Math.round(data.risk * 100) / 100 }));
+      return textResult({
+        period: `${temporal.periodDays} days`,
+        totalCommits: temporal.totalCommits,
+        hotspots: ranked
+      });
+    }
+  );
+}
+
+// src/mcp/tools/write.ts
+import { z as z3 } from "zod";
+
+// src/types/schema.ts
+import { z as z2 } from "zod";
+var ModuleAnalysisSchema = z2.object({
+  name: z2.string(),
+  purpose: z2.string(),
+  dataFlow: z2.string(),
+  publicApi: z2.array(z2.string()),
+  gotchas: z2.array(z2.string()),
+  dependencies: z2.array(z2.string())
+});
+var DecisionInputSchema = z2.object({
+  title: z2.string(),
+  context: z2.string(),
+  decision: z2.string(),
+  alternatives: z2.array(z2.string()).default([]),
+  consequences: z2.array(z2.string()).default([])
+});
+var PatternInputSchema = z2.object({
+  name: z2.string(),
+  description: z2.string(),
+  example: z2.string(),
+  files: z2.array(z2.string()).default([])
+});
+var FeedbackInputSchema = z2.object({
+  file: z2.string(),
+  issue: z2.string(),
+  reporter: z2.string().default("agent")
+});
+
+// src/core/patterns.ts
+async function readPatterns(projectRoot) {
+  return readFile(cortexPath(projectRoot, "patterns.md"));
+}
+async function addPattern(projectRoot, pattern) {
+  const existing = await readPatterns(projectRoot) || "# Coding Patterns\n";
+  const nameRegex = new RegExp(`### ${escapeRegex(pattern.name)}`, "i");
+  if (nameRegex.test(existing)) {
+    const entry2 = generatePatternEntry(pattern);
+    const sectionRegex = new RegExp(
+      `### ${escapeRegex(pattern.name)}[\\s\\S]*?(?=### |$)`,
+      "i"
+    );
+    const updated = existing.replace(sectionRegex, entry2 + "\n\n");
+    await writeFile(cortexPath(projectRoot, "patterns.md"), updated);
+    return "updated";
+  }
+  const entry = generatePatternEntry(pattern);
+  const content = existing.trimEnd() + "\n\n" + entry + "\n";
+  await writeFile(cortexPath(projectRoot, "patterns.md"), content);
+  return "added";
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/mcp/tools/write.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join3 } from "path";
+function textResult2(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function registerWriteTools(server, projectRoot) {
+  server.registerTool(
+    "analyze_module",
+    {
+      description: "Prepares a module for analysis. Returns the source files and a structured prompt. You should read the source files, analyze them, then call save_module_analysis with the result.",
+      inputSchema: {
+        name: z3.string().describe('Module name (e.g., "scoring", "api")')
+      }
+    },
+    async ({ name }) => {
+      const graph = await readGraph(projectRoot);
+      if (!graph) {
+        return textResult2({ error: "No graph data. Run codecortex init first." });
+      }
+      const module = graph.modules.find((m) => m.name === name);
+      if (!module) {
+        const available = graph.modules.map((m) => m.name);
+        return textResult2({ error: `Module "${name}" not found`, available });
+      }
+      const sourceFiles = [];
+      for (const filePath of module.files) {
+        try {
+          const content = await readFile2(join3(projectRoot, filePath), "utf-8");
+          sourceFiles.push({ path: filePath, content });
+        } catch {
+        }
+      }
+      const prompt = buildAnalysisPrompt(name, sourceFiles);
+      return textResult2({
+        module: name,
+        files: module.files,
+        prompt,
+        instruction: "Analyze the source files above and call save_module_analysis with the JSON result."
+      });
+    }
+  );
+  server.registerTool(
+    "save_module_analysis",
+    {
+      description: "Save the result of a module analysis. Provide the structured analysis (purpose, dataFlow, publicApi, gotchas, dependencies) and it will be persisted to modules/*.md.",
+      inputSchema: {
+        analysis: ModuleAnalysisSchema.describe("The structured module analysis")
+      }
+    },
+    async ({ analysis }) => {
+      const moduleAnalysis = {
+        ...analysis
+      };
+      const temporalContent = await readFile(cortexPath(projectRoot, "temporal.json"));
+      if (temporalContent) {
+        const temporal = JSON.parse(temporalContent);
+        const hotspot = temporal.hotspots?.find(
+          (h) => h.file.includes(`/${analysis.name}/`) || h.file.includes(`${analysis.name}.`)
+        );
+        const couplings = temporal.coupling?.filter(
+          (c) => c.fileA.includes(`/${analysis.name}/`) || c.fileB.includes(`/${analysis.name}/`)
+        ) || [];
+        const bugs = temporal.bugHistory?.filter(
+          (b) => b.file.includes(`/${analysis.name}/`)
+        ) || [];
+        if (hotspot || couplings.length > 0 || bugs.length > 0) {
+          moduleAnalysis.temporalSignals = {
+            churn: hotspot ? `${hotspot.changes} changes (${hotspot.stability})` : "unknown",
+            coupledWith: couplings.map((c) => {
+              const other = c.fileA.includes(`/${analysis.name}/`) ? c.fileB : c.fileA;
+              return `${other} (${c.cochanges} co-changes)`;
+            }),
+            stability: hotspot?.stability || "unknown",
+            bugHistory: bugs.flatMap((b) => b.lessons),
+            lastChanged: hotspot?.lastChanged || "unknown"
+          };
+        }
+      }
+      await writeModuleDoc(projectRoot, moduleAnalysis);
+      return textResult2({
+        saved: true,
+        module: analysis.name,
+        path: `.codecortex/modules/${analysis.name}.md`
+      });
+    }
+  );
+  server.registerTool(
+    "record_decision",
+    {
+      description: "Record an architectural decision. Documents WHY something is built a certain way, what alternatives were considered, and consequences. Use whenever a non-obvious technical choice is made.",
+      inputSchema: {
+        title: z3.string().describe('Decision title (e.g., "Use tree-sitter for parsing")'),
+        context: z3.string().describe("What situation led to this decision"),
+        decision: z3.string().describe("What was decided"),
+        alternatives: z3.array(z3.string()).default([]).describe("What other options were considered"),
+        consequences: z3.array(z3.string()).default([]).describe("Expected consequences of this decision")
+      }
+    },
+    async ({ title, context, decision, alternatives, consequences }) => {
+      const record = createDecision({ title, context, decision, alternatives, consequences });
+      await writeDecision(projectRoot, record);
+      return textResult2({
+        recorded: true,
+        id: record.id,
+        path: `.codecortex/decisions/${record.id}.md`
+      });
+    }
+  );
+  server.registerTool(
+    "update_patterns",
+    {
+      description: 'Add or update a coding pattern. Patterns document HOW code is written in this project (naming conventions, error handling, testing approaches). Returns "added", "updated", or "noop".',
+      inputSchema: {
+        name: z3.string().describe('Pattern name (e.g., "Error handling in API routes")'),
+        description: z3.string().describe("What the pattern is and when to use it"),
+        example: z3.string().describe("Code example showing the pattern"),
+        files: z3.array(z3.string()).default([]).describe("Files where this pattern is used")
+      }
+    },
+    async ({ name, description, example, files }) => {
+      const result = await addPattern(projectRoot, { name, description, example, files });
+      return textResult2({
+        action: result,
+        pattern: name,
+        path: ".codecortex/patterns.md"
+      });
+    }
+  );
+  server.registerTool(
+    "report_feedback",
+    {
+      description: "Report incorrect or outdated knowledge. If you discover that a module doc, decision, or pattern is wrong, report it here. The feedback will be stored and used in the next analysis cycle.",
+      inputSchema: {
+        file: z3.string().describe('Which knowledge file is incorrect (e.g., "modules/scoring.md")'),
+        issue: z3.string().describe("What is wrong or outdated"),
+        reporter: z3.string().default("agent").describe("Who is reporting (default: agent)")
+      }
+    },
+    async ({ file, issue, reporter }) => {
+      const dir = cortexPath(projectRoot, "feedback");
+      await ensureDir(dir);
+      const entry = {
+        date: (/* @__PURE__ */ new Date()).toISOString(),
+        file,
+        issue,
+        reporter
+      };
+      const feedbackPath = cortexPath(projectRoot, "feedback", "log.json");
+      const existing = await readFile(feedbackPath);
+      const entries = existing ? JSON.parse(existing) : [];
+      entries.push(entry);
+      await writeFile(feedbackPath, JSON.stringify(entries, null, 2));
+      return textResult2({
+        recorded: true,
+        totalFeedback: entries.length,
+        message: "Feedback recorded. Will be addressed in next codecortex update."
+      });
+    }
+  );
+}
+
+// src/mcp/server.ts
+function createServer(projectRoot) {
+  const server = new McpServer({
+    name: "codecortex",
+    version: "0.1.0",
+    description: "Persistent codebase knowledge layer. Pre-digested architecture, symbols, coupling, and patterns served to AI agents."
+  });
+  registerReadTools(server, projectRoot);
+  registerWriteTools(server, projectRoot);
+  return server;
+}
+async function startServer(projectRoot) {
+  const server = createServer(projectRoot);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(`CodeCortex MCP server running on stdio (root: ${projectRoot})`);
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const root = process.cwd();
+  startServer(root).catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+  });
+}
+
+export {
+  readFile,
+  writeFile,
+  ensureDir,
+  cortexPath,
+  writeJsonStream,
+  readManifest,
+  writeManifest,
+  createManifest,
+  updateManifest,
+  writeGraph,
+  buildGraph,
+  enrichCouplingWithImports,
+  listModuleDocs,
+  listDecisions,
+  writeSession,
+  listSessions,
+  getLatestSession,
+  createSession,
+  createServer,
+  startServer
+};
+//# sourceMappingURL=chunk-F4WTE7R3.js.map