archtracker-mcp 0.5.0 → 0.6.0

package/dist/mcp/index.js

@@ -2226,44 +2226,139 @@ 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;
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/analyzer/resolve.ts
+async function resolveGraph(opts) {
+  const layerConfig = await loadLayerConfig(opts.projectRoot);
+  if (layerConfig) {
+    const multi = await analyzeMultiLayer(opts.projectRoot, layerConfig.layers);
+    const autoConnections = detectCrossLayerConnections(multi.layers, layerConfig.layers);
+    const manualConnections = layerConfig.connections ?? [];
+    const manualKeys = new Set(manualConnections.map(
+      (c) => `${c.fromLayer}/${c.fromFile}\u2192${c.toLayer}/${c.toFile}`
+    ));
+    const merged = [
+      ...manualConnections,
+      ...autoConnections.filter(
+        (c) => !manualKeys.has(`${c.fromLayer}/${c.fromFile}\u2192${c.toLayer}/${c.toFile}`)
+      )
+    ];
+    return {
+      graph: multi.merged,
+      multiLayer: multi,
+      layerMetadata: multi.layerMetadata,
+      crossLayerEdges: merged
+    };
+  }
+  const graph = await analyzeProject(opts.targetDir, {
+    exclude: opts.exclude,
+    language: opts.language
+  });
+  return { graph };
+}
+
+// src/storage/snapshot.ts
+import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile3, access } from "fs/promises";
+import { join as join6 } from "path";
+import { z as z2 } from "zod";
 
 // src/types/schema.ts
 var SCHEMA_VERSION = "1.1";
 
 // src/storage/snapshot.ts
-var ARCHTRACKER_DIR = ".archtracker";
+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 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);
+  const dirPath = join6(projectRoot, ARCHTRACKER_DIR2);
+  const filePath = join6(dirPath, SNAPSHOT_FILE);
   const snapshot = {
     version: SCHEMA_VERSION,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2271,17 +2366,17 @@ async function saveSnapshot(projectRoot, graph, multiLayer) {
     graph,
     ...multiLayer ? { multiLayer } : {}
   };
-  await mkdir(dirPath, { recursive: true });
-  await writeFile(filePath, JSON.stringify(snapshot, null, 2), "utf-8");
+  await mkdir2(dirPath, { recursive: true });
+  await writeFile2(filePath, JSON.stringify(snapshot, null, 2), "utf-8");
   return snapshot;
 }
 async function loadSnapshot(projectRoot) {
-  const filePath = join5(projectRoot, ARCHTRACKER_DIR, SNAPSHOT_FILE);
+  const filePath = join6(projectRoot, ARCHTRACKER_DIR2, SNAPSHOT_FILE);
   let raw;
   try {
-    raw = await readFile2(filePath, "utf-8");
+    raw = await readFile3(filePath, "utf-8");
   } catch (error) {
-    if (isNodeError(error) && error.code === "ENOENT") {
+    if (isNodeError2(error) && error.code === "ENOENT") {
       return null;
     }
     throw new StorageError(
@@ -2312,7 +2407,7 @@ var StorageError = class extends Error {
     this.name = "StorageError";
   }
 };
-function isNodeError(error) {
+function isNodeError2(error) {
   return error instanceof Error && "code" in error;
 }
 
@@ -2413,71 +2508,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;
-}
-function isNodeError2(error) {
-  return error instanceof Error && "code" in error;
-}
-
 // src/utils/path-guard.ts
 import { resolve as resolve5 } from "path";
 function validatePath(inputPath, boundary) {
@@ -2527,30 +2557,13 @@ var LANG_DISPLAY = {
   "c-sharp": "C#"
 };
 var languageList = LANGUAGE_IDS.map((id) => LANG_DISPLAY[id] ?? id.charAt(0).toUpperCase() + id.slice(1)).join(", ");
-async function resolveGraphForMcp(opts) {
-  if (opts.targetDir === "src") {
-    const layerConfig = await loadLayerConfig(opts.projectRoot);
-    if (layerConfig) {
-      const multi = await analyzeMultiLayer(opts.projectRoot, layerConfig.layers);
-      const autoConnections = detectCrossLayerConnections(multi.layers, layerConfig.layers);
-      const manualConnections = layerConfig.connections ?? [];
-      const manualKeys = new Set(manualConnections.map(
-        (c) => `${c.fromLayer}/${c.fromFile}\u2192${c.toLayer}/${c.toFile}`
-      ));
-      const allConnections = [
-        ...manualConnections,
-        ...autoConnections.filter(
-          (c) => !manualKeys.has(`${c.fromLayer}/${c.fromFile}\u2192${c.toLayer}/${c.toFile}`)
-        )
-      ];
-      return { graph: multi.merged, multiLayer: multi, layerMetadata: multi.layerMetadata, crossEdges: allConnections };
-    }
-  }
-  const graph = await analyzeProject(opts.targetDir, {
+async function resolveGraphMcp(opts) {
+  return resolveGraph({
+    targetDir: opts.targetDir,
+    projectRoot: opts.projectRoot,
     exclude: opts.exclude,
     language: opts.language
   });
-  return { graph };
 }
 function formatLayerSummary(metadata) {
   return metadata.map(
@@ -2564,14 +2577,13 @@ server.tool(
     targetDir: z3.string().default("src").describe("Target directory path (default: src). When layers.json exists and this is 'src', multi-layer analysis is used automatically."),
     projectRoot: z3.string().default(".").describe("Project root (where .archtracker/ is located)"),
     exclude: z3.array(z3.string()).optional().describe("Array of regex patterns to exclude (e.g. ['test', 'mock'])"),
-    maxDepth: z3.number().int().min(0).optional().describe("Max analysis depth (0 = unlimited)"),
     language: languageEnum.optional().describe("Target language (auto-detected if omitted)")
   },
-  async ({ targetDir, projectRoot, exclude, maxDepth, language }) => {
+  async ({ targetDir, projectRoot, exclude, language }) => {
     try {
       validatePath(targetDir);
       validatePath(projectRoot);
-      const { graph, layerMetadata, crossEdges } = await resolveGraphForMcp({
+      const { graph, layerMetadata, crossLayerEdges } = await resolveGraphMcp({
         targetDir,
         projectRoot,
         exclude,
@@ -2581,11 +2593,11 @@ server.tool(
         t("mcp.analyzeComplete", { files: graph.totalFiles, edges: graph.totalEdges }),
         graph.circularDependencies.length > 0 ? t("mcp.circularFound", { count: graph.circularDependencies.length }) : t("mcp.circularNone"),
         ...layerMetadata ? ["\nLayers:\n" + formatLayerSummary(layerMetadata)] : [],
-        ...crossEdges?.length ? [`
-Cross-layer connections: ${crossEdges.length}`] : []
+        ...crossLayerEdges?.length ? [`
+Cross-layer connections: ${crossLayerEdges.length}`] : []
       ].join("\n");
       const result = { ...graph };
-      if (crossEdges?.length) result.crossLayerConnections = crossEdges;
+      if (crossLayerEdges?.length) result.crossLayerConnections = crossLayerEdges;
       return {
         content: [
           { type: "text", text: summary },
@@ -2599,19 +2611,20 @@ Cross-layer connections: ${crossEdges.length}`] : []
 );
 server.tool(
   "analyze_existing_architecture",
-  `Comprehensive architecture analysis for existing projects. Shows critical components, circular dependencies, orphan files, coupling hotspots, and directory breakdown. Supports ${LANGUAGE_IDS.length} languages.`,
+  `Comprehensive architecture analysis for existing projects. Shows critical components, circular dependencies, orphan files, coupling hotspots, and directory breakdown. Supports ${languageList}.`,
   {
     targetDir: z3.string().default("src").describe("Target directory path (default: src)"),
     exclude: z3.array(z3.string()).optional().describe("Array of regex patterns to exclude"),
     topN: z3.number().int().min(1).max(50).optional().describe("Number of top items to show in each section (default: 10)"),
     saveSnapshot: z3.boolean().optional().describe("Also save a snapshot after analysis (default: false)"),
-    projectRoot: z3.string().default(".").describe("Project root (needed only when saveSnapshot is true)"),
+    projectRoot: z3.string().default(".").describe("Project root (where .archtracker/ is located)"),
     language: languageEnum.optional().describe("Target language (auto-detected if omitted)")
   },
   async ({ targetDir, exclude, topN, saveSnapshot: doSave, projectRoot, language }) => {
     try {
       validatePath(targetDir);
-      const { graph, multiLayer, layerMetadata, crossEdges } = await resolveGraphForMcp({
+      validatePath(projectRoot);
+      const { graph, multiLayer, layerMetadata, crossLayerEdges } = await resolveGraphMcp({
         targetDir,
         projectRoot,
         exclude,
@@ -2624,16 +2637,15 @@ server.tool(
       if (layerMetadata) {
         content.push({ type: "text", text: "\nLayers:\n" + formatLayerSummary(layerMetadata) });
       }
-      if (crossEdges?.length) {
-        const crossSummary = crossEdges.map(
+      if (crossLayerEdges?.length) {
+        const crossSummary = crossLayerEdges.map(
           (c) => `  ${c.fromLayer}/${c.fromFile} \u2192 ${c.toLayer}/${c.toFile} [${c.type}] ${c.label ?? ""}`
         ).join("\n");
         content.push({ type: "text", text: `
-Cross-layer connections (${crossEdges.length}):
+Cross-layer connections (${crossLayerEdges.length}):
 ${crossSummary}` });
       }
       if (doSave) {
-        validatePath(projectRoot);
         await saveSnapshot(projectRoot, graph, multiLayer);
         content.push({ type: "text", text: t("analyze.snapshotSaved") });
       }
@@ -2655,7 +2667,7 @@ server.tool(
     try {
       validatePath(targetDir);
       validatePath(projectRoot);
-      const { graph, multiLayer, layerMetadata } = await resolveGraphForMcp({
+      const { graph, multiLayer, layerMetadata } = await resolveGraphMcp({
         targetDir,
         projectRoot,
         language
@@ -2692,7 +2704,7 @@ server.tool(
       validatePath(projectRoot);
       const existingSnapshot = await loadSnapshot(projectRoot);
       if (!existingSnapshot) {
-        const { graph, multiLayer } = await resolveGraphForMcp({
+        const { graph, multiLayer } = await resolveGraphMcp({
           targetDir,
           projectRoot,
           language
@@ -2711,7 +2723,7 @@ server.tool(
           ]
         };
       }
-      const { graph: currentGraph } = await resolveGraphForMcp({
+      const { graph: currentGraph } = await resolveGraphMcp({
         targetDir,
         projectRoot,
         language
@@ -2734,9 +2746,11 @@ server.tool(
   },
   async ({ targetDir, projectRoot, language }) => {
     try {
+      validatePath(targetDir);
+      validatePath(projectRoot);
       let snapshot = await loadSnapshot(projectRoot);
       if (!snapshot) {
-        const { graph: graph2, multiLayer } = await resolveGraphForMcp({
+        const { graph: graph2, multiLayer } = await resolveGraphMcp({
           targetDir,
           projectRoot,
           language
@@ -2802,7 +2816,7 @@ server.tool(
       validatePath(projectRoot);
       let snapshot = await loadSnapshot(projectRoot);
       if (!snapshot) {
-        const { graph: graph2, multiLayer } = await resolveGraphForMcp({
+        const { graph: graph2, multiLayer } = await resolveGraphMcp({
           targetDir,
           projectRoot,
           language