archtracker-mcp 0.1.0

package/dist/mcp/index.js

@@ -0,0 +1,920 @@
+// src/mcp/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z2 } from "zod";
+
+// src/analyzer/analyze.ts
+import { resolve } from "path";
+import { cruise } from "dependency-cruiser";
+var DEFAULT_EXCLUDE = [
+  "node_modules",
+  "\\.d\\.ts$",
+  "dist",
+  "build",
+  "coverage",
+  "\\.archtracker"
+];
+async function analyzeProject(rootDir, options = {}) {
+  const {
+    exclude = [],
+    maxDepth = 0,
+    tsConfigPath,
+    includeTypeOnly = true
+  } = options;
+  const absRootDir = resolve(rootDir);
+  const allExclude = [...DEFAULT_EXCLUDE, ...exclude];
+  const excludePattern = allExclude.join("|");
+  const cruiseOptions = {
+    baseDir: absRootDir,
+    exclude: { path: excludePattern },
+    doNotFollow: { path: "node_modules" },
+    maxDepth,
+    tsPreCompilationDeps: includeTypeOnly ? true : false,
+    combinedDependencies: false
+  };
+  if (tsConfigPath) {
+    cruiseOptions.tsConfig = { fileName: tsConfigPath };
+  }
+  let result;
+  try {
+    result = await cruise(["."], cruiseOptions);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new AnalyzerError(
+      `dependency-cruiser \u306E\u5B9F\u884C\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${message}`,
+      { cause: error }
+    );
+  }
+  if (result.exitCode !== 0 && !result.output) {
+    throw new AnalyzerError(
+      `\u89E3\u6790\u304C\u30A8\u30E9\u30FC\u30B3\u30FC\u30C9 ${result.exitCode} \u3067\u7D42\u4E86\u3057\u307E\u3057\u305F`
+    );
+  }
+  const cruiseResult = result.output;
+  return buildGraph(absRootDir, cruiseResult);
+}
+function buildGraph(rootDir, cruiseResult) {
+  const files = {};
+  const edges = [];
+  const circularSet = /* @__PURE__ */ new Set();
+  const circularDependencies = [];
+  for (const mod of cruiseResult.modules) {
+    if (isExternalModule(mod)) continue;
+    files[mod.source] = {
+      path: mod.source,
+      exists: !mod.couldNotResolve,
+      dependencies: [],
+      dependents: []
+    };
+  }
+  for (const mod of cruiseResult.modules) {
+    for (const dep of mod.dependencies) {
+      if (dep.couldNotResolve || dep.coreModule) continue;
+      if (!files[mod.source] || isExternalDep(dep)) continue;
+      const edgeType = dep.typeOnly ? "type-only" : dep.dynamic ? "dynamic" : "static";
+      edges.push({
+        source: mod.source,
+        target: dep.resolved,
+        type: edgeType
+      });
+      if (files[mod.source]) {
+        files[mod.source].dependencies.push(dep.resolved);
+      }
+      if (files[dep.resolved]) {
+        files[dep.resolved].dependents.push(mod.source);
+      }
+      if (dep.circular && dep.cycle) {
+        const cyclePath = dep.cycle.map((c) => c.name);
+        const cycleKey = [...cyclePath].sort().join("\u2192");
+        if (!circularSet.has(cycleKey)) {
+          circularSet.add(cycleKey);
+          circularDependencies.push({ cycle: cyclePath });
+        }
+      }
+    }
+  }
+  return {
+    rootDir,
+    files,
+    edges,
+    circularDependencies,
+    totalFiles: Object.keys(files).length,
+    totalEdges: edges.length
+  };
+}
+function isExternalModule(mod) {
+  if (mod.coreModule) return true;
+  const depTypes = mod.dependencyTypes ?? [];
+  if (depTypes.some((t2) => t2.startsWith("npm") || t2 === "core")) return true;
+  return isExternalPath(mod.source);
+}
+function isExternalDep(dep) {
+  if (dep.coreModule) return true;
+  if (dep.dependencyTypes.some((t2) => t2.startsWith("npm") || t2 === "core")) return true;
+  return isExternalPath(dep.resolved);
+}
+function isExternalPath(source) {
+  if (source.startsWith("@")) return true;
+  if (!source.includes("/") && !source.includes("\\") && !source.includes(".")) return true;
+  if (source.startsWith("node:")) return true;
+  return false;
+}
+var AnalyzerError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "AnalyzerError";
+  }
+};
+
+// src/i18n/index.ts
+var currentLocale = detectLocale();
+function detectLocale() {
+  const env = process.env.LC_ALL || process.env.LANG || "";
+  if (env.startsWith("ja")) return "ja";
+  return "en";
+}
+function t(key, vars) {
+  const messages = currentLocale === "ja" ? ja : en;
+  let msg = messages[key] ?? en[key] ?? key;
+  if (vars) {
+    for (const [k, v] of Object.entries(vars)) {
+      msg = msg.replaceAll(`{${k}}`, String(v));
+    }
+  }
+  return msg;
+}
+var en = {
+  // Analyzer
+  "analyzer.failed": "dependency-cruiser failed: {message}",
+  "analyzer.exitCode": "Analysis finished with error code {code}",
+  // Storage
+  "storage.parseFailed": "Failed to parse snapshot.json. File may be corrupted: {path}",
+  "storage.readFailed": "Failed to read snapshot.json: {path}",
+  "storage.invalidSchema": "snapshot.json schema is invalid. Please regenerate with `archtracker init`:\n{issues}",
+  "storage.versionMismatch": "snapshot.json version ({version}) is incompatible with current schema ({expected}). Regenerate with `archtracker init`.",
+  // Path guard
+  "pathGuard.traversal": 'Path points outside project root: "{input}" \u2192 "{resolved}" (allowed: "{boundary}")',
+  // Diff report
+  "diff.title": "# Architecture Change Report\n",
+  "diff.noChanges": "No changes \u2014 snapshot matches current code.\n",
+  "diff.added": "## Added Files ({count})",
+  "diff.removed": "## Removed Files ({count})",
+  "diff.modified": "## Modified Dependencies ({count})",
+  "diff.affected": "## Files Requiring Review ({count})",
+  "diff.reasonRemoved": 'Dependency "{file}" was removed',
+  "diff.reasonModified": 'Dependency "{file}" had its dependencies changed',
+  "diff.reasonAdded": 'New dependency "{file}" was added',
+  // Search
+  "search.pathMatch": 'Path matches "{pattern}"',
+  "search.affected": 'May be affected by changes to "{file}" (via: {via})',
+  "search.critical": "{count} files depend on this component",
+  "search.orphan": "Orphan file (no dependencies, no dependents)",
+  "search.noResults": 'No results: "{query}" (mode: {mode})',
+  "search.results": "Results: {count} (mode: {mode})",
+  // CLI
+  "cli.analyzing": "Analyzing...",
+  "cli.snapshotSaved": "Snapshot saved",
+  "cli.timestamp": "  Timestamp: {ts}",
+  "cli.fileCount": "  Files: {count}",
+  "cli.edgeCount": "  Edges: {count}",
+  "cli.circularCount": "  Circular deps: {count}",
+  "cli.keyComponents": "\nKey components:",
+  "cli.dependedBy": "{path} ({count} dependents)",
+  "cli.noSnapshot": "No snapshot found. Run `archtracker init` first.",
+  "cli.ciFailed": "\nCI check failed: {count} file(s) require review",
+  "cli.autoGenerating": "No snapshot found, auto-generating...",
+  "cli.project": "Project: {path}",
+  "cli.validPaths": "\nValid file paths:",
+  "cli.snapshot": "Snapshot: {ts}",
+  // MCP
+  "mcp.analyzeComplete": "Analysis complete: {files} files, {edges} edges",
+  "mcp.circularFound": "Circular deps: {count} found",
+  "mcp.circularNone": "Circular deps: none",
+  "mcp.snapshotSaved": "Snapshot saved",
+  "mcp.autoInit": "No snapshot existed. Initial snapshot auto-generated.",
+  "mcp.nextCheckEnabled": "Diff checking will be active from the next run.",
+  "mcp.queryRequired": '"{mode}" mode requires the query parameter',
+  // Analyze report
+  "analyze.title": "# Architecture Analysis Report\n",
+  "analyze.overview": "## Overview",
+  "analyze.totalFiles": "  Total files: {count}",
+  "analyze.totalEdges": "  Total edges: {count}",
+  "analyze.totalCircular": "  Circular dependencies: {count}",
+  "analyze.criticalTitle": "\n## Critical Components (Top {count})",
+  "analyze.criticalItem": "  {path} ({count} dependents)",
+  "analyze.circularTitle": "\n## Circular Dependencies ({count})",
+  "analyze.circularItem": "  {files}",
+  "analyze.orphanTitle": "\n## Orphan Files ({count})",
+  "analyze.couplingTitle": "\n## High Coupling (Top {count} by import count)",
+  "analyze.couplingItem": "  {path} ({count} imports)",
+  "analyze.layerTitle": "\n## Directory Breakdown",
+  "analyze.layerItem": "  {dir}/ \u2014 {count} files",
+  "analyze.noIssues": "\nNo architectural issues detected.",
+  "analyze.snapshotSaved": "\nSnapshot saved alongside analysis.",
+  // CI
+  "ci.generated": "GitHub Actions workflow generated: {path}",
+  // Web viewer
+  "web.starting": "Starting architecture viewer...",
+  "web.listening": "Architecture graph available at: http://localhost:{port}",
+  "web.stop": "Press Ctrl+C to stop",
+  "web.watching": "Watching {dir}/ for changes...",
+  "web.reloading": "File change detected, reloading...",
+  "web.reloaded": "Graph reloaded",
+  // Errors
+  "error.analyzer": "[Analysis Error] {message}",
+  "error.storage": "[Storage Error] {message}",
+  "error.pathTraversal": "[Security Error] {message}",
+  "error.generic": "[Error] {message}",
+  "error.unexpected": "[Error] Unexpected error: {message}",
+  "error.cli.analyzer": "Analysis error: {message}",
+  "error.cli.storage": "Storage error: {message}",
+  "error.cli.generic": "Error: {message}",
+  "error.cli.unexpected": "Unexpected error: {message}"
+};
+var ja = {
+  // Analyzer
+  "analyzer.failed": "dependency-cruiser \u306E\u5B9F\u884C\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {message}",
+  "analyzer.exitCode": "\u89E3\u6790\u304C\u30A8\u30E9\u30FC\u30B3\u30FC\u30C9 {code} \u3067\u7D42\u4E86\u3057\u307E\u3057\u305F",
+  // Storage
+  "storage.parseFailed": "snapshot.json \u306E\u30D1\u30FC\u30B9\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3002\u30D5\u30A1\u30A4\u30EB\u304C\u7834\u640D\u3057\u3066\u3044\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059: {path}",
+  "storage.readFailed": "snapshot.json \u306E\u8AAD\u307F\u53D6\u308A\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {path}",
+  "storage.invalidSchema": "snapshot.json \u306E\u30B9\u30AD\u30FC\u30DE\u304C\u4E0D\u6B63\u3067\u3059\u3002archtracker init \u3067\u518D\u751F\u6210\u3057\u3066\u304F\u3060\u3055\u3044:\n{issues}",
+  "storage.versionMismatch": "snapshot.json \u306E\u30D0\u30FC\u30B8\u30E7\u30F3 ({version}) \u304C\u73FE\u5728\u306E\u30B9\u30AD\u30FC\u30DE ({expected}) \u3068\u4E92\u63DB\u6027\u304C\u3042\u308A\u307E\u305B\u3093\u3002archtracker init \u3067\u518D\u751F\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+  // Path guard
+  "pathGuard.traversal": '\u30D1\u30B9\u304C\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u30EB\u30FC\u30C8\u306E\u5916\u90E8\u3092\u6307\u3057\u3066\u3044\u307E\u3059: "{input}" \u2192 "{resolved}" (\u8A31\u53EF\u7BC4\u56F2: "{boundary}")',
+  // Diff report
+  "diff.title": "# \u30A2\u30FC\u30AD\u30C6\u30AF\u30C1\u30E3\u5909\u66F4\u30EC\u30DD\u30FC\u30C8\n",
+  "diff.noChanges": "\u5909\u66F4\u306A\u3057 \u2014 \u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3068\u73FE\u5728\u306E\u30B3\u30FC\u30C9\u306F\u4E00\u81F4\u3057\u3066\u3044\u307E\u3059\u3002\n",
+  "diff.added": "## \u8FFD\u52A0\u3055\u308C\u305F\u30D5\u30A1\u30A4\u30EB ({count}\u4EF6)",
+  "diff.removed": "## \u524A\u9664\u3055\u308C\u305F\u30D5\u30A1\u30A4\u30EB ({count}\u4EF6)",
+  "diff.modified": "## \u4F9D\u5B58\u95A2\u4FC2\u304C\u5909\u66F4\u3055\u308C\u305F\u30D5\u30A1\u30A4\u30EB ({count}\u4EF6)",
+  "diff.affected": "## \u78BA\u8A8D\u304C\u5FC5\u8981\u306A\u30D5\u30A1\u30A4\u30EB ({count}\u4EF6)",
+  "diff.reasonRemoved": '\u4F9D\u5B58\u5148 "{file}" \u304C\u524A\u9664\u3055\u308C\u307E\u3057\u305F',
+  "diff.reasonModified": '\u4F9D\u5B58\u5148 "{file}" \u306E\u4F9D\u5B58\u95A2\u4FC2\u304C\u5909\u66F4\u3055\u308C\u307E\u3057\u305F',
+  "diff.reasonAdded": '\u65B0\u3057\u3044\u4F9D\u5B58\u5148 "{file}" \u304C\u8FFD\u52A0\u3055\u308C\u307E\u3057\u305F',
+  // Search
+  "search.pathMatch": '\u30D1\u30B9\u304C "{pattern}" \u306B\u30DE\u30C3\u30C1',
+  "search.affected": '"{file}" \u306E\u5909\u66F4\u306B\u3088\u308A\u5F71\u97FF\u3092\u53D7\u3051\u308B\u53EF\u80FD\u6027\uFF08\u7D4C\u7531: {via}\uFF09',
+  "search.critical": "{count}\u4EF6\u306E\u30D5\u30A1\u30A4\u30EB\u304C\u4F9D\u5B58\u3059\u308B\u91CD\u8981\u30B3\u30F3\u30DD\u30FC\u30CD\u30F3\u30C8",
+  "search.orphan": "\u5B64\u7ACB\u30D5\u30A1\u30A4\u30EB\uFF08\u4F9D\u5B58\u306A\u3057\u30FB\u88AB\u4F9D\u5B58\u306A\u3057\uFF09",
+  "search.noResults": '\u691C\u7D22\u7D50\u679C\u306A\u3057: "{query}" (\u30E2\u30FC\u30C9: {mode})',
+  "search.results": "\u691C\u7D22\u7D50\u679C: {count}\u4EF6 (\u30E2\u30FC\u30C9: {mode})",
+  // CLI
+  "cli.analyzing": "\u89E3\u6790\u4E2D...",
+  "cli.snapshotSaved": "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3092\u4FDD\u5B58\u3057\u307E\u3057\u305F",
+  "cli.timestamp": "  \u30BF\u30A4\u30E0\u30B9\u30BF\u30F3\u30D7: {ts}",
+  "cli.fileCount": "  \u30D5\u30A1\u30A4\u30EB\u6570: {count}",
+  "cli.edgeCount": "  \u30A8\u30C3\u30B8\u6570: {count}",
+  "cli.circularCount": "  \u5FAA\u74B0\u53C2\u7167: {count}\u4EF6",
+  "cli.keyComponents": "\n\u4E3B\u8981\u30B3\u30F3\u30DD\u30FC\u30CD\u30F3\u30C8:",
+  "cli.dependedBy": "{path} ({count}\u4EF6\u304C\u4F9D\u5B58)",
+  "cli.noSnapshot": "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002`archtracker init` \u3092\u5148\u306B\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+  "cli.ciFailed": "\nCI \u30C1\u30A7\u30C3\u30AF\u5931\u6557: {count}\u4EF6\u306E\u8981\u78BA\u8A8D\u30D5\u30A1\u30A4\u30EB\u304C\u3042\u308A\u307E\u3059",
+  "cli.autoGenerating": "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u304C\u7121\u3044\u305F\u3081\u81EA\u52D5\u751F\u6210\u3057\u307E\u3059...",
+  "cli.project": "\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8: {path}",
+  "cli.validPaths": "\n\u6709\u52B9\u306A\u30D5\u30A1\u30A4\u30EB\u30D1\u30B9:",
+  "cli.snapshot": "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8: {ts}",
+  // MCP
+  "mcp.analyzeComplete": "\u89E3\u6790\u5B8C\u4E86: {files}\u30D5\u30A1\u30A4\u30EB, {edges}\u30A8\u30C3\u30B8",
+  "mcp.circularFound": "\u5FAA\u74B0\u53C2\u7167: {count}\u4EF6\u691C\u51FA",
+  "mcp.circularNone": "\u5FAA\u74B0\u53C2\u7167: \u306A\u3057",
+  "mcp.snapshotSaved": "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3092\u4FDD\u5B58\u3057\u307E\u3057\u305F",
+  "mcp.autoInit": "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u304C\u5B58\u5728\u3057\u306A\u304B\u3063\u305F\u305F\u3081\u3001\u521D\u671F\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3092\u81EA\u52D5\u751F\u6210\u3057\u307E\u3057\u305F\u3002",
+  "mcp.nextCheckEnabled": "\u6B21\u56DE\u306E\u5B9F\u884C\u6642\u304B\u3089\u5DEE\u5206\u30C1\u30A7\u30C3\u30AF\u304C\u6709\u52B9\u306B\u306A\u308A\u307E\u3059\u3002",
+  "mcp.queryRequired": '"{mode}" \u30E2\u30FC\u30C9\u3067\u306F query \u30D1\u30E9\u30E1\u30FC\u30BF\u304C\u5FC5\u9808\u3067\u3059',
+  // Analyze report
+  "analyze.title": "# \u30A2\u30FC\u30AD\u30C6\u30AF\u30C1\u30E3\u5206\u6790\u30EC\u30DD\u30FC\u30C8\n",
+  "analyze.overview": "## \u6982\u8981",
+  "analyze.totalFiles": "  \u7DCF\u30D5\u30A1\u30A4\u30EB\u6570: {count}",
+  "analyze.totalEdges": "  \u7DCF\u30A8\u30C3\u30B8\u6570: {count}",
+  "analyze.totalCircular": "  \u5FAA\u74B0\u53C2\u7167: {count}\u4EF6",
+  "analyze.criticalTitle": "\n## \u91CD\u8981\u30B3\u30F3\u30DD\u30FC\u30CD\u30F3\u30C8 (\u4E0A\u4F4D{count}\u4EF6)",
+  "analyze.criticalItem": "  {path} ({count}\u4EF6\u304C\u4F9D\u5B58)",
+  "analyze.circularTitle": "\n## \u5FAA\u74B0\u53C2\u7167 ({count}\u4EF6)",
+  "analyze.circularItem": "  {files}",
+  "analyze.orphanTitle": "\n## \u5B64\u7ACB\u30D5\u30A1\u30A4\u30EB ({count}\u4EF6)",
+  "analyze.couplingTitle": "\n## \u9AD8\u7D50\u5408\u30D5\u30A1\u30A4\u30EB (import\u6570 \u4E0A\u4F4D{count}\u4EF6)",
+  "analyze.couplingItem": "  {path} ({count}\u4EF6\u3092import)",
+  "analyze.layerTitle": "\n## \u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u69CB\u6210",
+  "analyze.layerItem": "  {dir}/ \u2014 {count}\u30D5\u30A1\u30A4\u30EB",
+  "analyze.noIssues": "\n\u30A2\u30FC\u30AD\u30C6\u30AF\u30C1\u30E3\u4E0A\u306E\u554F\u984C\u306F\u691C\u51FA\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F\u3002",
+  "analyze.snapshotSaved": "\n\u5206\u6790\u3068\u540C\u6642\u306B\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3092\u4FDD\u5B58\u3057\u307E\u3057\u305F\u3002",
+  // CI
+  "ci.generated": "GitHub Actions \u30EF\u30FC\u30AF\u30D5\u30ED\u30FC\u3092\u751F\u6210\u3057\u307E\u3057\u305F: {path}",
+  // Web viewer
+  "web.starting": "\u30A2\u30FC\u30AD\u30C6\u30AF\u30C1\u30E3\u30D3\u30E5\u30FC\u30A2\u30FC\u3092\u8D77\u52D5\u4E2D...",
+  "web.listening": "\u30A2\u30FC\u30AD\u30C6\u30AF\u30C1\u30E3\u30B0\u30E9\u30D5: http://localhost:{port}",
+  "web.stop": "Ctrl+C \u3067\u505C\u6B62",
+  "web.watching": "{dir}/ \u3092\u76E3\u8996\u4E2D...",
+  "web.reloading": "\u30D5\u30A1\u30A4\u30EB\u5909\u66F4\u3092\u691C\u51FA\u3001\u30EA\u30ED\u30FC\u30C9\u4E2D...",
+  "web.reloaded": "\u30B0\u30E9\u30D5\u3092\u66F4\u65B0\u3057\u307E\u3057\u305F",
+  // Errors
+  "error.analyzer": "[\u89E3\u6790\u30A8\u30E9\u30FC] {message}",
+  "error.storage": "[\u30B9\u30C8\u30EC\u30FC\u30B8\u30A8\u30E9\u30FC] {message}",
+  "error.pathTraversal": "[\u30BB\u30AD\u30E5\u30EA\u30C6\u30A3\u30A8\u30E9\u30FC] {message}",
+  "error.generic": "[\u30A8\u30E9\u30FC] {message}",
+  "error.unexpected": "[\u30A8\u30E9\u30FC] \u4E88\u671F\u3057\u306A\u3044\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F: {message}",
+  "error.cli.analyzer": "\u89E3\u6790\u30A8\u30E9\u30FC: {message}",
+  "error.cli.storage": "\u30B9\u30C8\u30EC\u30FC\u30B8\u30A8\u30E9\u30FC: {message}",
+  "error.cli.generic": "\u30A8\u30E9\u30FC: {message}",
+  "error.cli.unexpected": "\u4E88\u671F\u3057\u306A\u3044\u30A8\u30E9\u30FC: {message}"
+};
+
+// src/analyzer/search.ts
+function searchByPath(graph, pattern) {
+  const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(escaped, "i");
+  return Object.values(graph.files).filter((f) => regex.test(f.path)).map((f) => toSearchResult(f, t("search.pathMatch", { pattern })));
+}
+function findAffectedFiles(graph, filePath, maxDepth = 10) {
+  const node = findNode(graph, filePath);
+  if (!node) return [];
+  const visited = /* @__PURE__ */ new Set();
+  const results = [];
+  function traverse(current, depth, via) {
+    if (depth > maxDepth || visited.has(current.path)) return;
+    visited.add(current.path);
+    if (current.path !== node.path) {
+      results.push(
+        toSearchResult(
+          current,
+          t("search.affected", { file: filePath, via })
+        )
+      );
+    }
+    for (const depPath of current.dependents) {
+      const depNode = graph.files[depPath];
+      if (depNode) {
+        traverse(depNode, depth + 1, current.path);
+      }
+    }
+  }
+  traverse(node, 0, filePath);
+  return results;
+}
+function findCriticalFiles(graph, limit = 10) {
+  return Object.values(graph.files).filter((f) => f.dependents.length > 0).sort((a, b) => b.dependents.length - a.dependents.length).slice(0, limit).map(
+    (f) => toSearchResult(f, t("search.critical", { count: f.dependents.length }))
+  );
+}
+function findOrphanFiles(graph) {
+  return Object.values(graph.files).filter((f) => f.dependents.length === 0 && f.dependencies.length === 0).map((f) => toSearchResult(f, t("search.orphan")));
+}
+function findNode(graph, filePath) {
+  if (graph.files[filePath]) return graph.files[filePath];
+  const key = Object.keys(graph.files).find(
+    (k) => k.endsWith(filePath) || k.includes(filePath)
+  );
+  return key ? graph.files[key] : void 0;
+}
+function toSearchResult(node, matchReason) {
+  return {
+    file: node.path,
+    dependents: node.dependents,
+    dependencies: node.dependencies,
+    dependentCount: node.dependents.length,
+    dependencyCount: node.dependencies.length,
+    matchReason
+  };
+}
+
+// src/analyzer/report.ts
+function formatAnalysisReport(graph, options = {}) {
+  const topN = options.topN ?? 10;
+  const lines = [];
+  const files = Object.values(graph.files);
+  lines.push(t("analyze.title"));
+  lines.push(t("analyze.overview"));
+  lines.push(t("analyze.totalFiles", { count: graph.totalFiles }));
+  lines.push(t("analyze.totalEdges", { count: graph.totalEdges }));
+  lines.push(t("analyze.totalCircular", { count: graph.circularDependencies.length }));
+  const critical = files.filter((f) => f.dependents.length > 0).sort((a, b) => b.dependents.length - a.dependents.length).slice(0, topN);
+  if (critical.length > 0) {
+    lines.push(t("analyze.criticalTitle", { count: critical.length }));
+    for (const f of critical) {
+      lines.push(t("analyze.criticalItem", { path: f.path, count: f.dependents.length }));
+    }
+  }
+  if (graph.circularDependencies.length > 0) {
+    lines.push(t("analyze.circularTitle", { count: graph.circularDependencies.length }));
+    for (const c of graph.circularDependencies) {
+      lines.push(t("analyze.circularItem", { files: c.cycle.join(" \u2192 ") }));
+    }
+  }
+  const highCoupling = files.filter((f) => f.dependencies.length > 0).sort((a, b) => b.dependencies.length - a.dependencies.length).slice(0, topN);
+  if (highCoupling.length > 0) {
+    lines.push(t("analyze.couplingTitle", { count: highCoupling.length }));
+    for (const f of highCoupling) {
+      lines.push(t("analyze.couplingItem", { path: f.path, count: f.dependencies.length }));
+    }
+  }
+  const orphans = files.filter(
+    (f) => f.dependents.length === 0 && f.dependencies.length === 0
+  );
+  if (orphans.length > 0) {
+    lines.push(t("analyze.orphanTitle", { count: orphans.length }));
+    for (const f of orphans) {
+      lines.push(`  ${f.path}`);
+    }
+  }
+  const dirCounts = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const dir = f.path.includes("/") ? f.path.substring(0, f.path.lastIndexOf("/")) : ".";
+    dirCounts.set(dir, (dirCounts.get(dir) ?? 0) + 1);
+  }
+  if (dirCounts.size > 1) {
+    lines.push(t("analyze.layerTitle"));
+    const sorted = [...dirCounts.entries()].sort((a, b) => b[1] - a[1]);
+    for (const [dir, count] of sorted) {
+      lines.push(t("analyze.layerItem", { dir, count }));
+    }
+  }
+  if (graph.circularDependencies.length === 0 && orphans.length === 0) {
+    lines.push(t("analyze.noIssues"));
+  }
+  return lines.join("\n");
+}
+
+// src/storage/snapshot.ts
+import { mkdir, writeFile, readFile, access } from "fs/promises";
+import { join } from "path";
+import { z } from "zod";
+
+// src/types/schema.ts
+var SCHEMA_VERSION = "1.0";
+
+// src/storage/snapshot.ts
+var ARCHTRACKER_DIR = ".archtracker";
+var SNAPSHOT_FILE = "snapshot.json";
+var FileNodeSchema = z.object({
+  path: z.string(),
+  exists: z.boolean(),
+  dependencies: z.array(z.string()),
+  dependents: z.array(z.string())
+});
+var DependencyGraphSchema = z.object({
+  rootDir: z.string(),
+  files: z.record(z.string(), FileNodeSchema),
+  edges: z.array(z.object({
+    source: z.string(),
+    target: z.string(),
+    type: z.enum(["static", "dynamic", "type-only"])
+  })),
+  circularDependencies: z.array(z.object({ cycle: z.array(z.string()) })),
+  totalFiles: z.number(),
+  totalEdges: z.number()
+});
+var SnapshotSchema = z.object({
+  version: z.literal(SCHEMA_VERSION),
+  timestamp: z.string(),
+  rootDir: z.string(),
+  graph: DependencyGraphSchema
+});
+async function saveSnapshot(projectRoot, graph) {
+  const dirPath = join(projectRoot, ARCHTRACKER_DIR);
+  const filePath = join(dirPath, SNAPSHOT_FILE);
+  const snapshot = {
+    version: SCHEMA_VERSION,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    rootDir: graph.rootDir,
+    graph
+  };
+  await mkdir(dirPath, { recursive: true });
+  await writeFile(filePath, JSON.stringify(snapshot, null, 2), "utf-8");
+  return snapshot;
+}
+async function loadSnapshot(projectRoot) {
+  const filePath = join(projectRoot, ARCHTRACKER_DIR, SNAPSHOT_FILE);
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf-8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return null;
+    }
+    throw new StorageError(
+      t("storage.readFailed", { path: filePath }),
+      { cause: error }
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new StorageError(
+      t("storage.parseFailed", { path: filePath })
+    );
+  }
+  const result = SnapshotSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).slice(0, 5).join("\n");
+    throw new StorageError(
+      t("storage.invalidSchema", { issues })
+    );
+  }
+  return result.data;
+}
+var StorageError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "StorageError";
+  }
+};
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/storage/diff.ts
+function computeDiff(oldGraph, newGraph) {
+  const oldFiles = new Set(Object.keys(oldGraph.files));
+  const newFiles = new Set(Object.keys(newGraph.files));
+  const added = [...newFiles].filter((f) => !oldFiles.has(f));
+  const removed = [...oldFiles].filter((f) => !newFiles.has(f));
+  const modified = [];
+  for (const file of newFiles) {
+    if (!oldFiles.has(file)) continue;
+    const oldDeps = oldGraph.files[file].dependencies.slice().sort();
+    const newDeps = newGraph.files[file].dependencies.slice().sort();
+    if (!arraysEqual(oldDeps, newDeps)) {
+      modified.push(file);
+    }
+  }
+  const removedSet = new Set(removed);
+  const changedFiles = /* @__PURE__ */ new Set([...removed, ...modified]);
+  const affectedDependents = [];
+  const seenAffected = /* @__PURE__ */ new Set();
+  for (const changedFile of changedFiles) {
+    const graph = removedSet.has(changedFile) ? oldGraph : newGraph;
+    const node = graph.files[changedFile];
+    if (!node) continue;
+    for (const dependent of node.dependents) {
+      const key = `${dependent}\u2192${changedFile}`;
+      if (seenAffected.has(key)) continue;
+      seenAffected.add(key);
+      const reason = removedSet.has(changedFile) ? t("diff.reasonRemoved", { file: changedFile }) : t("diff.reasonModified", { file: changedFile });
+      affectedDependents.push({
+        file: dependent,
+        reason,
+        dependsOn: changedFile
+      });
+    }
+  }
+  for (const addedFile of added) {
+    const node = newGraph.files[addedFile];
+    if (!node) continue;
+    for (const dependent of node.dependents) {
+      const key = `${dependent}\u2192${addedFile}`;
+      if (seenAffected.has(key)) continue;
+      seenAffected.add(key);
+      affectedDependents.push({
+        file: dependent,
+        reason: t("diff.reasonAdded", { file: addedFile }),
+        dependsOn: addedFile
+      });
+    }
+  }
+  return { added, removed, modified, affectedDependents };
+}
+function formatDiffReport(diff) {
+  const lines = [];
+  lines.push(t("diff.title"));
+  if (diff.added.length === 0 && diff.removed.length === 0 && diff.modified.length === 0) {
+    lines.push(t("diff.noChanges"));
+    return lines.join("\n");
+  }
+  if (diff.added.length > 0) {
+    lines.push(t("diff.added", { count: diff.added.length }));
+    for (const f of diff.added) {
+      lines.push(`  + ${f}`);
+    }
+    lines.push("");
+  }
+  if (diff.removed.length > 0) {
+    lines.push(t("diff.removed", { count: diff.removed.length }));
+    for (const f of diff.removed) {
+      lines.push(`  - ${f}`);
+    }
+    lines.push("");
+  }
+  if (diff.modified.length > 0) {
+    lines.push(t("diff.modified", { count: diff.modified.length }));
+    for (const f of diff.modified) {
+      lines.push(`  ~ ${f}`);
+    }
+    lines.push("");
+  }
+  if (diff.affectedDependents.length > 0) {
+    lines.push(t("diff.affected", { count: diff.affectedDependents.length }));
+    for (const a of diff.affectedDependents) {
+      lines.push(`  ! ${a.file}`);
+      lines.push(`    ${a.reason}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function arraysEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+// src/utils/path-guard.ts
+import { resolve as resolve2 } from "path";
+function validatePath(inputPath, boundary) {
+  const resolved = resolve2(inputPath);
+  const root = boundary ? resolve2(boundary) : process.cwd();
+  if (!resolved.startsWith(root)) {
+    throw new PathTraversalError(
+      t("pathGuard.traversal", { input: inputPath, resolved, boundary: root })
+    );
+  }
+  return resolved;
+}
+var PathTraversalError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PathTraversalError";
+  }
+};
+
+// src/mcp/index.ts
+var server = new McpServer({
+  name: "archtracker",
+  version: "0.1.0"
+});
+server.tool(
+  "generate_map",
+  "Analyze dependency graph of a directory and return file import/export structure as JSON",
+  {
+    targetDir: z2.string().default("src").describe("Target directory path (default: src)"),
+    exclude: z2.array(z2.string()).optional().describe("Array of regex patterns to exclude (e.g. ['test', 'mock'])"),
+    maxDepth: z2.number().int().min(0).optional().describe("Max analysis depth (0 = unlimited)")
+  },
+  async ({ targetDir, exclude, maxDepth }) => {
+    try {
+      validatePath(targetDir);
+      const graph = await analyzeProject(targetDir, { exclude, maxDepth });
+      const summary = [
+        t("mcp.analyzeComplete", { files: graph.totalFiles, edges: graph.totalEdges }),
+        graph.circularDependencies.length > 0 ? t("mcp.circularFound", { count: graph.circularDependencies.length }) : t("mcp.circularNone")
+      ].join("\n");
+      return {
+        content: [
+          { type: "text", text: summary },
+          { type: "text", text: JSON.stringify(graph, null, 2) }
+        ]
+      };
+    } catch (error) {
+      return errorResponse(error);
+    }
+  }
+);
+server.tool(
+  "analyze_existing_architecture",
+  "Comprehensive architecture analysis for existing projects. Shows critical components, circular dependencies, orphan files, coupling hotspots, and directory breakdown.",
+  {
+    targetDir: z2.string().default("src").describe("Target directory path (default: src)"),
+    exclude: z2.array(z2.string()).optional().describe("Array of regex patterns to exclude"),
+    topN: z2.number().int().min(1).max(50).optional().describe("Number of top items to show in each section (default: 10)"),
+    saveSnapshot: z2.boolean().optional().describe("Also save a snapshot after analysis (default: false)"),
+    projectRoot: z2.string().default(".").describe("Project root (needed only when saveSnapshot is true)")
+  },
+  async ({ targetDir, exclude, topN, saveSnapshot: doSave, projectRoot }) => {
+    try {
+      validatePath(targetDir);
+      const graph = await analyzeProject(targetDir, { exclude });
+      const report = formatAnalysisReport(graph, { topN: topN ?? 10 });
+      const content = [
+        { type: "text", text: report }
+      ];
+      if (doSave) {
+        validatePath(projectRoot);
+        await saveSnapshot(projectRoot, graph);
+        content.push({ type: "text", text: t("analyze.snapshotSaved") });
+      }
+      return { content };
+    } catch (error) {
+      return errorResponse(error);
+    }
+  }
+);
+server.tool(
+  "save_architecture_snapshot",
+  "Save the current dependency graph as a snapshot to .archtracker/snapshot.json",
+  {
+    targetDir: z2.string().default("src").describe("Target directory path"),
+    projectRoot: z2.string().default(".").describe("Project root (where .archtracker is placed)")
+  },
+  async ({ targetDir, projectRoot }) => {
+    try {
+      validatePath(targetDir);
+      validatePath(projectRoot);
+      const graph = await analyzeProject(targetDir);
+      const snapshot = await saveSnapshot(projectRoot, graph);
+      const keyComponents = Object.values(graph.files).sort((a, b) => b.dependents.length - a.dependents.length).slice(0, 5).map((f) => `  ${t("cli.dependedBy", { path: f.path, count: f.dependents.length })}`);
+      const report = [
+        t("mcp.snapshotSaved"),
+        t("cli.timestamp", { ts: snapshot.timestamp }),
+        t("cli.fileCount", { count: graph.totalFiles }),
+        t("cli.edgeCount", { count: graph.totalEdges }),
+        "",
+        t("cli.keyComponents"),
+        ...keyComponents
+      ].join("\n");
+      return { content: [{ type: "text", text: report }] };
+    } catch (error) {
+      return errorResponse(error);
+    }
+  }
+);
+server.tool(
+  "check_architecture_diff",
+  "Compare saved snapshot with current code dependencies and warn about files that may need updates",
+  {
+    targetDir: z2.string().default("src").describe("Target directory path"),
+    projectRoot: z2.string().default(".").describe("Project root (where .archtracker is placed)")
+  },
+  async ({ targetDir, projectRoot }) => {
+    try {
+      validatePath(targetDir);
+      validatePath(projectRoot);
+      const existingSnapshot = await loadSnapshot(projectRoot);
+      if (!existingSnapshot) {
+        const graph = await analyzeProject(targetDir);
+        await saveSnapshot(projectRoot, graph);
+        return {
+          content: [
+            {
+              type: "text",
+              text: [
+                t("mcp.autoInit"),
+                t("cli.fileCount", { count: graph.totalFiles }) + ", " + t("cli.edgeCount", { count: graph.totalEdges }),
+                t("mcp.nextCheckEnabled")
+              ].join("\n")
+            }
+          ]
+        };
+      }
+      const currentGraph = await analyzeProject(targetDir);
+      const diff = computeDiff(existingSnapshot.graph, currentGraph);
+      const report = formatDiffReport(diff);
+      return { content: [{ type: "text", text: report }] };
+    } catch (error) {
+      return errorResponse(error);
+    }
+  }
+);
+server.tool(
+  "get_current_context",
+  "Get current valid file paths and architecture summary for AI session initialization",
+  {
+    targetDir: z2.string().default("src").describe("Target directory path"),
+    projectRoot: z2.string().default(".").describe("Project root")
+  },
+  async ({ targetDir, projectRoot }) => {
+    try {
+      let snapshot = await loadSnapshot(projectRoot);
+      if (!snapshot) {
+        const graph2 = await analyzeProject(targetDir);
+        snapshot = await saveSnapshot(projectRoot, graph2);
+      }
+      const graph = snapshot.graph;
+      const keyComponents = Object.values(graph.files).filter((f) => f.dependents.length > 0 || f.dependencies.length > 0).sort((a, b) => b.dependents.length - a.dependents.length).slice(0, 20).map((f) => ({
+        path: f.path,
+        dependentCount: f.dependents.length,
+        dependencyCount: f.dependencies.length
+      }));
+      const validPaths = Object.keys(graph.files).sort();
+      const summary = [
+        t("cli.project", { path: graph.rootDir }),
+        t("cli.fileCount", { count: graph.totalFiles }),
+        t("cli.edgeCount", { count: graph.totalEdges }),
+        t("cli.circularCount", { count: graph.circularDependencies.length }),
+        t("cli.snapshot", { ts: snapshot.timestamp }),
+        "",
+        t("cli.keyComponents"),
+        ...keyComponents.map(
+          (c) => `  ${t("cli.dependedBy", { path: c.path, count: c.dependentCount })}`
+        )
+      ].join("\n");
+      const context = {
+        validPaths,
+        summary,
+        snapshotExists: true,
+        snapshotTimestamp: snapshot.timestamp,
+        keyComponents
+      };
+      return {
+        content: [
+          { type: "text", text: summary },
+          {
+            type: "text",
+            text: JSON.stringify(context, null, 2)
+          }
+        ]
+      };
+    } catch (error) {
+      return errorResponse(error);
+    }
+  }
+);
+server.tool(
+  "search_architecture",
+  "Search architecture: file path search, impact analysis, critical component detection, orphan file detection",
+  {
+    query: z2.string().optional().describe("Search query (required for path/affected modes, not needed for critical/orphans)"),
+    mode: z2.enum(["path", "affected", "critical", "orphans"]).default("path").describe(
+      "Search mode: path=search by path, affected=change impact, critical=key files, orphans=isolated files"
+    ),
+    targetDir: z2.string().default("src").describe("Target directory path"),
+    projectRoot: z2.string().default(".").describe("Project root"),
+    limit: z2.number().int().min(1).max(50).optional().describe("Max results (default: 10)")
+  },
+  async ({ query, mode, targetDir, projectRoot, limit }) => {
+    try {
+      validatePath(targetDir);
+      validatePath(projectRoot);
+      let snapshot = await loadSnapshot(projectRoot);
+      if (!snapshot) {
+        const graph2 = await analyzeProject(targetDir);
+        snapshot = await saveSnapshot(projectRoot, graph2);
+      }
+      const graph = snapshot.graph;
+      const maxResults = limit ?? 10;
+      let results;
+      if ((mode === "path" || mode === "affected") && !query) {
+        return {
+          content: [{ type: "text", text: t("mcp.queryRequired", { mode }) }],
+          isError: true
+        };
+      }
+      switch (mode) {
+        case "path":
+          results = searchByPath(graph, query);
+          break;
+        case "affected":
+          results = findAffectedFiles(graph, query);
+          break;
+        case "critical":
+          results = findCriticalFiles(graph, maxResults);
+          break;
+        case "orphans":
+          results = findOrphanFiles(graph);
+          break;
+      }
+      if (results.length === 0) {
+        return {
+          content: [
+            { type: "text", text: t("search.noResults", { query: query ?? "", mode }) }
+          ]
+        };
+      }
+      const lines = [
+        t("search.results", { count: results.length, mode }),
+        "",
+        ...results.slice(0, maxResults).map((r) => {
+          return [
+            `  ${r.file}`,
+            `   ${r.matchReason}`,
+            `   deps: ${r.dependencyCount} -> [${r.dependencies.slice(0, 5).join(", ")}${r.dependencies.length > 5 ? "..." : ""}]`,
+            `   dependents: ${r.dependentCount} <- [${r.dependents.slice(0, 5).join(", ")}${r.dependents.length > 5 ? "..." : ""}]`
+          ].join("\n");
+        })
+      ];
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    } catch (error) {
+      return errorResponse(error);
+    }
+  }
+);
+function errorResponse(error) {
+  let message;
+  if (error instanceof PathTraversalError) {
+    message = t("error.pathTraversal", { message: error.message });
+  } else if (error instanceof AnalyzerError) {
+    message = t("error.analyzer", { message: error.message });
+  } else if (error instanceof StorageError) {
+    message = t("error.storage", { message: error.message });
+  } else if (error instanceof Error) {
+    message = t("error.generic", { message: error.message });
+  } else {
+    message = t("error.unexpected", { message: String(error) });
+  }
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[archtracker] MCP server running on stdio");
+}
+main().catch((error) => {
+  console.error("[archtracker] Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map