mason-context 0.1.0 → 0.2.0

package/dist/bin/mason.js

@@ -1,6 +1,12 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -372,48 +378,44 @@ function formatPromptForCopy(system, userMessage) {
 
 ${userMessage}`;
 }
+function spawnWithStdin(command, args, input) {
+  const { spawn } = __require("child_process");
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 3e5
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout.trim());
+      } else {
+        reject(new Error(`${command} exited with code ${code}: ${stderr}`));
+      }
+    });
+    proc.on("error", reject);
+    proc.stdin.write(input);
+    proc.stdin.end();
+  });
+}
 async function callClaudeCLI(system, userMessage) {
-  const fs7 = await import("fs/promises");
-  const os2 = await import("os");
-  const path6 = await import("path");
   const prompt = `${system}
 
 ${userMessage}`;
-  const tmpFile = path6.join(os2.tmpdir(), `mason-prompt-${Date.now()}.txt`);
-  try {
-    await fs7.writeFile(tmpFile, prompt, "utf-8");
-    const promptContent = await fs7.readFile(tmpFile, "utf-8");
-    const { stdout } = await exec4(
-      "sh",
-      ["-c", `cat "${tmpFile}" | claude -p`],
-      { maxBuffer: 1e7, timeout: 3e5 }
-    );
-    return stdout.trim();
-  } finally {
-    await fs7.unlink(tmpFile).catch(() => {
-    });
-  }
+  return spawnWithStdin("claude", ["-p"], prompt);
 }
 async function callGeminiCLI(system, userMessage) {
-  const fs7 = await import("fs/promises");
-  const os2 = await import("os");
-  const path6 = await import("path");
   const prompt = `${system}
 
 ${userMessage}`;
-  const tmpFile = path6.join(os2.tmpdir(), `mason-prompt-${Date.now()}.txt`);
-  try {
-    await fs7.writeFile(tmpFile, prompt, "utf-8");
-    const { stdout } = await exec4(
-      "sh",
-      ["-c", `cat "${tmpFile}" | gemini -p ""`],
-      { maxBuffer: 1e7, timeout: 3e5 }
-    );
-    return stdout.trim();
-  } finally {
-    await fs7.unlink(tmpFile).catch(() => {
-    });
-  }
+  return spawnWithStdin("gemini", ["-p", ""], prompt);
 }
 async function callOllamaCLI(host, model, system, userMessage) {
   const response = await fetch(`${host}/api/chat`, {
@@ -524,6 +526,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 = path2.resolve(rootDir, filePath);
+    if (!resolvedPath.startsWith(path2.resolve(rootDir))) continue;
     selected.set(filePath, "always-include (project config)");
   }
   let configCount = 0;
@@ -695,7 +699,9 @@ async function sampleFiles(rootDir, maxFiles = 25) {
   const results = [];
   for (const [filePath, reason] of selected) {
     try {
-      const fullPath = path2.join(rootDir, filePath);
+      const fullPath = path2.resolve(rootDir, filePath);
+      if (!fullPath.startsWith(path2.resolve(rootDir))) continue;
+      if (isSensitiveFile(filePath)) continue;
       const stat = await fs3.stat(fullPath);
       if (stat.size > 1e5) continue;
       const content = await fs3.readFile(fullPath, "utf-8");
@@ -713,10 +719,15 @@ async function sampleFiles(rootDir, maxFiles = 25) {
   }
   return results;
 }
+function isSensitiveFile(filePath) {
+  const basename = path2.basename(filePath);
+  return SENSITIVE_PATTERNS.some((p) => p.test(basename));
+}
 async function readFullFile(rootDir, filePath) {
   try {
     const fullPath = path2.join(path2.resolve(rootDir), filePath);
     if (!fullPath.startsWith(path2.resolve(rootDir))) return null;
+    if (isSensitiveFile(filePath)) return null;
     const content = await fs3.readFile(fullPath, "utf-8");
     return {
       path: filePath,
@@ -727,7 +738,7 @@ async function readFullFile(rootDir, filePath) {
     return null;
   }
 }
-var exec5, SOURCE_EXTENSIONS, CONFIG_FILES, ENTRY_POINT_PATTERNS, ARCHITECTURAL_PATTERNS, IGNORE_PATTERNS, PREVIEW_LINES;
+var exec5, SOURCE_EXTENSIONS, CONFIG_FILES, ENTRY_POINT_PATTERNS, ARCHITECTURAL_PATTERNS, IGNORE_PATTERNS, PREVIEW_LINES, SENSITIVE_PATTERNS;
 var init_sampler = __esm({
   "src/mcp/sampler.ts"() {
     "use strict";
@@ -873,6 +884,21 @@ var init_sampler = __esm({
       "**/BuildConfig.java"
     ];
     PREVIEW_LINES = 60;
+    SENSITIVE_PATTERNS = [
+      /^\.env$/,
+      /^\.env\./,
+      /\.pem$/,
+      /\.key$/,
+      /\.p12$/,
+      /\.pfx$/,
+      /\.jks$/,
+      /id_rsa/,
+      /id_ed25519/,
+      /credentials\./,
+      /secret/i,
+      /\.keystore$/,
+      /local\.properties$/
+    ];
   }
 });
 
@@ -1182,12 +1208,200 @@ var init_snapshot = __esm({
   }
 });
 
-// src/mcp/tools.ts
+// 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/tools.ts
+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";
 async function buildContext(dir) {
   return {
     rootDir: dir,
@@ -1195,7 +1409,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);
@@ -1249,7 +1463,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 {
     }
@@ -1267,9 +1481,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) {
@@ -1287,18 +1501,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 {
@@ -1309,7 +1523,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.",
@@ -1323,19 +1537,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();
@@ -1348,7 +1554,7 @@ async function getProjectStructure(dir) {
       }
       const info2 = dirInfo.get(dirPath);
       info2.fileCount++;
-      const ext = path4.extname(file).slice(1);
+      const ext = path5.extname(file).slice(1);
       if (ext) {
         info2.extensions.set(ext, (info2.extensions.get(ext) ?? 0) + 1);
       }
@@ -1370,7 +1576,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.*",
@@ -1385,15 +1591,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);
@@ -1401,7 +1607,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);
@@ -1409,10 +1615,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;
@@ -1444,7 +1650,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({
@@ -1454,23 +1660,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),
@@ -1496,7 +1710,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);
@@ -1527,28 +1741,13 @@ 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);
 }
-var exec7, IGNORE;
+var exec8, IGNORE2;
 var init_tools = __esm({
   "src/mcp/tools.ts"() {
     "use strict";
@@ -1556,8 +1755,8 @@ var init_tools = __esm({
     init_git();
     init_sampler();
     init_snapshot();
-    exec7 = promisify7(execFile7);
-    IGNORE = [
+    exec8 = promisify8(execFile8);
+    IGNORE2 = [
       "**/node_modules/**",
       "**/dist/**",
       "**/build/**",
@@ -1590,12 +1789,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")
     },
@@ -1621,7 +1820,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)")
@@ -1633,46 +1832,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.",
@@ -1713,20 +1872,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 }]
       };
@@ -1753,8 +1906,8 @@ init_config();
 init_providers();
 init_tools();
 import { Command } from "commander";
-import fs6 from "fs/promises";
-import path5 from "path";
+import fs7 from "fs/promises";
+import path6 from "path";
 import ora from "ora";
 import chalk2 from "chalk";
 
@@ -1819,11 +1972,11 @@ function createCLI() {
     "Context engineering CLI & MCP server \u2014 generates intelligent CLAUDE.md files"
   ).version("0.1.0");
   program2.command("setup").description("Register Mason as an MCP server with Claude Code").option("--scope <scope>", "Config scope: user or project", "user").action(async (opts) => {
-    const { execFile: execFile8 } = await import("child_process");
-    const { promisify: promisify8 } = await import("util");
-    const exec8 = promisify8(execFile8);
+    const { execFile: execFile9 } = await import("child_process");
+    const { promisify: promisify9 } = await import("util");
+    const exec9 = promisify9(execFile9);
     try {
-      await exec8("claude", ["--version"]);
+      await exec9("claude", ["--version"]);
     } catch {
       error(
         "Claude Code CLI not found. Install it from https://claude.ai/code"
@@ -1842,7 +1995,7 @@ function createCLI() {
         "mason-ai",
         "mcp"
       ];
-      await exec8("claude", args);
+      await exec9("claude", args);
       success("Mason registered with Claude Code.");
       info("Restart Claude Code to start using Mason's tools.");
     } catch (err) {
@@ -1897,7 +2050,7 @@ function createCLI() {
       );
       process.exit(1);
     }
-    const rootDir = path5.resolve(dir);
+    const rootDir = path6.resolve(dir);
     const runConfig = opts.model ? { ...config, model: opts.model } : config;
     const spinner = ora("Analyzing codebase...").start();
     const analysisData = await fullAnalysis(rootDir);
@@ -1927,11 +2080,40 @@ ${analysisData}`
         error("LLM returned empty response.");
         process.exit(1);
       }
-      const claudeDir = path5.join(rootDir, ".claude");
-      await fs6.mkdir(claudeDir, { recursive: true });
-      const outPath = path5.join(claudeDir, "CLAUDE.md");
-      await fs6.writeFile(outPath, markdown, "utf-8");
+      const claudeDir = path6.join(rootDir, ".claude");
+      await fs7.mkdir(claudeDir, { recursive: true });
+      const outPath = path6.join(claudeDir, "CLAUDE.md");
+      await fs7.writeFile(outPath, markdown, "utf-8");
       success(`Generated ${outPath}`);
+      try {
+        const { createSnapshot: createSnapshot2 } = await Promise.resolve().then(() => (init_snapshot(), snapshot_exports));
+        const spinner2 = ora("Building concept map...").start();
+        const snapshot = await createSnapshot2(rootDir, runConfig);
+        spinner2.stop();
+        const featureCount = Object.keys(snapshot.features).length;
+        const flowCount = Object.keys(snapshot.flows).length;
+        success(
+          `Concept map created: ${featureCount} features, ${flowCount} flows`
+        );
+      } catch {
+      }
+      const hookPath = path6.join(rootDir, ".git", "hooks", "post-commit");
+      try {
+        const hookContent = await fs7.readFile(hookPath, "utf-8");
+        if (!hookContent.includes("mason snapshot-update")) {
+          console.log(
+            chalk2.gray(
+              '\nTip: Run "mason snapshot --install-hook" to keep the concept map updated automatically.'
+            )
+          );
+        }
+      } catch {
+        console.log(
+          chalk2.gray(
+            '\nTip: Run "mason snapshot --install-hook" to keep the concept map updated automatically.'
+          )
+        );
+      }
     } catch (err) {
       spinner.stop();
       error(
@@ -1945,7 +2127,7 @@ ${analysisData}`
       createSnapshot: createSnapshot2,
       installHook: installHook2
     } = await Promise.resolve().then(() => (init_snapshot(), snapshot_exports));
-    const rootDir = path5.resolve(dir);
+    const rootDir = path6.resolve(dir);
     if (opts.installHook) {
       try {
         await installHook2(rootDir);
@@ -1983,7 +2165,7 @@ ${analysisData}`
   });
   program2.command("snapshot-update").description("Incrementally update snapshot with recent changes").argument("[dir]", "Directory to update", ".").action(async (dir) => {
     const { updateSnapshot: updateSnapshot2 } = await Promise.resolve().then(() => (init_snapshot(), snapshot_exports));
-    const rootDir = path5.resolve(dir);
+    const rootDir = path6.resolve(dir);
     const config = await loadConfig();
     if (!config) return;
     try {
@@ -1995,8 +2177,46 @@ ${analysisData}`
     } catch {
     }
   });
+  program2.command("impact").description("Show files affected by changes to a given file").argument("<files...>", "File paths or names to analyze").option("-d, --dir <dir>", "Project directory", ".").action(async (files, opts) => {
+    const { analyzeImpact: analyzeImpact2 } = await Promise.resolve().then(() => (init_impact(), impact_exports));
+    const rootDir = path6.resolve(opts.dir);
+    const spinner = ora("Analyzing impact...").start();
+    const result = await analyzeImpact2(rootDir, files);
+    spinner.stop();
+    console.log(chalk2.bold(`
+Impact analysis for: ${result.targetFiles.join(", ")}
+`));
+    if (result.cochange.length > 0) {
+      console.log(chalk2.bold("  Co-change (files that historically change together):"));
+      for (const entry of result.cochange) {
+        const rate = chalk2.gray(`${Math.round(entry.cochangeRate * 100)}%`);
+        console.log(`    ${rate} ${entry.file} ${chalk2.gray(`(${entry.sharedCommits} shared commits)`)}`);
+      }
+      console.log();
+    }
+    if (result.references.length > 0) {
+      console.log(chalk2.bold("  References (files that mention the target):"));
+      for (const entry of result.references) {
+        console.log(`    ${entry.file} ${chalk2.gray(`[${entry.matches.join(", ")}]`)}`);
+      }
+      console.log();
+    }
+    if (result.tests.length > 0) {
+      console.log(chalk2.bold("  Related tests:"));
+      for (const entry of result.tests) {
+        console.log(`    ${entry.file} ${chalk2.gray(`(${entry.confidence})`)}`);
+      }
+      console.log();
+    }
+    const total = result.cochange.length + result.references.length + result.tests.length;
+    if (total === 0) {
+      info("No impact detected \u2014 this file may be independent.");
+    } else {
+      console.log(chalk2.bold(`  ${total} related file(s) found`));
+    }
+  });
   program2.command("analyze").description("Analyze the codebase and print findings").argument("[dir]", "Directory to analyze", ".").action(async (dir) => {
-    const rootDir = path5.resolve(dir);
+    const rootDir = path6.resolve(dir);
     const spinner = ora("Analyzing codebase...").start();
     const context = await buildContext2(rootDir);
     const results = await runAll(context);