mason-context 0.1.0 → 0.2.0

package/dist/bin/mason-mcp.js

@@ -1,4 +1,201 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/impact/impact.ts
+var impact_exports = {};
+__export(impact_exports, {
+  analyzeImpact: () => analyzeImpact
+});
+import fs5 from "fs/promises";
+import path4 from "path";
+import { execFile as execFile7 } from "child_process";
+import { promisify as promisify7 } from "util";
+import fg3 from "fast-glob";
+async function analyzeImpact(rootDir, targetFiles) {
+  const resolvedRoot = path4.resolve(rootDir);
+  const resolvedTargets = await resolveTargetFiles(resolvedRoot, targetFiles);
+  const [cochange, references, tests] = await Promise.all([
+    getCochangeFiles(resolvedRoot, resolvedTargets),
+    getReferences(resolvedRoot, resolvedTargets),
+    getRelatedTests(resolvedRoot, resolvedTargets)
+  ]);
+  return {
+    targetFiles: resolvedTargets,
+    cochange,
+    references,
+    tests
+  };
+}
+async function resolveTargetFiles(rootDir, targets) {
+  const resolved = [];
+  for (const target of targets) {
+    if (target.includes("/")) {
+      resolved.push(target);
+      continue;
+    }
+    const matches = await fg3(`**/${target}`, {
+      cwd: rootDir,
+      ignore: IGNORE
+    });
+    if (matches.length > 0) {
+      resolved.push(matches[0]);
+    } else {
+      const noExt = target.replace(/\.[^.]+$/, "");
+      const extMatches = await fg3(`**/${noExt}.*`, {
+        cwd: rootDir,
+        ignore: IGNORE
+      });
+      if (extMatches.length > 0) {
+        resolved.push(extMatches[0]);
+      } else {
+        resolved.push(target);
+      }
+    }
+  }
+  return resolved;
+}
+async function getCochangeFiles(rootDir, targetFiles) {
+  const cochangeCounts = /* @__PURE__ */ new Map();
+  let totalTargetCommits = 0;
+  for (const targetFile of targetFiles) {
+    try {
+      const { stdout: commitLog } = await exec7(
+        "git",
+        ["log", "--format=%H", "-n", "500", "--", targetFile],
+        { cwd: rootDir, maxBuffer: 5e6 }
+      );
+      const commits = commitLog.trim().split("\n").filter(Boolean);
+      totalTargetCommits += commits.length;
+      if (commits.length === 0) continue;
+      for (const commit of commits) {
+        try {
+          const { stdout: filesInCommit } = await exec7(
+            "git",
+            ["diff-tree", "--no-commit-id", "--name-only", "-r", commit],
+            { cwd: rootDir }
+          );
+          const files = filesInCommit.trim().split("\n").filter(Boolean);
+          for (const file of files) {
+            if (targetFiles.includes(file)) continue;
+            cochangeCounts.set(file, (cochangeCounts.get(file) ?? 0) + 1);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  if (totalTargetCommits === 0) return [];
+  return [...cochangeCounts.entries()].map(([file, count]) => ({
+    file,
+    cochangeRate: Math.round(count / totalTargetCommits * 100) / 100,
+    sharedCommits: count
+  })).filter((e) => e.cochangeRate >= 0.3 || e.sharedCommits >= 3).sort((a, b) => b.cochangeRate - a.cochangeRate).slice(0, 20);
+}
+async function getReferences(rootDir, targetFiles) {
+  const searchNames = /* @__PURE__ */ new Set();
+  for (const target of targetFiles) {
+    const basename = path4.basename(target).replace(/\.[^.]+$/, "");
+    searchNames.add(basename);
+  }
+  const allSourceFiles = await fg3(`**/${SOURCE_EXTENSIONS2}`, {
+    cwd: rootDir,
+    ignore: IGNORE
+  });
+  const targetSet = new Set(targetFiles);
+  const filesToSearch = allSourceFiles.filter((f) => !targetSet.has(f));
+  const results = /* @__PURE__ */ new Map();
+  const batchSize = 50;
+  for (let i = 0; i < filesToSearch.length; i += batchSize) {
+    const batch = filesToSearch.slice(i, i + batchSize);
+    await Promise.all(
+      batch.map(async (file) => {
+        try {
+          const content = await fs5.readFile(
+            path4.join(rootDir, file),
+            "utf-8"
+          );
+          for (const name of searchNames) {
+            const regex = new RegExp(`\\b${escapeRegex(name)}\\b`);
+            if (regex.test(content)) {
+              if (!results.has(file)) results.set(file, /* @__PURE__ */ new Set());
+              results.get(file).add(name);
+            }
+          }
+        } catch {
+        }
+      })
+    );
+  }
+  return [...results.entries()].map(([file, matches]) => ({
+    file,
+    matches: [...matches]
+  })).sort((a, b) => b.matches.length - a.matches.length);
+}
+async function getRelatedTests(rootDir, targetFiles) {
+  const testPatterns = [
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/*Test.kt",
+    "**/*Test.java",
+    "**/*Tests.kt",
+    "**/*Tests.java",
+    "**/test_*.py",
+    "**/*_test.py",
+    "**/*_test.go",
+    "**/*Tests.swift",
+    "**/*Test.swift",
+    "**/*_test.rs"
+  ];
+  const testFiles = await fg3(testPatterns, { cwd: rootDir, ignore: IGNORE });
+  const results = [];
+  for (const target of targetFiles) {
+    const targetBaseName = path4.basename(target).replace(/\.[^.]+$/, "");
+    for (const testFile of testFiles) {
+      const testBaseName = path4.basename(testFile).replace(/\.[^.]+$/, "");
+      const sourceName = testBaseName.replace(/Test$|Tests$|Spec$|\.test$|\.spec$/, "").replace(/^test_|_test$/, "");
+      if (sourceName === targetBaseName) {
+        results.push({
+          file: testFile,
+          confidence: "exact"
+        });
+      }
+    }
+  }
+  return results;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var exec7, IGNORE, SOURCE_EXTENSIONS2;
+var init_impact = __esm({
+  "src/impact/impact.ts"() {
+    "use strict";
+    exec7 = promisify7(execFile7);
+    IGNORE = [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.gradle/**",
+      "**/target/**",
+      "**/.git/**",
+      "**/vendor/**",
+      "**/__pycache__/**",
+      "**/venv/**",
+      "**/.venv/**",
+      "**/generated/**"
+    ];
+    SOURCE_EXTENSIONS2 = "*.{ts,tsx,js,jsx,kt,kts,java,py,go,rs,swift,rb,cs,cpp,c,h,dart,gradle.kts,gradle}";
+  }
+});
 
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -6,11 +203,11 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 
 // src/mcp/tools.ts
-import fs5 from "fs/promises";
-import path4 from "path";
-import { execFile as execFile7 } from "child_process";
-import { promisify as promisify7 } from "util";
-import fg3 from "fast-glob";
+import fs6 from "fs/promises";
+import path5 from "path";
+import { execFile as execFile8 } from "child_process";
+import { promisify as promisify8 } from "util";
+import fg4 from "fast-glob";
 
 // src/analyzers/git-history.ts
 import { execFile } from "child_process";
@@ -398,6 +595,8 @@ async function sampleFiles(rootDir, maxFiles = 25) {
   const ignorePatterns = [...IGNORE_PATTERNS, ...projectConfig.ignore ?? []];
   for (const filePath of projectConfig.alwaysInclude ?? []) {
     if (selected.size >= maxFiles) break;
+    const resolvedPath = path.resolve(rootDir, filePath);
+    if (!resolvedPath.startsWith(path.resolve(rootDir))) continue;
     selected.set(filePath, "always-include (project config)");
   }
   let configCount = 0;
@@ -569,7 +768,9 @@ async function sampleFiles(rootDir, maxFiles = 25) {
   const results = [];
   for (const [filePath, reason] of selected) {
     try {
-      const fullPath = path.join(rootDir, filePath);
+      const fullPath = path.resolve(rootDir, filePath);
+      if (!fullPath.startsWith(path.resolve(rootDir))) continue;
+      if (isSensitiveFile(filePath)) continue;
       const stat = await fs2.stat(fullPath);
       if (stat.size > 1e5) continue;
       const content = await fs2.readFile(fullPath, "utf-8");
@@ -587,19 +788,24 @@ async function sampleFiles(rootDir, maxFiles = 25) {
   }
   return results;
 }
-async function readFullFile(rootDir, filePath) {
-  try {
-    const fullPath = path.join(path.resolve(rootDir), filePath);
-    if (!fullPath.startsWith(path.resolve(rootDir))) return null;
-    const content = await fs2.readFile(fullPath, "utf-8");
-    return {
-      path: filePath,
-      content,
-      totalLines: content.split("\n").length
-    };
-  } catch {
-    return null;
-  }
+var SENSITIVE_PATTERNS = [
+  /^\.env$/,
+  /^\.env\./,
+  /\.pem$/,
+  /\.key$/,
+  /\.p12$/,
+  /\.pfx$/,
+  /\.jks$/,
+  /id_rsa/,
+  /id_ed25519/,
+  /credentials\./,
+  /secret/i,
+  /\.keystore$/,
+  /local\.properties$/
+];
+function isSensitiveFile(filePath) {
+  const basename = path.basename(filePath);
+  return SENSITIVE_PATTERNS.some((p) => p.test(basename));
 }
 
 // src/snapshot/snapshot.ts
@@ -663,8 +869,8 @@ async function getCurrentGitHash(rootDir) {
 }
 
 // src/mcp/tools.ts
-var exec7 = promisify7(execFile7);
-var IGNORE = [
+var exec8 = promisify8(execFile8);
+var IGNORE2 = [
   "**/node_modules/**",
   "**/dist/**",
   "**/build/**",
@@ -685,7 +891,7 @@ async function buildContext(dir) {
   };
 }
 async function analyzeProject(dir) {
-  const rootDir = path4.resolve(dir);
+  const rootDir = path5.resolve(dir);
   const context = await buildContext(rootDir);
   const results = await runAll(context);
   const projectSnapshot = await detectProjectSnapshot(rootDir);
@@ -739,7 +945,7 @@ async function detectProjectSnapshot(rootDir) {
   const present = [];
   for (const file of buildFiles) {
     try {
-      await fs5.access(path4.join(rootDir, file));
+      await fs6.access(path5.join(rootDir, file));
       present.push(file);
     } catch {
     }
@@ -757,9 +963,9 @@ async function detectProjectSnapshot(rootDir) {
   ];
   const testInfo = {};
   for (const pattern of testDirs) {
-    const files = await fg3(`${pattern}/**/*`, {
+    const files = await fg4(`${pattern}/**/*`, {
       cwd: rootDir,
-      ignore: IGNORE,
+      ignore: IGNORE2,
       onlyFiles: true
     });
     if (files.length > 0) {
@@ -777,18 +983,18 @@ async function detectProjectSnapshot(rootDir) {
     { pattern: "**/*_test.rs", label: "*_test.rs" }
   ];
   for (const { pattern, label } of testFilePatterns) {
-    const files = await fg3(pattern, { cwd: rootDir, ignore: IGNORE });
+    const files = await fg4(pattern, { cwd: rootDir, ignore: IGNORE2 });
     if (files.length > 0) {
       testInfo[label] = files.length;
     }
   }
-  const sourceFiles = await fg3("**/*.{ts,tsx,js,jsx,kt,kts,java,py,go,rs,swift,rb,cs,cpp,c,dart}", {
+  const sourceFiles = await fg4("**/*.{ts,tsx,js,jsx,kt,kts,java,py,go,rs,swift,rb,cs,cpp,c,dart}", {
     cwd: rootDir,
-    ignore: IGNORE
+    ignore: IGNORE2
   });
   const fileCounts = {};
   for (const file of sourceFiles) {
-    const ext = path4.extname(file).slice(1);
+    const ext = path5.extname(file).slice(1);
     fileCounts[ext] = (fileCounts[ext] ?? 0) + 1;
   }
   return {
@@ -799,7 +1005,7 @@ async function detectProjectSnapshot(rootDir) {
   };
 }
 async function getCodeSamples(dir, count = 15) {
-  const rootDir = path4.resolve(dir);
+  const rootDir = path5.resolve(dir);
   const samples = await sampleFiles(rootDir, count);
   const output = {
     note: "These are previews (first ~60 lines). Use get_file_content to read the full file if needed.",
@@ -813,19 +1019,11 @@ async function getCodeSamples(dir, count = 15) {
   };
   return JSON.stringify(output, null, 2);
 }
-async function getFileContent(dir, filePath) {
-  const rootDir = path4.resolve(dir);
-  const result = await readFullFile(rootDir, filePath);
-  if (!result) {
-    return JSON.stringify({ error: `Could not read file: ${filePath}` });
-  }
-  return JSON.stringify(result, null, 2);
-}
 async function getProjectStructure(dir) {
-  const rootDir = path4.resolve(dir);
-  const allFiles = await fg3("**/*", {
+  const rootDir = path5.resolve(dir);
+  const allFiles = await fg4("**/*", {
     cwd: rootDir,
-    ignore: IGNORE,
+    ignore: IGNORE2,
     onlyFiles: true
   });
   const dirInfo = /* @__PURE__ */ new Map();
@@ -838,7 +1036,7 @@ async function getProjectStructure(dir) {
       }
       const info = dirInfo.get(dirPath);
       info.fileCount++;
-      const ext = path4.extname(file).slice(1);
+      const ext = path5.extname(file).slice(1);
       if (ext) {
         info.extensions.set(ext, (info.extensions.get(ext) ?? 0) + 1);
       }
@@ -860,7 +1058,7 @@ async function getProjectStructure(dir) {
   return JSON.stringify(output, null, 2);
 }
 async function getTestMap(dir) {
-  const rootDir = path4.resolve(dir);
+  const rootDir = path5.resolve(dir);
   const testPatterns = [
     "**/*.test.*",
     "**/*.spec.*",
@@ -875,15 +1073,15 @@ async function getTestMap(dir) {
     "**/*Test.swift",
     "**/*_test.rs"
   ];
-  const testFiles = await fg3(testPatterns, { cwd: rootDir, ignore: IGNORE });
-  const sourceFiles = await fg3(
+  const testFiles = await fg4(testPatterns, { cwd: rootDir, ignore: IGNORE2 });
+  const sourceFiles = await fg4(
     "**/*.{ts,tsx,js,jsx,kt,kts,java,py,go,rs,swift,rb,cs,cpp,dart}",
-    { cwd: rootDir, ignore: IGNORE }
+    { cwd: rootDir, ignore: IGNORE2 }
   );
   const sourceByBaseName = /* @__PURE__ */ new Map();
   for (const file of sourceFiles) {
     if (testFiles.includes(file)) continue;
-    const baseName = path4.basename(file).replace(/\.[^.]+$/, "");
+    const baseName = path5.basename(file).replace(/\.[^.]+$/, "");
     const existing = sourceByBaseName.get(baseName) ?? [];
     existing.push(file);
     sourceByBaseName.set(baseName, existing);
@@ -891,7 +1089,7 @@ async function getTestMap(dir) {
   const pairs = [];
   const unmatched = [];
   for (const testFile of testFiles) {
-    const testBaseName = path4.basename(testFile).replace(/\.[^.]+$/, "");
+    const testBaseName = path5.basename(testFile).replace(/\.[^.]+$/, "");
     const sourceName = testBaseName.replace(/Test$|Tests$|Spec$|\.test$|\.spec$/, "").replace(/^test_|_test$/, "");
     if (!sourceName) {
       unmatched.push(testFile);
@@ -899,10 +1097,10 @@ async function getTestMap(dir) {
     }
     const candidates = sourceByBaseName.get(sourceName);
     if (candidates && candidates.length > 0) {
-      const testDir = path4.dirname(testFile);
+      const testDir = path5.dirname(testFile);
       const bestMatch = candidates.reduce((best, candidate) => {
-        const candidateDir = path4.dirname(candidate);
-        const bestDir = path4.dirname(best);
+        const candidateDir = path5.dirname(candidate);
+        const bestDir = path5.dirname(best);
         const candidateOverlap = commonSegments(testDir, candidateDir);
         const bestOverlap = commonSegments(testDir, bestDir);
         return candidateOverlap > bestOverlap ? candidate : best;
@@ -934,7 +1132,7 @@ function commonSegments(pathA, pathB) {
   return count;
 }
 async function getSnapshot(dir) {
-  const rootDir = path4.resolve(dir);
+  const rootDir = path5.resolve(dir);
   const snapshot = await loadSnapshot(rootDir);
   if (!snapshot) {
     return JSON.stringify({
@@ -944,23 +1142,31 @@ async function getSnapshot(dir) {
   }
   const currentHash = await getCurrentGitHash(rootDir);
   const isStale = snapshot.gitHash !== currentHash && snapshot.gitHash !== "unknown";
+  const seenFiles = /* @__PURE__ */ new Set();
+  const compactFeatures = {};
+  for (const [name, feat] of Object.entries(snapshot.features)) {
+    const unique = feat.files.filter((f) => !seenFiles.has(f));
+    if (unique.length === 0) continue;
+    for (const f of unique) seenFiles.add(f);
+    compactFeatures[name] = unique;
+  }
+  const compactFlows = {};
+  for (const [name, flow] of Object.entries(snapshot.flows)) {
+    compactFlows[name] = flow.chain;
+  }
   const output = {
     exists: true,
-    createdAt: snapshot.createdAt,
-    updatedAt: snapshot.updatedAt,
-    featureCount: Object.keys(snapshot.features).length,
-    flowCount: Object.keys(snapshot.flows).length,
-    features: snapshot.features,
-    flows: snapshot.flows,
+    features: compactFeatures,
+    flows: compactFlows,
     stale: isStale
   };
   if (isStale) {
-    output.message = "Snapshot is behind HEAD. Some features/flows may reference changed files. Run 'mason snapshot-update' or call save_snapshot to refresh.";
+    output.message = "Snapshot is behind HEAD. Run 'mason snapshot-update' or call save_snapshot to refresh.";
   }
-  return JSON.stringify(output, null, 2);
+  return JSON.stringify(output);
 }
 async function fullAnalysis(dir) {
-  const rootDir = path4.resolve(dir);
+  const rootDir = path5.resolve(dir);
   const [analysis, structure, samples, testMap, snapshot] = await Promise.all([
     analyzeProject(dir),
     getProjectStructure(dir),
@@ -986,7 +1192,7 @@ async function fullAnalysis(dir) {
   return JSON.stringify(output, null, 2);
 }
 async function saveSnapshotData(dir, features, flows) {
-  const rootDir = path4.resolve(dir);
+  const rootDir = path5.resolve(dir);
   const gitHash = await getCurrentGitHash(rootDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const existing = await loadSnapshot(rootDir);
@@ -1017,26 +1223,11 @@ async function saveSnapshotData(dir, features, flows) {
     flows: Object.keys(flows).length
   });
 }
-async function configureProject(dir, config) {
-  const rootDir = path4.resolve(dir);
-  const configDir = path4.join(rootDir, ".mason");
-  const configPath = path4.join(configDir, "config.json");
-  let existing = {};
-  try {
-    const raw = await fs5.readFile(configPath, "utf-8");
-    existing = JSON.parse(raw);
-  } catch {
-  }
-  if (config.patterns) existing.patterns = config.patterns;
-  if (config.alwaysInclude) existing.alwaysInclude = config.alwaysInclude;
-  if (config.ignore) existing.ignore = config.ignore;
-  await fs5.mkdir(configDir, { recursive: true });
-  await fs5.writeFile(configPath, JSON.stringify(existing, null, 2), "utf-8");
-  return JSON.stringify({
-    status: "saved",
-    path: configPath,
-    config: existing
-  });
+async function getImpact(dir, files) {
+  const { analyzeImpact: analyzeImpact2 } = await Promise.resolve().then(() => (init_impact(), impact_exports));
+  const rootDir = path5.resolve(dir);
+  const result = await analyzeImpact2(rootDir, files);
+  return JSON.stringify(result, null, 2);
 }
 
 // src/mcp/server.ts
@@ -1047,12 +1238,12 @@ function createMcpServer() {
       version: "0.1.0"
     },
     {
-      instructions: "Mason is a context engineering tool. Always call get_snapshot before using Explore agents, Glob, or Grep to understand the codebase. The snapshot is a concept map that maps features and flows to their implementing files \u2014 it eliminates the need to search. This applies to ANY question about architecture, features, flows, how things work, cross-feature interactions, or bug investigation. Workflow: 1) Call get_snapshot first. 2) If no snapshot, call full_analysis instead. 3) Use get_file_content to read the files the snapshot points to. 4) Call save_snapshot to persist your understanding for future sessions. 5) Call write_claude_md for documentation."
+      instructions: "Mason is a context engineering tool. Always call get_snapshot before using Explore agents, Glob, or Grep to understand the codebase. The snapshot is a concept map that maps features and flows to their implementing files \u2014 it eliminates the need to search. This applies to ANY question about architecture, features, flows, how things work, cross-feature interactions, or bug investigation. Workflow: 1) Call get_snapshot first. 2) If no snapshot, call full_analysis and then save_snapshot to create one. 3) If the snapshot is stale, tell the user and offer to update it. 4) Use your native file reading tool to read files the snapshot points to. 5) Before modifying a file, call get_impact to check what else might be affected. 6) After making significant changes (new features, refactors, architecture changes), call save_snapshot to update the concept map."
     }
   );
   server.tool(
     "full_analysis",
-    "Run a complete project analysis in one call. Returns git history stats, project structure with file counts, curated code sample previews (~60 lines each), and test-to-source file mapping. This is the recommended starting point \u2014 call this first, then use get_file_content to read specific files in full.",
+    "Run a complete project analysis in one call. Returns git history stats, project structure with file counts, curated code sample previews (~60 lines each), and test-to-source file mapping. This is the recommended starting point \u2014 call this first, then read specific files natively for full content.",
     {
       dir: z.string().describe("Absolute path to the project root directory")
     },
@@ -1078,7 +1269,7 @@ function createMcpServer() {
   );
   server.tool(
     "get_code_samples",
-    "Get previews (first ~60 lines) of representative source files from the codebase. Includes entry points, config files, hot files (frequently changed), test examples, and one file per directory for breadth. Use get_file_content to read the full content of any file that looks interesting.",
+    "Get previews (first ~60 lines) of representative source files from the codebase. Includes entry points, config files, hot files (frequently changed), test examples, and one file per directory for breadth. Read files natively for full content.",
     {
       dir: z.string().describe("Absolute path to the project root directory"),
       count: z.number().optional().default(15).describe("Maximum number of files to sample (default: 15)")
@@ -1090,46 +1281,6 @@ function createMcpServer() {
       };
     }
   );
-  server.tool(
-    "get_file_content",
-    "Read the full content of a specific file. Use this after get_code_samples to drill into files you want to understand fully.",
-    {
-      dir: z.string().describe("Absolute path to the project root directory"),
-      file_path: z.string().describe("Relative path to the file within the project (e.g., 'src/main.ts')")
-    },
-    async ({ dir, file_path }) => {
-      const result = await getFileContent(dir, file_path);
-      return {
-        content: [{ type: "text", text: result }]
-      };
-    }
-  );
-  server.tool(
-    "get_project_structure",
-    "Get the directory structure of a project with file counts and extension breakdown per directory. Shows top-level files and annotated directory listing up to 2 levels deep. Useful for understanding project layout before diving into code.",
-    {
-      dir: z.string().describe("Absolute path to the project root directory")
-    },
-    async ({ dir }) => {
-      const result = await getProjectStructure(dir);
-      return {
-        content: [{ type: "text", text: result }]
-      };
-    }
-  );
-  server.tool(
-    "get_test_map",
-    "Map test files to their corresponding source files by name matching. Shows which source files have tests and which don't. Useful for understanding test coverage patterns and test organization conventions.",
-    {
-      dir: z.string().describe("Absolute path to the project root directory")
-    },
-    async ({ dir }) => {
-      const result = await getTestMap(dir);
-      return {
-        content: [{ type: "text", text: result }]
-      };
-    }
-  );
   server.tool(
     "get_snapshot",
     "Get the project's concept map \u2014 a lookup table from features and flows to the files that implement them. Use this to jump straight to relevant files instead of exploring. Example: 'home screen' \u2192 [HomeScreen.kt, HomeViewModel.kt, HomeModule.kt]. If stale, run 'mason snapshot-update' to refresh.",
@@ -1170,20 +1321,14 @@ function createMcpServer() {
     }
   );
   server.tool(
-    "configure_project",
-    "Configure Mason for this project. Add custom file patterns to sample, files to always include, or paths to ignore. Saved to .mason/config.json. Use this when the default architectural patterns miss important files in the project.",
+    "get_impact",
+    "Analyze the impact of changing specific files. Returns three signals: git co-change (files that historically change together), references (files that mention the target by name), and related tests. Use this before editing a file to understand what else might need updating.",
     {
       dir: z.string().describe("Absolute path to the project root directory"),
-      patterns: z.array(z.string()).optional().describe("Custom glob patterns for architecturally important files (e.g., '**/*Gateway.*', '**/*Bloc.*')"),
-      alwaysInclude: z.array(z.string()).optional().describe("Specific file paths to always include in samples (e.g., 'src/core/config.ts')"),
-      ignore: z.array(z.string()).optional().describe("Additional glob patterns to ignore (e.g., '**/fixtures/**')")
+      files: z.array(z.string()).describe("File paths or names to analyze (e.g., ['WeatherRepository.kt'] or ['src/services/auth.ts'])")
     },
-    async ({ dir, patterns, alwaysInclude, ignore }) => {
-      const result = await configureProject(dir, {
-        patterns,
-        alwaysInclude,
-        ignore
-      });
+    async ({ dir, files }) => {
+      const result = await getImpact(dir, files);
       return {
         content: [{ type: "text", text: result }]
       };