ctxo-mcp 0.2.0

package/dist/index.js

@@ -0,0 +1,786 @@
+#!/usr/bin/env node
+import {
+  RevertDetector,
+  SimpleGitAdapter,
+  SqliteStorageAdapter
+} from "./chunk-P7JUSY3I.js";
+import {
+  DetailLevelSchema,
+  JsonIndexReader
+} from "./chunk-54ETLIQX.js";
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z6 } from "zod";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+// src/core/masking/masking-pipeline.ts
+var DEFAULT_PATTERNS = [
+  // AWS Access Key IDs (AKIA...)
+  { regex: /AKIA[0-9A-Z]{16}/g, label: "AWS_KEY" },
+  // AWS Secret Access Keys (40 char base64 containing / or + — excludes hex-only git hashes)
+  { regex: /(?<![A-Za-z0-9/+])(?=[A-Za-z0-9/+=]{40}(?![A-Za-z0-9/+=]))(?=.*[/+])[A-Za-z0-9/+=]{40}/g, label: "AWS_SECRET" },
+  // JWT tokens (eyJ...)
+  { regex: /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g, label: "JWT" },
+  // Private IPv4 (10.x.x.x, 172.16-31.x.x, 192.168.x.x)
+  { regex: /\b(?:10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(?:1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3})\b/g, label: "PRIVATE_IP" },
+  // Private IPv6 (fc00::/7)
+  { regex: /\b[fF][cCdD][0-9a-fA-F]{0,2}(?::[0-9a-fA-F]{1,4}){1,7}\b/g, label: "PRIVATE_IPV6" },
+  // Environment variable assignments for secrets
+  { regex: /(?:_SECRET|_KEY|_TOKEN|_PASSWORD)\s*=\s*['"]?[^\s'"]{8,}['"]?/g, label: "ENV_SECRET" },
+  // GCP service account keys
+  { regex: /"private_key"\s*:\s*"-----BEGIN[^"]+"/g, label: "GCP_KEY" },
+  // Azure connection strings
+  { regex: /AccountKey=[A-Za-z0-9+/=]{20,}/g, label: "AZURE_KEY" }
+];
+var MaskingPipeline = class _MaskingPipeline {
+  patterns;
+  constructor(additionalPatterns = []) {
+    this.patterns = [...DEFAULT_PATTERNS, ...additionalPatterns].map(({ regex, label }) => ({
+      regex: new RegExp(regex.source, regex.flags),
+      label
+    }));
+  }
+  static fromConfig(configPatterns) {
+    const additional = [];
+    for (const { pattern, flags, label } of configPatterns) {
+      try {
+        additional.push({ regex: new RegExp(pattern, flags ?? "g"), label });
+      } catch (err) {
+        console.error(`[ctxo:masking] Invalid regex pattern "${pattern}": ${err.message}`);
+      }
+    }
+    return new _MaskingPipeline(additional);
+  }
+  mask(text) {
+    if (text.length === 0) return text;
+    let result = text;
+    for (const { regex, label } of this.patterns) {
+      result = result.replace(regex, `[REDACTED:${label}]`);
+    }
+    return result;
+  }
+};
+
+// src/adapters/mcp/get-logic-slice.ts
+import { z } from "zod";
+
+// src/core/graph/symbol-graph.ts
+var SymbolGraph = class {
+  nodes = /* @__PURE__ */ new Map();
+  nodesByFileAndName = /* @__PURE__ */ new Map();
+  forwardEdges = /* @__PURE__ */ new Map();
+  reverseEdges = /* @__PURE__ */ new Map();
+  edgeSet = /* @__PURE__ */ new Set();
+  addNode(node) {
+    this.nodes.set(node.symbolId, node);
+    const parts = node.symbolId.split("::");
+    if (parts.length >= 2) {
+      this.nodesByFileAndName.set(`${parts[0]}::${parts[1]}`, node);
+    }
+  }
+  addEdge(edge) {
+    const resolvedFrom = this.resolveNodeId(edge.from);
+    const resolvedTo = this.resolveNodeId(edge.to);
+    const resolvedEdge = { from: resolvedFrom, to: resolvedTo, kind: edge.kind };
+    const edgeKey = `${resolvedEdge.from}|${resolvedEdge.to}|${resolvedEdge.kind}`;
+    if (this.edgeSet.has(edgeKey)) return;
+    this.edgeSet.add(edgeKey);
+    const forward = this.forwardEdges.get(resolvedEdge.from) ?? [];
+    forward.push(resolvedEdge);
+    this.forwardEdges.set(resolvedEdge.from, forward);
+    const reverse = this.reverseEdges.get(resolvedEdge.to) ?? [];
+    reverse.push(resolvedEdge);
+    this.reverseEdges.set(resolvedEdge.to, reverse);
+  }
+  getNode(symbolId) {
+    return this.nodes.get(symbolId) ?? this.resolveNodeFuzzy(symbolId);
+  }
+  resolveNodeId(id) {
+    if (this.nodes.has(id)) return id;
+    const parts = id.split("::");
+    if (parts.length >= 2) {
+      const fuzzyKey = `${parts[0]}::${parts[1]}`;
+      const match = this.nodesByFileAndName.get(fuzzyKey);
+      if (match) return match.symbolId;
+    }
+    return id;
+  }
+  resolveNodeFuzzy(id) {
+    const parts = id.split("::");
+    if (parts.length >= 2) {
+      return this.nodesByFileAndName.get(`${parts[0]}::${parts[1]}`);
+    }
+    return void 0;
+  }
+  getForwardEdges(symbolId) {
+    return this.forwardEdges.get(symbolId) ?? [];
+  }
+  getReverseEdges(symbolId) {
+    return this.reverseEdges.get(symbolId) ?? [];
+  }
+  hasNode(symbolId) {
+    return this.nodes.has(symbolId);
+  }
+  get nodeCount() {
+    return this.nodes.size;
+  }
+  get edgeCount() {
+    return this.edgeSet.size;
+  }
+  allNodes() {
+    return [...this.nodes.values()];
+  }
+  allEdges() {
+    const edges = [];
+    for (const list of this.forwardEdges.values()) {
+      edges.push(...list);
+    }
+    return edges;
+  }
+};
+
+// src/core/logic-slice/logic-slice-query.ts
+var LogicSliceQuery = class {
+  getLogicSlice(graph, symbolId, maxDepth = Infinity) {
+    const root = graph.getNode(symbolId);
+    if (!root) return void 0;
+    const visited = /* @__PURE__ */ new Set([symbolId]);
+    const dependencies = [];
+    const collectedEdges = [];
+    const queue = [{ id: symbolId, depth: 0 }];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current.depth >= maxDepth) continue;
+      const edges = graph.getForwardEdges(current.id);
+      for (const edge of edges) {
+        const depNode = graph.getNode(edge.to);
+        if (!depNode) continue;
+        collectedEdges.push(edge);
+        if (visited.has(edge.to)) continue;
+        visited.add(edge.to);
+        dependencies.push(depNode);
+        queue.push({ id: edge.to, depth: current.depth + 1 });
+      }
+    }
+    return { root, dependencies, edges: collectedEdges };
+  }
+};
+
+// src/core/detail-levels/detail-formatter.ts
+var L1_MAX_LINES = 150;
+var L4_TOKEN_BUDGET = 8e3;
+var DetailFormatter = class {
+  format(slice, level) {
+    switch (level) {
+      case 1:
+        return this.formatL1(slice);
+      case 2:
+        return this.formatL2(slice);
+      case 3:
+        return this.formatL3(slice);
+      case 4:
+        return this.formatL4(slice);
+    }
+  }
+  formatL1(slice) {
+    const root = slice.root;
+    const lineCount = root.endLine - root.startLine + 1;
+    const clampedRoot = lineCount > L1_MAX_LINES ? { ...root, endLine: root.startLine + L1_MAX_LINES - 1 } : root;
+    return {
+      root: clampedRoot,
+      dependencies: [],
+      edges: [],
+      level: 1,
+      levelDescription: "L1: Root symbol signature only (no dependencies)",
+      ...lineCount > L1_MAX_LINES ? { truncation: { truncated: true, reason: "token_budget_exceeded" } } : {}
+    };
+  }
+  formatL2(slice) {
+    const directEdges = slice.edges.filter((e) => e.from === slice.root.symbolId);
+    const directDepIds = new Set(directEdges.map((e) => e.to));
+    const directDeps = slice.dependencies.filter((d) => directDepIds.has(d.symbolId));
+    return {
+      root: slice.root,
+      dependencies: directDeps,
+      edges: directEdges,
+      level: 2,
+      levelDescription: "L2: Root + direct dependencies (depth 1)"
+    };
+  }
+  formatL3(slice) {
+    return {
+      root: slice.root,
+      dependencies: slice.dependencies,
+      edges: slice.edges,
+      level: 3,
+      levelDescription: "L3: Full transitive dependency closure"
+    };
+  }
+  formatL4(slice) {
+    const estimatedTokens = this.estimateTokens(slice);
+    if (estimatedTokens > L4_TOKEN_BUDGET) {
+      const truncated = this.truncateToTokenBudget(slice, L4_TOKEN_BUDGET);
+      return {
+        ...truncated,
+        level: 4,
+        levelDescription: "L4: Full closure with 8K token budget (truncated)",
+        truncation: {
+          truncated: true,
+          reason: "token_budget_exceeded"
+        }
+      };
+    }
+    return {
+      root: slice.root,
+      dependencies: slice.dependencies,
+      edges: slice.edges,
+      level: 4,
+      levelDescription: "L4: Full closure with 8K token budget"
+    };
+  }
+  estimateTokens(slice) {
+    let chars = this.symbolCharEstimate(slice.root);
+    for (const dep of slice.dependencies) {
+      chars += this.symbolCharEstimate(dep);
+    }
+    for (const edge of slice.edges) {
+      chars += edge.from.length + edge.to.length + edge.kind.length + 10;
+    }
+    return Math.ceil(chars / 4);
+  }
+  symbolCharEstimate(node) {
+    return (node.endLine - node.startLine + 1) * 40;
+  }
+  truncateToTokenBudget(slice, budget) {
+    let currentTokens = this.symbolCharEstimate(slice.root) / 4;
+    const deps = [];
+    const includedIds = /* @__PURE__ */ new Set([slice.root.symbolId]);
+    for (const dep of slice.dependencies) {
+      const depTokens = this.symbolCharEstimate(dep) / 4;
+      if (currentTokens + depTokens > budget) break;
+      currentTokens += depTokens;
+      deps.push(dep);
+      includedIds.add(dep.symbolId);
+    }
+    const edges = slice.edges.filter(
+      (e) => includedIds.has(e.from) && includedIds.has(e.to)
+    );
+    return { root: slice.root, dependencies: deps, edges };
+  }
+};
+
+// src/adapters/mcp/get-logic-slice.ts
+var InputSchema = z.object({
+  symbolId: z.string().min(1).optional(),
+  symbolIds: z.array(z.string().min(1)).optional(),
+  level: DetailLevelSchema.optional().default(3)
+}).refine(
+  (data) => data.symbolId || data.symbolIds && data.symbolIds.length > 0,
+  { message: "Either symbolId or symbolIds must be provided" }
+);
+function buildGraphFromStorage(storage) {
+  const graph = new SymbolGraph();
+  for (const sym of storage.getAllSymbols()) {
+    graph.addNode(sym);
+  }
+  for (const edge of storage.getAllEdges()) {
+    graph.addEdge(edge);
+  }
+  return graph;
+}
+function buildGraphFromJsonIndex(ctxoRoot) {
+  const reader = new JsonIndexReader(ctxoRoot);
+  const indices = reader.readAll();
+  const graph = new SymbolGraph();
+  for (const fileIndex of indices) {
+    for (const sym of fileIndex.symbols) {
+      graph.addNode(sym);
+    }
+  }
+  for (const fileIndex of indices) {
+    for (const edge of fileIndex.edges) {
+      graph.addEdge(edge);
+    }
+  }
+  return graph;
+}
+function handleGetLogicSlice(storage, masking, staleness, ctxoRoot = ".ctxo") {
+  const query = new LogicSliceQuery();
+  const formatter = new DetailFormatter();
+  const getGraph = () => {
+    const jsonGraph = buildGraphFromJsonIndex(ctxoRoot);
+    if (jsonGraph.nodeCount > 0) return jsonGraph;
+    return buildGraphFromStorage(storage);
+  };
+  const handler = (args) => {
+    try {
+      const parsed = InputSchema.safeParse(args);
+      if (!parsed.success) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
+        };
+      }
+      const { symbolId, symbolIds, level } = parsed.data;
+      const ids = symbolIds ?? (symbolId ? [symbolId] : []);
+      const graph = getGraph();
+      const results = [];
+      for (const id of ids) {
+        const slice = query.getLogicSlice(graph, id);
+        if (slice) {
+          results.push(formatter.format(slice, level));
+        } else {
+          results.push({ found: false, symbolId: id, hint: 'Symbol not found. Run "ctxo index".' });
+        }
+      }
+      const responseData = ids.length === 1 ? results[0] : { batch: true, results };
+      const payload = masking.mask(JSON.stringify(responseData));
+      const content = [];
+      if (staleness) {
+        const warning = staleness.check(storage.listIndexedFiles());
+        if (warning) {
+          content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
+        }
+      }
+      content.push({ type: "text", text: payload });
+      return { content };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
+      };
+    }
+  };
+  return handler;
+}
+
+// src/adapters/mcp/get-why-context.ts
+import { z as z2 } from "zod";
+var InputSchema2 = z2.object({
+  symbolId: z2.string().min(1)
+});
+function handleGetWhyContext(storage, git, masking, staleness, ctxoRoot = ".ctxo") {
+  const revertDetector = new RevertDetector();
+  const indexReader = new JsonIndexReader(ctxoRoot);
+  return async (args) => {
+    try {
+      const parsed = InputSchema2.safeParse(args);
+      if (!parsed.success) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
+        };
+      }
+      const { symbolId } = parsed.data;
+      const symbol = storage.getSymbolById(symbolId);
+      if (!symbol) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ found: false, hint: 'Symbol not found. Run "ctxo index" to build the codebase index.' }) }]
+        };
+      }
+      const filePath = symbolId.split("::")[0];
+      const indices = indexReader.readAll();
+      const fileIndex = indices.find((i) => i.file === filePath);
+      let commitHistory;
+      let antiPatterns;
+      if (fileIndex && fileIndex.intent.length > 0) {
+        commitHistory = fileIndex.intent;
+        antiPatterns = fileIndex.antiPatterns;
+      } else {
+        const commits = await git.getCommitHistory(filePath);
+        commitHistory = commits.map((c) => ({
+          hash: c.hash,
+          message: c.message,
+          date: c.date,
+          kind: "commit"
+        }));
+        antiPatterns = revertDetector.detect(commits);
+      }
+      const responsePayload = {
+        commitHistory,
+        antiPatternWarnings: antiPatterns
+      };
+      if (antiPatterns.length > 0) {
+        responsePayload.warningBadge = "\u26A0 Anti-pattern detected";
+      }
+      const payload = masking.mask(JSON.stringify(responsePayload));
+      const content = [];
+      if (staleness) {
+        const warning = staleness.check(storage.listIndexedFiles());
+        if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
+      }
+      content.push({ type: "text", text: payload });
+      return { content };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
+      };
+    }
+  };
+}
+
+// src/adapters/mcp/get-change-intelligence.ts
+import { z as z3 } from "zod";
+
+// src/core/change-intelligence/churn-analyzer.ts
+var ChurnAnalyzer = class {
+  normalize(commitCount, maxCommitCount) {
+    if (maxCommitCount <= 0) return 0;
+    if (commitCount < 0) {
+      throw new Error(`Invalid commit count: ${commitCount}`);
+    }
+    return Math.min(commitCount / maxCommitCount, 1);
+  }
+};
+
+// src/core/change-intelligence/health-scorer.ts
+var HealthScorer = class {
+  score(symbolId, complexity, churn) {
+    const composite = complexity * churn;
+    const band = this.toBand(composite);
+    return { symbolId, complexity, churn, composite, band };
+  }
+  toBand(composite) {
+    if (composite < 0.3) return "low";
+    if (composite < 0.7) return "medium";
+    return "high";
+  }
+};
+
+// src/adapters/mcp/get-change-intelligence.ts
+var InputSchema3 = z3.object({
+  symbolId: z3.string().min(1)
+});
+function handleGetChangeIntelligence(storage, git, masking, staleness, ctxoRoot = ".ctxo") {
+  const churnAnalyzer = new ChurnAnalyzer();
+  const healthScorer = new HealthScorer();
+  const indexReader = new JsonIndexReader(ctxoRoot);
+  return async (args) => {
+    try {
+      const parsed = InputSchema3.safeParse(args);
+      if (!parsed.success) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
+        };
+      }
+      const { symbolId } = parsed.data;
+      const symbol = storage.getSymbolById(symbolId);
+      if (!symbol) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ found: false, hint: 'Symbol not found. Run "ctxo index" to build the codebase index.' }) }]
+        };
+      }
+      const filePath = symbolId.split("::")[0];
+      const normalizePath = (p) => p.replace(/\\/g, "/");
+      const allFiles = storage.listIndexedFiles();
+      const churnResults = await Promise.all(allFiles.map((f) => git.getFileChurn(f)));
+      const maxChurn = Math.max(1, ...churnResults.map((c) => c.commitCount));
+      const targetChurn = churnResults.find((c) => normalizePath(c.filePath) === normalizePath(filePath));
+      const commitCount = targetChurn?.commitCount ?? 0;
+      const normalizedChurn = churnAnalyzer.normalize(commitCount, maxChurn);
+      const indices = indexReader.readAll();
+      const fileIndex = indices.find((i) => i.file === filePath);
+      const complexityEntries = fileIndex?.complexity ?? [];
+      let cyclomatic = complexityEntries.find((c) => c.symbolId === symbolId)?.cyclomatic;
+      if (cyclomatic === void 0) {
+        const symbolName = symbolId.split("::")[1] ?? "";
+        const relatedEntries = complexityEntries.filter(
+          (c) => c.symbolId.startsWith(`${filePath}::${symbolName}.`)
+        );
+        cyclomatic = relatedEntries.length > 0 ? Math.max(...relatedEntries.map((c) => c.cyclomatic)) : 1;
+      }
+      const normalizedComplexity = Math.min((cyclomatic - 1) / 9, 1);
+      const score = healthScorer.score(symbolId, normalizedComplexity, normalizedChurn);
+      const payload = masking.mask(JSON.stringify(score));
+      const content = [];
+      if (staleness) {
+        const warning = staleness.check(storage.listIndexedFiles());
+        if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
+      }
+      content.push({ type: "text", text: payload });
+      return { content };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
+      };
+    }
+  };
+}
+
+// src/adapters/mcp/get-blast-radius.ts
+import { z as z4 } from "zod";
+
+// src/core/blast-radius/blast-radius-calculator.ts
+var BlastRadiusCalculator = class {
+  calculate(graph, symbolId) {
+    if (!graph.hasNode(symbolId)) {
+      return { impactedSymbols: [], directDependentsCount: 0, overallRiskScore: 0 };
+    }
+    const visited = /* @__PURE__ */ new Set([symbolId]);
+    const entries = [];
+    const queue = [{ id: symbolId, depth: 0 }];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const reverseEdges = graph.getReverseEdges(current.id);
+      for (const edge of reverseEdges) {
+        if (visited.has(edge.from)) continue;
+        visited.add(edge.from);
+        if (!graph.hasNode(edge.from)) continue;
+        const depth = current.depth + 1;
+        const riskScore = 1 / Math.pow(depth, 0.7);
+        entries.push({
+          symbolId: edge.from,
+          depth,
+          dependentCount: graph.getReverseEdges(edge.from).length,
+          riskScore: Math.round(riskScore * 1e3) / 1e3
+        });
+        queue.push({ id: edge.from, depth });
+      }
+    }
+    entries.sort((a, b) => a.depth - b.depth);
+    const directDependentsCount = entries.filter((e) => e.depth === 1).length;
+    const totalRisk = entries.reduce((sum, e) => sum + e.riskScore, 0);
+    const maxPossibleRisk = entries.length > 0 ? entries.length : 1;
+    const overallRiskScore = Math.round(Math.min(totalRisk / maxPossibleRisk, 1) * 1e3) / 1e3;
+    return { impactedSymbols: entries, directDependentsCount, overallRiskScore };
+  }
+};
+
+// src/adapters/mcp/get-blast-radius.ts
+var InputSchema4 = z4.object({
+  symbolId: z4.string().min(1)
+});
+function handleGetBlastRadius(storage, masking, staleness, ctxoRoot = ".ctxo") {
+  const calculator = new BlastRadiusCalculator();
+  const getGraph = () => {
+    const jsonGraph = buildGraphFromJsonIndex(ctxoRoot);
+    if (jsonGraph.nodeCount > 0) return jsonGraph;
+    return buildGraphFromStorage(storage);
+  };
+  return (args) => {
+    try {
+      const parsed = InputSchema4.safeParse(args);
+      if (!parsed.success) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
+        };
+      }
+      const { symbolId } = parsed.data;
+      const graph = getGraph();
+      if (!graph.hasNode(symbolId)) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ found: false, hint: 'Symbol not found. Run "ctxo index" to build the codebase index.' }) }]
+        };
+      }
+      const result = calculator.calculate(graph, symbolId);
+      const payload = masking.mask(JSON.stringify({
+        symbolId,
+        impactScore: result.impactedSymbols.length,
+        directDependentsCount: result.directDependentsCount,
+        overallRiskScore: result.overallRiskScore,
+        impactedSymbols: result.impactedSymbols
+      }));
+      const content = [];
+      if (staleness) {
+        const warning = staleness.check(storage.listIndexedFiles());
+        if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
+      }
+      content.push({ type: "text", text: payload });
+      return { content };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
+      };
+    }
+  };
+}
+
+// src/adapters/mcp/get-architectural-overlay.ts
+import { z as z5 } from "zod";
+
+// src/core/overlay/architectural-overlay.ts
+var DEFAULT_RULES = [
+  // Test layer (matched first — __tests__, .test.ts, tests/, fixtures)
+  { pattern: /__tests__/, layer: "Test" },
+  { pattern: /\.test\.ts$/, layer: "Test" },
+  { pattern: /\btests\b/, layer: "Test" },
+  { pattern: /\bfixtures?\b/, layer: "Test" },
+  // Composition root
+  { pattern: /src\/index\.ts$/, layer: "Composition" },
+  // Domain
+  { pattern: /\bcore\b/, layer: "Domain" },
+  { pattern: /\bports?\b/, layer: "Domain" },
+  // Adapter
+  { pattern: /\badapters?\b/, layer: "Adapter" },
+  { pattern: /\bcli\b/, layer: "Adapter" },
+  // Infrastructure
+  { pattern: /\binfra\b/, layer: "Infrastructure" },
+  { pattern: /\bdb\b/, layer: "Infrastructure" },
+  { pattern: /\bqueue\b/, layer: "Infrastructure" },
+  // Config files
+  { pattern: /\.(config|rc)\.(ts|js|json)$/, layer: "Configuration" }
+];
+var ArchitecturalOverlay = class {
+  rules;
+  constructor(customRules) {
+    this.rules = (customRules ?? DEFAULT_RULES).map(({ pattern, layer }) => ({
+      pattern: new RegExp(pattern.source, pattern.flags),
+      layer
+    }));
+  }
+  classify(filePaths) {
+    const layers = {};
+    for (const filePath of filePaths) {
+      const layer = this.matchLayer(filePath);
+      const list = layers[layer] ?? [];
+      list.push(filePath);
+      layers[layer] = list;
+    }
+    return { layers };
+  }
+  matchLayer(filePath) {
+    for (const rule of this.rules) {
+      if (rule.pattern.test(filePath)) {
+        return rule.layer;
+      }
+    }
+    return "Unknown";
+  }
+};
+
+// src/adapters/mcp/get-architectural-overlay.ts
+var InputSchema5 = z5.object({
+  layer: z5.string().optional()
+});
+function handleGetArchitecturalOverlay(storage, masking, staleness) {
+  const overlay = new ArchitecturalOverlay();
+  return (args) => {
+    try {
+      const parsed = InputSchema5.safeParse(args);
+      if (!parsed.success) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
+        };
+      }
+      const files = storage.listIndexedFiles();
+      const result = overlay.classify(files);
+      const buildContent = (payloadStr) => {
+        const content = [];
+        if (staleness) {
+          const warning = staleness.check(files);
+          if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
+        }
+        content.push({ type: "text", text: payloadStr });
+        return content;
+      };
+      if (parsed.data.layer) {
+        const filtered = result.layers[parsed.data.layer];
+        const payload2 = masking.mask(JSON.stringify({ layer: parsed.data.layer, files: filtered ?? [] }));
+        return { content: buildContent(payload2) };
+      }
+      const payload = masking.mask(JSON.stringify(result));
+      return { content: buildContent(payload) };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
+      };
+    }
+  };
+}
+
+// src/index.ts
+function loadMaskingConfig(ctxoRoot) {
+  const jsonConfigPath = join(ctxoRoot, "masking.json");
+  if (existsSync(jsonConfigPath)) {
+    try {
+      const raw = readFileSync(jsonConfigPath, "utf-8");
+      const patterns = JSON.parse(raw);
+      console.error(`[ctxo] Loaded ${patterns.length} custom masking pattern(s)`);
+      return MaskingPipeline.fromConfig(patterns);
+    } catch (err) {
+      console.error(`[ctxo] Failed to load masking config: ${err.message}`);
+    }
+  }
+  return new MaskingPipeline();
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length > 0) {
+    const { CliRouter } = await import("./cli-router-PIWHLS5F.js");
+    const router = new CliRouter(process.cwd());
+    await router.route(args);
+    return;
+  }
+  const ctxoRoot = ".ctxo";
+  const storage = new SqliteStorageAdapter(ctxoRoot);
+  await storage.init();
+  const masking = loadMaskingConfig(ctxoRoot);
+  const git = new SimpleGitAdapter(process.cwd());
+  const server = new McpServer({ name: "ctxo", version: "0.1.0" });
+  const { StalenessDetector } = await import("./staleness-detector-5AN223FM.js");
+  const staleness = new StalenessDetector(process.cwd(), ctxoRoot);
+  const logicSliceHandler = handleGetLogicSlice(storage, masking, staleness, ctxoRoot);
+  const whyContextHandler = handleGetWhyContext(storage, git, masking, staleness, ctxoRoot);
+  const changeIntelligenceHandler = handleGetChangeIntelligence(storage, git, masking, staleness, ctxoRoot);
+  server.registerTool(
+    "get_logic_slice",
+    {
+      description: "Retrieve a Logic-Slice for a named symbol \u2014 the symbol plus all transitive dependencies",
+      inputSchema: {
+        symbolId: z6.string().optional().describe("Single symbol ID (format: file::name::kind)"),
+        symbolIds: z6.array(z6.string()).optional().describe("Batch: array of symbol IDs"),
+        level: z6.number().min(1).max(4).optional().default(3).describe("Detail level (L1=signature, L2=direct deps, L3=full closure, L4=with token budget)")
+      }
+    },
+    (args2) => logicSliceHandler(args2)
+  );
+  server.registerTool(
+    "get_why_context",
+    {
+      description: "Retrieve git commit intent, anti-pattern warnings from revert history for a symbol",
+      inputSchema: {
+        symbolId: z6.string().min(1).describe("The symbol ID (format: file::name::kind)")
+      }
+    },
+    (args2) => whyContextHandler(args2)
+  );
+  server.registerTool(
+    "get_change_intelligence",
+    {
+      description: "Retrieve complexity x churn composite score for a symbol",
+      inputSchema: {
+        symbolId: z6.string().min(1).describe("The symbol ID (format: file::name::kind)")
+      }
+    },
+    (args2) => changeIntelligenceHandler(args2)
+  );
+  const blastRadiusHandler = handleGetBlastRadius(storage, masking, staleness, ctxoRoot);
+  server.registerTool(
+    "get_blast_radius",
+    {
+      description: "Retrieve the blast radius for a symbol \u2014 symbols that would break if it changed",
+      inputSchema: {
+        symbolId: z6.string().min(1).describe("The symbol ID (format: file::name::kind)")
+      }
+    },
+    (args2) => blastRadiusHandler(args2)
+  );
+  const overlayHandler = handleGetArchitecturalOverlay(storage, masking, staleness);
+  server.registerTool(
+    "get_architectural_overlay",
+    {
+      description: "Retrieve an architectural overlay \u2014 layer map identifying Domain, Infrastructure, and Adapter boundaries",
+      inputSchema: {
+        layer: z6.string().optional().describe("Filter by specific layer name")
+      }
+    },
+    (args2) => overlayHandler(args2)
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  console.error("[ctxo] Fatal:", err.message);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map