archtracker-mcp 0.5.0 → 0.7.0

package/dist/index.d.ts

@@ -56,6 +56,12 @@ interface ArchSnapshot {
     graph: DependencyGraph;
     /** Present only when layers.json was used */
     multiLayer?: MultiLayerGraph;
+    /** Analysis options used to generate this snapshot (for diff consistency checks) */
+    analysisOptions?: {
+        targetDir?: string;
+        language?: string;
+        exclude?: string[];
+    };
 }
 /** Diff result between two snapshots */
 interface ArchDiff {
@@ -156,7 +162,7 @@ declare function formatAnalysisReport(graph: DependencyGraph, options?: {
  * Each layer is analyzed independently via analyzeProject().
  * Results are merged into a unified graph with layer-prefixed node paths.
  */
-declare function analyzeMultiLayer(projectRoot: string, layerDefs: LayerDefinition[]): Promise<MultiLayerGraph>;
+declare function analyzeMultiLayer(projectRoot: string, layerDefs: LayerDefinition[], globalExclude?: string[]): Promise<MultiLayerGraph>;
 /**
  * Auto-detect cross-layer connections by scanning file contents
  * for references to identifiers defined in other layers.
@@ -180,7 +186,11 @@ declare function detectCrossLayerConnections(layers: Record<string, DependencyGr
  * Creates .archtracker/ directory if it doesn't exist.
  * Writes snapshot.json with schema version and timestamp.
  */
-declare function saveSnapshot(projectRoot: string, graph: DependencyGraph, multiLayer?: MultiLayerGraph): Promise<ArchSnapshot>;
+declare function saveSnapshot(projectRoot: string, graph: DependencyGraph, multiLayer?: MultiLayerGraph, analysisOptions?: {
+    targetDir?: string;
+    language?: string;
+    exclude?: string[];
+}): Promise<ArchSnapshot>;
 /**
  * Load the most recent snapshot from .archtracker/snapshot.json.
  *

package/dist/index.js

@@ -1564,6 +1564,8 @@ var en = {
   "diff.reasonRemoved": 'Dependency "{file}" was removed',
   "diff.reasonModified": 'Dependency "{file}" had its dependencies changed',
   "diff.reasonAdded": 'New dependency "{file}" was added',
+  "diff.testSummary": "  ... and {count} test/fixture file(s)",
+  "diff.testAffectedSummary": "  ... and {count} test/fixture-related review(s)",
   // Search
   "search.pathMatch": 'Path matches "{pattern}"',
   "search.affected": 'May be affected by changes to "{file}" (via: {via})',
@@ -1625,6 +1627,12 @@ var en = {
   "web.watching": "Watching {dir}/ for changes...",
   "web.reloading": "File change detected, reloading...",
   "web.reloaded": "Graph reloaded",
+  // History
+  "history.title": "# Snapshot History\n",
+  "history.empty": "No snapshots found. Run `archtracker init` to create one.",
+  "history.entry": "  {ts}  |  {files} files, {edges} edges, {circular} circular{layers}",
+  "history.count": "{count} snapshot(s) recorded",
+  "history.snapshotNotFound": "Snapshot not found for timestamp: {ts}",
   // Errors
   "error.analyzer": "[Analysis Error] {message}",
   "error.storage": "[Storage Error] {message}",
@@ -1657,6 +1665,8 @@ var ja = {
   "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',
+  "diff.testSummary": "  ... \u4ED6 {count}\u4EF6\u306E\u30C6\u30B9\u30C8/\u30D5\u30A3\u30AF\u30B9\u30C1\u30E3\u30D5\u30A1\u30A4\u30EB",
+  "diff.testAffectedSummary": "  ... \u4ED6 {count}\u4EF6\u306E\u30C6\u30B9\u30C8/\u30D5\u30A3\u30AF\u30B9\u30C1\u30E3\u95A2\u9023\u306E\u78BA\u8A8D\u9805\u76EE",
   // 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',
@@ -1718,6 +1728,12 @@ var ja = {
   "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",
+  // History
+  "history.title": "# \u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u5C65\u6B74\n",
+  "history.empty": "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002`archtracker init` \u3067\u4F5C\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+  "history.entry": "  {ts}  |  {files}\u30D5\u30A1\u30A4\u30EB, {edges}\u30A8\u30C3\u30B8, \u5FAA\u74B0{circular}\u4EF6{layers}",
+  "history.count": "{count}\u4EF6\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3092\u8A18\u9332",
+  "history.snapshotNotFound": "\u6307\u5B9A\u306E\u30BF\u30A4\u30E0\u30B9\u30BF\u30F3\u30D7\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: {ts}",
   // Errors
   "error.analyzer": "[\u89E3\u6790\u30A8\u30E9\u30FC] {message}",
   "error.storage": "[\u30B9\u30C8\u30EC\u30FC\u30B8\u30A8\u30E9\u30FC] {message}",
@@ -1802,14 +1818,14 @@ var LAYER_COLORS = [
   "#ffa657",
   "#7ee787"
 ];
-async function analyzeMultiLayer(projectRoot, layerDefs) {
+async function analyzeMultiLayer(projectRoot, layerDefs, globalExclude) {
   const layers = {};
   const layerMetadata = [];
   for (let idx = 0; idx < layerDefs.length; idx++) {
     const def = layerDefs[idx];
     const targetDir = resolve4(projectRoot, def.targetDir);
     const graph = await analyzeProject(targetDir, {
-      exclude: def.exclude,
+      exclude: def.exclude ?? globalExclude,
       language: def.language
     });
     const language = def.language ?? await detectLanguage(targetDir) ?? "javascript";
@@ -2170,57 +2186,144 @@ function mergeLayerGraphs(projectRoot, layers) {
   };
 }
 
-// src/storage/snapshot.ts
-import { mkdir, writeFile, readFile as readFile2, access } from "fs/promises";
+// src/storage/layers.ts
+import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
 import { join as join5 } from "path";
 import { z } from "zod";
 var ARCHTRACKER_DIR = ".archtracker";
+var LAYERS_FILE = "layers.json";
+var LayerDefinitionSchema = z.object({
+  name: z.string().min(1).regex(
+    /^[a-zA-Z0-9_-]+$/,
+    "Layer name must be alphanumeric (hyphens/underscores allowed)"
+  ),
+  targetDir: z.string().min(1),
+  language: z.enum(LANGUAGE_IDS).optional(),
+  exclude: z.array(z.string()).optional(),
+  color: z.string().optional(),
+  description: z.string().optional()
+});
+var CrossLayerConnectionSchema = z.object({
+  fromLayer: z.string(),
+  fromFile: z.string(),
+  toLayer: z.string(),
+  toFile: z.string(),
+  type: z.enum(["api-call", "event", "data-flow", "manual"]),
+  label: z.string().optional()
+});
+var LayerConfigSchema = z.object({
+  version: z.literal("1.0"),
+  layers: z.array(LayerDefinitionSchema).min(1).refine(
+    (layers) => {
+      const names = layers.map((l) => l.name);
+      return new Set(names).size === names.length;
+    },
+    { message: "Layer names must be unique" }
+  ),
+  connections: z.array(CrossLayerConnectionSchema).optional()
+});
+async function loadLayerConfig(projectRoot) {
+  const filePath = join5(projectRoot, ARCHTRACKER_DIR, LAYERS_FILE);
+  let raw;
+  try {
+    raw = await readFile2(filePath, "utf-8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return null;
+    }
+    throw new Error(`Failed to read ${filePath}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in ${filePath}`);
+  }
+  const result = LayerConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).slice(0, 5).join("\n");
+    throw new Error(`layers.json validation failed:
+${issues}`);
+  }
+  return result.data;
+}
+async function saveLayerConfig(projectRoot, config) {
+  const dirPath = join5(projectRoot, ARCHTRACKER_DIR);
+  const filePath = join5(dirPath, LAYERS_FILE);
+  await mkdir(dirPath, { recursive: true });
+  await writeFile(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/storage/graph-cache.ts
+import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2, stat as stat4 } from "fs/promises";
+import { join as join6, resolve as resolve5 } from "path";
+import { readdir as readdir3 } from "fs/promises";
+import { createHash } from "crypto";
+
+// src/storage/snapshot.ts
+import { mkdir as mkdir3, writeFile as writeFile3, readFile as readFile4, readdir as readdir4, access } from "fs/promises";
+import { join as join7 } from "path";
+import { z as z2 } from "zod";
+var ARCHTRACKER_DIR2 = ".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 HISTORY_DIR = "history";
+var FileNodeSchema = z2.object({
+  path: z2.string(),
+  exists: z2.boolean(),
+  dependencies: z2.array(z2.string()),
+  dependents: z2.array(z2.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"])
+var DependencyGraphSchema = z2.object({
+  rootDir: z2.string(),
+  files: z2.record(z2.string(), FileNodeSchema),
+  edges: z2.array(z2.object({
+    source: z2.string(),
+    target: z2.string(),
+    type: z2.enum(["static", "dynamic", "type-only"])
   })),
-  circularDependencies: z.array(z.object({ cycle: z.array(z.string()) })),
-  totalFiles: z.number(),
-  totalEdges: z.number()
+  circularDependencies: z2.array(z2.object({ cycle: z2.array(z2.string()) })),
+  totalFiles: z2.number(),
+  totalEdges: z2.number()
 });
-var SnapshotSchema = z.object({
-  version: z.enum([SCHEMA_VERSION, "1.0"]),
-  timestamp: z.string(),
-  rootDir: z.string(),
+var SnapshotSchema = z2.object({
+  version: z2.enum([SCHEMA_VERSION, "1.0"]),
+  timestamp: z2.string(),
+  rootDir: z2.string(),
   graph: DependencyGraphSchema
 });
-async function saveSnapshot(projectRoot, graph, multiLayer) {
-  const dirPath = join5(projectRoot, ARCHTRACKER_DIR);
-  const filePath = join5(dirPath, SNAPSHOT_FILE);
+async function saveSnapshot(projectRoot, graph, multiLayer, analysisOptions) {
+  const dirPath = join7(projectRoot, ARCHTRACKER_DIR2);
+  const filePath = join7(dirPath, SNAPSHOT_FILE);
   const snapshot = {
     version: SCHEMA_VERSION,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     rootDir: graph.rootDir,
     graph,
-    ...multiLayer ? { multiLayer } : {}
+    ...multiLayer ? { multiLayer } : {},
+    ...analysisOptions ? { analysisOptions } : {}
   };
-  await mkdir(dirPath, { recursive: true });
-  await writeFile(filePath, JSON.stringify(snapshot, null, 2), "utf-8");
+  await mkdir3(dirPath, { recursive: true });
+  const json = JSON.stringify(snapshot, null, 2);
+  await writeFile3(filePath, json, "utf-8");
+  try {
+    const historyPath = join7(dirPath, HISTORY_DIR);
+    await mkdir3(historyPath, { recursive: true });
+    const safeTs = snapshot.timestamp.replace(/[:.]/g, "-");
+    await writeFile3(join7(historyPath, `${safeTs}.json`), json, "utf-8");
+  } catch {
+  }
   return snapshot;
 }
 async function loadSnapshot(projectRoot) {
-  const filePath = join5(projectRoot, ARCHTRACKER_DIR, SNAPSHOT_FILE);
+  const filePath = join7(projectRoot, ARCHTRACKER_DIR2, SNAPSHOT_FILE);
   let raw;
   try {
-    raw = await readFile2(filePath, "utf-8");
+    raw = await readFile4(filePath, "utf-8");
   } catch (error) {
-    if (isNodeError(error) && error.code === "ENOENT") {
+    if (isNodeError2(error) && error.code === "ENOENT") {
       return null;
     }
     throw new StorageError(
@@ -2247,7 +2350,7 @@ async function loadSnapshot(projectRoot) {
 }
 async function hasArchtrackerDir(projectRoot) {
   try {
-    await access(join5(projectRoot, ARCHTRACKER_DIR));
+    await access(join7(projectRoot, ARCHTRACKER_DIR2));
     return true;
   } catch {
     return false;
@@ -2259,7 +2362,7 @@ var StorageError = class extends Error {
     this.name = "StorageError";
   }
 };
-function isNodeError(error) {
+function isNodeError2(error) {
   return error instanceof Error && "code" in error;
 }
 
@@ -2314,6 +2417,17 @@ function computeDiff(oldGraph, newGraph) {
   }
   return { added, removed, modified, affectedDependents };
 }
+function isTestOrFixture(path) {
+  return /(__fixtures__|__tests__|__mocks__|\.test\.|\.spec\.|\.e2e\.)/.test(path);
+}
+function partition(arr, pred) {
+  const yes = [];
+  const no = [];
+  for (const item of arr) {
+    (pred(item) ? yes : no).push(item);
+  }
+  return [yes, no];
+}
 function formatDiffReport(diff) {
   const lines = [];
   lines.push(t("diff.title"));
@@ -2322,32 +2436,51 @@ function formatDiffReport(diff) {
     return lines.join("\n");
   }
   if (diff.added.length > 0) {
+    const [testFiles, srcFiles] = partition(diff.added, isTestOrFixture);
     lines.push(t("diff.added", { count: diff.added.length }));
-    for (const f of diff.added) {
+    for (const f of srcFiles) {
       lines.push(`  + ${f}`);
     }
+    if (testFiles.length > 0) {
+      lines.push(t("diff.testSummary", { count: testFiles.length }));
+    }
     lines.push("");
   }
   if (diff.removed.length > 0) {
+    const [testFiles, srcFiles] = partition(diff.removed, isTestOrFixture);
     lines.push(t("diff.removed", { count: diff.removed.length }));
-    for (const f of diff.removed) {
+    for (const f of srcFiles) {
       lines.push(`  - ${f}`);
     }
+    if (testFiles.length > 0) {
+      lines.push(t("diff.testSummary", { count: testFiles.length }));
+    }
     lines.push("");
   }
   if (diff.modified.length > 0) {
+    const [testFiles, srcFiles] = partition(diff.modified, isTestOrFixture);
     lines.push(t("diff.modified", { count: diff.modified.length }));
-    for (const f of diff.modified) {
+    for (const f of srcFiles) {
       lines.push(`  ~ ${f}`);
     }
+    if (testFiles.length > 0) {
+      lines.push(t("diff.testSummary", { count: testFiles.length }));
+    }
     lines.push("");
   }
   if (diff.affectedDependents.length > 0) {
+    const [testEntries, srcEntries] = partition(
+      diff.affectedDependents,
+      (a) => isTestOrFixture(a.file) || isTestOrFixture(a.dependsOn)
+    );
     lines.push(t("diff.affected", { count: diff.affectedDependents.length }));
-    for (const a of diff.affectedDependents) {
+    for (const a of srcEntries) {
       lines.push(`  ! ${a.file}`);
       lines.push(`    ${a.reason}`);
     }
+    if (testEntries.length > 0) {
+      lines.push(t("diff.testAffectedSummary", { count: testEntries.length }));
+    }
     lines.push("");
   }
   return lines.join("\n");
@@ -2359,77 +2492,6 @@ function arraysEqual(a, b) {
   }
   return true;
 }
-
-// src/storage/layers.ts
-import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join6 } from "path";
-import { z as z2 } from "zod";
-var ARCHTRACKER_DIR2 = ".archtracker";
-var LAYERS_FILE = "layers.json";
-var LayerDefinitionSchema = z2.object({
-  name: z2.string().min(1).regex(
-    /^[a-zA-Z0-9_-]+$/,
-    "Layer name must be alphanumeric (hyphens/underscores allowed)"
-  ),
-  targetDir: z2.string().min(1),
-  language: z2.enum(LANGUAGE_IDS).optional(),
-  exclude: z2.array(z2.string()).optional(),
-  color: z2.string().optional(),
-  description: z2.string().optional()
-});
-var CrossLayerConnectionSchema = z2.object({
-  fromLayer: z2.string(),
-  fromFile: z2.string(),
-  toLayer: z2.string(),
-  toFile: z2.string(),
-  type: z2.enum(["api-call", "event", "data-flow", "manual"]),
-  label: z2.string().optional()
-});
-var LayerConfigSchema = z2.object({
-  version: z2.literal("1.0"),
-  layers: z2.array(LayerDefinitionSchema).min(1).refine(
-    (layers) => {
-      const names = layers.map((l) => l.name);
-      return new Set(names).size === names.length;
-    },
-    { message: "Layer names must be unique" }
-  ),
-  connections: z2.array(CrossLayerConnectionSchema).optional()
-});
-async function loadLayerConfig(projectRoot) {
-  const filePath = join6(projectRoot, ARCHTRACKER_DIR2, LAYERS_FILE);
-  let raw;
-  try {
-    raw = await readFile3(filePath, "utf-8");
-  } catch (error) {
-    if (isNodeError2(error) && error.code === "ENOENT") {
-      return null;
-    }
-    throw new Error(`Failed to read ${filePath}`);
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error(`Invalid JSON in ${filePath}`);
-  }
-  const result = LayerConfigSchema.safeParse(parsed);
-  if (!result.success) {
-    const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).slice(0, 5).join("\n");
-    throw new Error(`layers.json validation failed:
-${issues}`);
-  }
-  return result.data;
-}
-async function saveLayerConfig(projectRoot, config) {
-  const dirPath = join6(projectRoot, ARCHTRACKER_DIR2);
-  const filePath = join6(dirPath, LAYERS_FILE);
-  await mkdir2(dirPath, { recursive: true });
-  await writeFile2(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-}
-function isNodeError2(error) {
-  return error instanceof Error && "code" in error;
-}
 export {
   AnalyzerError,
   SCHEMA_VERSION,