mason-context 0.3.7 → 0.7.0

package/dist/bin/mason-mcp.js

@@ -1,1412 +0,0 @@
-#!/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/test-map.ts
-var test_map_exports = {};
-__export(test_map_exports, {
-  buildTestMap: () => buildTestMap
-});
-import path2 from "path";
-import fg3 from "fast-glob";
-async function buildTestMap(dir) {
-  const rootDir = path2.resolve(dir);
-  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 sourceFiles = await fg3(
-    "**/*.{ts,tsx,js,jsx,kt,kts,java,py,go,rs,swift,rb,cs,cpp,dart}",
-    { cwd: rootDir, ignore: IGNORE }
-  );
-  const sourceByBaseName = /* @__PURE__ */ new Map();
-  for (const file of sourceFiles) {
-    if (testFiles.includes(file)) continue;
-    const baseName = path2.basename(file).replace(/\.[^.]+$/, "");
-    const existing = sourceByBaseName.get(baseName) ?? [];
-    existing.push(file);
-    sourceByBaseName.set(baseName, existing);
-  }
-  const paired = [];
-  const unmatched = [];
-  for (const testFile of testFiles) {
-    const testBaseName = path2.basename(testFile).replace(/\.[^.]+$/, "");
-    const sourceName = testBaseName.replace(/Test$|Tests$|Spec$|\.test$|\.spec$/, "").replace(/^test_|_test$/, "");
-    if (!sourceName) {
-      unmatched.push(testFile);
-      continue;
-    }
-    const candidates = sourceByBaseName.get(sourceName);
-    if (candidates && candidates.length > 0) {
-      const testDir = path2.dirname(testFile);
-      const bestMatch = candidates.reduce((best, candidate) => {
-        const candidateDir = path2.dirname(candidate);
-        const bestDir = path2.dirname(best);
-        const candidateOverlap = commonSegments(testDir, candidateDir);
-        const bestOverlap = commonSegments(testDir, bestDir);
-        return candidateOverlap > bestOverlap ? candidate : best;
-      });
-      paired.push({
-        test: testFile,
-        source: bestMatch,
-        confidence: candidates.length === 1 ? "exact" : "best-guess"
-      });
-    } else {
-      unmatched.push(testFile);
-    }
-  }
-  return { totalTestFiles: testFiles.length, paired, unmatched };
-}
-function commonSegments(pathA, pathB) {
-  const segsA = pathA.split("/");
-  const segsB = pathB.split("/");
-  let count = 0;
-  for (let i = 0; i < Math.min(segsA.length, segsB.length); i++) {
-    if (segsA[i] === segsB[i]) count++;
-    else break;
-  }
-  return count;
-}
-var IGNORE;
-var init_test_map = __esm({
-  "src/test-map.ts"() {
-    "use strict";
-    IGNORE = [
-      "**/node_modules/**",
-      "**/dist/**",
-      "**/build/**",
-      "**/.gradle/**",
-      "**/target/**",
-      "**/.git/**",
-      "**/vendor/**",
-      "**/__pycache__/**",
-      "**/venv/**",
-      "**/.venv/**",
-      "**/*.min.*",
-      "**/*.map"
-    ];
-  }
-});
-
-// src/impact/impact.ts
-var impact_exports = {};
-__export(impact_exports, {
-  analyzeImpact: () => analyzeImpact
-});
-import fs5 from "fs/promises";
-import path5 from "path";
-import { execFile as execFile7 } from "child_process";
-import { promisify as promisify7 } from "util";
-import fg5 from "fast-glob";
-async function analyzeImpact(rootDir, targetFiles) {
-  const resolvedRoot = path5.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 fg5(`**/${target}`, {
-      cwd: rootDir,
-      ignore: IGNORE2
-    });
-    if (matches.length > 0) {
-      resolved.push(matches[0]);
-    } else {
-      const noExt = target.replace(/\.[^.]+$/, "");
-      const extMatches = await fg5(`**/${noExt}.*`, {
-        cwd: rootDir,
-        ignore: IGNORE2
-      });
-      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 = path5.basename(target).replace(/\.[^.]+$/, "");
-    searchNames.add(basename);
-  }
-  const allSourceFiles = await fg5(`**/${SOURCE_EXTENSIONS2}`, {
-    cwd: rootDir,
-    ignore: IGNORE2
-  });
-  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(
-            path5.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 fg5(testPatterns, { cwd: rootDir, ignore: IGNORE2 });
-  const results = [];
-  for (const target of targetFiles) {
-    const targetBaseName = path5.basename(target).replace(/\.[^.]+$/, "");
-    for (const testFile of testFiles) {
-      const testBaseName = path5.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, IGNORE2, SOURCE_EXTENSIONS2;
-var init_impact = __esm({
-  "src/impact/impact.ts"() {
-    "use strict";
-    exec7 = promisify7(execFile7);
-    IGNORE2 = [
-      "**/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";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-
-// src/mcp/tools.ts
-import fs6 from "fs/promises";
-import path6 from "path";
-import { execFile as execFile8 } from "child_process";
-import { promisify as promisify8 } from "util";
-import fg6 from "fast-glob";
-
-// src/analyzers/git-history.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-
-// src/analyzers/base.ts
-import fs from "fs/promises";
-import fg from "fast-glob";
-var BaseAnalyzer = class {
-  async findFiles(patterns, root) {
-    return fg(patterns, {
-      cwd: root,
-      ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"],
-      absolute: true
-    });
-  }
-  async readFile(filePath) {
-    return fs.readFile(filePath, "utf-8");
-  }
-  createFinding(partial) {
-    return {
-      analyzer: this.name,
-      category: partial.category,
-      confidence: partial.confidence,
-      summary: partial.summary,
-      evidence: partial.evidence ?? [],
-      ruleCandidate: partial.ruleCandidate ?? null
-    };
-  }
-  createResult(findings, gaps, startTime) {
-    return {
-      analyzer: this.name,
-      findings,
-      gaps,
-      durationMs: Date.now() - startTime
-    };
-  }
-};
-
-// src/analyzers/git-history.ts
-var exec = promisify(execFile);
-var GitHistoryAnalyzer = class extends BaseAnalyzer {
-  name = "git-history";
-  async analyze(context) {
-    const startTime = Date.now();
-    const findings = [];
-    const gaps = [];
-    if (!context.gitAvailable) {
-      return this.createResult([], [], startTime);
-    }
-    const [staleFindings, staleGaps] = await this.findStaleDirectories(context);
-    findings.push(...staleFindings);
-    gaps.push(...staleGaps);
-    const hotFindings = await this.findHotFiles(context);
-    findings.push(...hotFindings);
-    const commitFindings = await this.analyzeCommitPatterns(context);
-    findings.push(...commitFindings);
-    return this.createResult(findings, gaps, startTime);
-  }
-  async git(args, cwd) {
-    try {
-      const { stdout } = await exec("git", args, { cwd, maxBuffer: 1e7 });
-      return stdout.trim();
-    } catch {
-      return "";
-    }
-  }
-  async findStaleDirectories(context) {
-    const findings = [];
-    const gaps = [];
-    const output = await this.git(
-      ["log", "--all", "--format=%ci", "--name-only", "--diff-filter=AMCR", "-n", "500"],
-      context.rootDir
-    );
-    if (!output) return [findings, gaps];
-    const dirLastTouch = /* @__PURE__ */ new Map();
-    let currentDate = null;
-    for (const line of output.split("\n")) {
-      if (!line) continue;
-      if (/^\d{4}-\d{2}-\d{2}/.test(line)) {
-        currentDate = new Date(line);
-      } else if (currentDate) {
-        const topDir = line.split("/")[0];
-        if (topDir && !topDir.startsWith(".") && !topDir.includes("node_modules")) {
-          const existing = dirLastTouch.get(topDir);
-          if (!existing || currentDate > existing) {
-            dirLastTouch.set(topDir, currentDate);
-          }
-        }
-      }
-    }
-    const sixMonthsAgo = /* @__PURE__ */ new Date();
-    sixMonthsAgo.setMonth(sixMonthsAgo.getMonth() - 6);
-    for (const [dir, lastTouch] of dirLastTouch) {
-      if (lastTouch < sixMonthsAgo) {
-        const monthsStale = Math.floor(
-          (Date.now() - lastTouch.getTime()) / (1e3 * 60 * 60 * 24 * 30)
-        );
-        findings.push(
-          this.createFinding({
-            category: "risk",
-            confidence: 0.7,
-            summary: `Directory "${dir}" hasn't been modified in ${monthsStale} months`,
-            evidence: [
-              { filePath: dir, detail: `Last commit: ${lastTouch.toISOString().split("T")[0]}` }
-            ],
-            ruleCandidate: `Do not refactor or modify files in "${dir}/" unless explicitly asked \u2014 this area has been stable for ${monthsStale} months and may be legacy code.`
-          })
-        );
-        gaps.push({
-          analyzer: this.name,
-          question: `Directory "${dir}" hasn't been touched in ${monthsStale} months. Is it deprecated, stable, or legacy?`,
-          context: `Last modified: ${lastTouch.toISOString().split("T")[0]}`,
-          answerKey: `stale-dir-${dir}`
-        });
-      }
-    }
-    return [findings, gaps];
-  }
-  async findHotFiles(context) {
-    const findings = [];
-    const output = await this.git(
-      ["log", "--since=3 months ago", "--format=", "--name-only"],
-      context.rootDir
-    );
-    if (!output) return findings;
-    const fileCounts = /* @__PURE__ */ new Map();
-    for (const line of output.split("\n")) {
-      if (!line || line.startsWith(".") || line.includes("node_modules")) continue;
-      fileCounts.set(line, (fileCounts.get(line) ?? 0) + 1);
-    }
-    const sorted = [...fileCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
-    if (sorted.length > 0 && sorted[0][1] >= 5) {
-      const hotFiles = sorted.filter(([, count]) => count >= 5);
-      if (hotFiles.length > 0) {
-        findings.push(
-          this.createFinding({
-            category: "risk",
-            confidence: 0.8,
-            summary: `${hotFiles.length} files changed frequently in the last 3 months`,
-            evidence: hotFiles.map(([file, count]) => ({
-              filePath: file,
-              detail: `${count} commits`
-            })),
-            ruleCandidate: `These files change frequently and are high-risk for conflicts: ${hotFiles.map(([f]) => f).join(", ")}. Take extra care when modifying them.`
-          })
-        );
-      }
-    }
-    return findings;
-  }
-  async analyzeCommitPatterns(context) {
-    const findings = [];
-    const output = await this.git(
-      ["log", "--format=%s", "-n", "100"],
-      context.rootDir
-    );
-    if (!output) return findings;
-    const messages = output.split("\n").filter(Boolean);
-    const conventionalPattern = /^(feat|fix|chore|docs|style|refactor|test|perf|ci|build|revert)(\(.+\))?:/;
-    const conventionalCount = messages.filter(
-      (m) => conventionalPattern.test(m)
-    ).length;
-    const conventionalRatio = conventionalCount / messages.length;
-    if (conventionalRatio > 0.5) {
-      findings.push(
-        this.createFinding({
-          category: "convention",
-          confidence: Math.min(conventionalRatio + 0.1, 1),
-          summary: `${Math.round(conventionalRatio * 100)}% of recent commits use conventional commit format`,
-          evidence: [
-            {
-              filePath: ".git",
-              detail: `${conventionalCount} of ${messages.length} commits match`
-            }
-          ],
-          ruleCandidate: "Use conventional commit format: type(scope): description (e.g., feat(auth): add login endpoint)"
-        })
-      );
-    }
-    const ticketPattern = /[A-Z]+-\d+|#\d+/;
-    const ticketCount = messages.filter((m) => ticketPattern.test(m)).length;
-    const ticketRatio = ticketCount / messages.length;
-    if (ticketRatio > 0.3) {
-      findings.push(
-        this.createFinding({
-          category: "convention",
-          confidence: ticketRatio,
-          summary: `${Math.round(ticketRatio * 100)}% of commits reference issue/ticket IDs`,
-          evidence: [
-            {
-              filePath: ".git",
-              detail: `${ticketCount} of ${messages.length} commits have ticket refs`
-            }
-          ],
-          ruleCandidate: "Include issue/ticket references in commit messages when applicable."
-        })
-      );
-    }
-    return findings;
-  }
-};
-
-// src/analyzers/index.ts
-var analyzers = [new GitHistoryAnalyzer()];
-async function runAll(context) {
-  return Promise.all(analyzers.map((a) => a.analyze(context)));
-}
-
-// src/utils/git.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var exec2 = promisify2(execFile2);
-async function isGitRepo(dir) {
-  try {
-    await exec2("git", ["rev-parse", "--git-dir"], { cwd: dir });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/mcp/sampler.ts
-import fs2 from "fs/promises";
-import path from "path";
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
-import fg2 from "fast-glob";
-var exec3 = promisify3(execFile3);
-var SOURCE_EXTENSIONS = [
-  "ts",
-  "tsx",
-  "js",
-  "jsx",
-  "mts",
-  "mjs",
-  "kt",
-  "kts",
-  "java",
-  "py",
-  "go",
-  "rs",
-  "swift",
-  "rb",
-  "cs",
-  "cpp",
-  "c",
-  "h",
-  "dart"
-];
-var CONFIG_FILES = [
-  // Build & project config
-  "package.json",
-  "tsconfig.json",
-  "build.gradle.kts",
-  "build.gradle",
-  "settings.gradle.kts",
-  "settings.gradle",
-  "Cargo.toml",
-  "go.mod",
-  "pyproject.toml",
-  "Gemfile",
-  "*.csproj",
-  // Version catalogs & dependency locks
-  "gradle/libs.versions.toml",
-  // Code quality & formatting
-  ".editorconfig",
-  ".eslintrc.*",
-  "eslint.config.*",
-  ".prettierrc",
-  "rustfmt.toml",
-  ".swiftlint.yml",
-  // CI/CD
-  ".github/workflows/*.yml",
-  ".gitlab-ci.yml",
-  "Jenkinsfile",
-  // Containerization
-  "Dockerfile",
-  "docker-compose.yml",
-  "docker-compose.yaml"
-];
-var ENTRY_POINT_PATTERNS = [
-  "src/main.*",
-  "src/index.*",
-  "src/app.*",
-  "main.*",
-  "index.*",
-  "app.*",
-  "App.*",
-  "**/Main.kt",
-  "**/Application.kt",
-  "**/main.py",
-  "**/main.go",
-  "**/main.rs",
-  "**/lib.rs",
-  "**/Program.cs"
-];
-var ARCHITECTURAL_PATTERNS = [
-  // State/data flow
-  { glob: "**/*ViewModel.*", category: "state", reason: "viewmodel (state management)" },
-  { glob: "**/*Store.*", category: "state", reason: "store (state management)" },
-  { glob: "**/*Reducer.*", category: "state", reason: "reducer (state management)" },
-  // Data layer — interface
-  { glob: "**/*Repository.*", category: "data-interface", reason: "repository interface (data layer contract)" },
-  { glob: "**/*Dao.*", category: "data-interface", reason: "DAO (data access)" },
-  { glob: "**/*DataSource.*", category: "data-interface", reason: "data source" },
-  // Data layer — implementation (where actual patterns live: mappers, retry, IO dispatchers)
-  { glob: "**/*RepositoryImpl.*", category: "data-impl", reason: "repository implementation (data layer patterns)" },
-  { glob: "**/*ServiceImpl.*", category: "data-impl", reason: "service implementation" },
-  { glob: "**/*Impl.*", category: "data-impl", reason: "implementation (concrete patterns)" },
-  // Data transformation
-  { glob: "**/*Mapper.*", category: "transform", reason: "mapper (data transformation)" },
-  { glob: "**/*Converter.*", category: "transform", reason: "converter (data transformation)" },
-  { glob: "**/*Adapter.*", category: "transform", reason: "adapter (interface adaptation)" },
-  // Dependency injection / wiring
-  { glob: "**/*Module.*", category: "di", reason: "module (DI/wiring)" },
-  { glob: "**/*Provider.*", category: "di", reason: "provider (DI/wiring)" },
-  { glob: "**/*Container.*", category: "di", reason: "container (DI/wiring)" },
-  { glob: "**/*Factory.*", category: "di", reason: "factory (object creation)" },
-  // API / network
-  { glob: "**/*Service.*", category: "api", reason: "service (business/API layer)" },
-  { glob: "**/*Client.*", category: "api", reason: "client (API/network layer)" },
-  { glob: "**/*Api.*", category: "api", reason: "API interface definition" },
-  // Interface contracts / protocols
-  { glob: "**/*Interface.*", category: "contract", reason: "interface definition" },
-  { glob: "**/*Protocol.*", category: "contract", reason: "protocol definition" },
-  { glob: "**/*Trait.*", category: "contract", reason: "trait definition" },
-  // Routing / navigation
-  { glob: "**/*Router.*", category: "routing", reason: "router (navigation/routing)" },
-  { glob: "**/*Route.*", category: "routing", reason: "route definition" },
-  { glob: "**/*NavHost.*", category: "routing", reason: "navigation host" },
-  { glob: "**/*Controller.*", category: "routing", reason: "controller (request handling)" },
-  { glob: "**/*Handler.*", category: "routing", reason: "handler (request handling)" },
-  // Middleware / interceptors
-  { glob: "**/*Middleware.*", category: "middleware", reason: "middleware (request pipeline)" },
-  { glob: "**/*Interceptor.*", category: "middleware", reason: "interceptor (cross-cutting)" },
-  { glob: "**/*Plugin.*", category: "middleware", reason: "plugin (extensibility)" },
-  // Models / types
-  { glob: "**/*Model.*", category: "model", reason: "model (domain types)" },
-  { glob: "**/*Entity.*", category: "model", reason: "entity (persistence types)" },
-  { glob: "**/*Dto.*", category: "model", reason: "DTO (data transfer types)" },
-  { glob: "**/*Schema.*", category: "model", reason: "schema (data validation)" },
-  // Use cases / commands
-  { glob: "**/*UseCase.*", category: "usecase", reason: "use case (business logic)" },
-  { glob: "**/*Interactor.*", category: "usecase", reason: "interactor (business logic)" },
-  { glob: "**/*Command.*", category: "usecase", reason: "command (CQRS pattern)" }
-];
-var IGNORE_PATTERNS = [
-  "**/node_modules/**",
-  "**/dist/**",
-  "**/build/**",
-  "**/.gradle/**",
-  "**/target/**",
-  "**/.git/**",
-  "**/vendor/**",
-  "**/__pycache__/**",
-  "**/venv/**",
-  "**/.venv/**",
-  "**/*.min.*",
-  "**/*.map",
-  "**/package-lock.json",
-  "**/yarn.lock",
-  "**/pnpm-lock.yaml",
-  "**/*.lock",
-  "**/*.generated.*",
-  "**/generated/**",
-  "**/R.java",
-  "**/BuildConfig.java"
-];
-var PREVIEW_LINES = 60;
-async function loadProjectConfig(rootDir) {
-  try {
-    const raw = await fs2.readFile(
-      path.join(rootDir, ".mason", "config.json"),
-      "utf-8"
-    );
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-async function getTrackedFiles(rootDir) {
-  try {
-    const { stdout } = await exec3("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
-      cwd: rootDir,
-      maxBuffer: 1e7
-    });
-    return new Set(stdout.trim().split("\n").filter(Boolean));
-  } catch {
-    return null;
-  }
-}
-async function sampleFiles(rootDir, maxFiles = 25) {
-  const selected = /* @__PURE__ */ new Map();
-  const projectConfig = await loadProjectConfig(rootDir);
-  const ignorePatterns = [...IGNORE_PATTERNS, ...projectConfig.ignore ?? []];
-  const trackedFiles = await getTrackedFiles(rootDir);
-  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;
-  for (const pattern of CONFIG_FILES) {
-    if (configCount >= 5) break;
-    const matches = await fg2(pattern, {
-      cwd: rootDir,
-      ignore: ignorePatterns,
-      deep: 3
-    });
-    for (const match of matches) {
-      if (configCount >= 5 || selected.size >= maxFiles) break;
-      selected.set(match, "config file");
-      configCount++;
-    }
-  }
-  const moduleBuildPatterns = [
-    // Gradle
-    "**/build.gradle.kts",
-    "**/build.gradle",
-    // Cargo workspace members
-    "**/Cargo.toml",
-    // Node workspaces
-    "**/package.json",
-    // Go sub-modules
-    "**/go.mod"
-  ];
-  let moduleBuildCount = 0;
-  for (const pattern of moduleBuildPatterns) {
-    const matches = await fg2(pattern, {
-      cwd: rootDir,
-      ignore: ignorePatterns,
-      deep: 4
-    });
-    const subMatches = matches.filter((m) => m.includes("/"));
-    for (const match of subMatches) {
-      if (moduleBuildCount >= 4 || selected.size >= maxFiles) break;
-      if (!selected.has(match)) {
-        selected.set(match, "module build file (reveals dependency graph)");
-        moduleBuildCount++;
-      }
-    }
-    if (moduleBuildCount >= 4) break;
-  }
-  let entryCount = 0;
-  for (const pattern of ENTRY_POINT_PATTERNS) {
-    if (entryCount >= 2) break;
-    const matches = await fg2(pattern, {
-      cwd: rootDir,
-      ignore: ignorePatterns,
-      deep: 5
-    });
-    for (const match of matches) {
-      if (entryCount >= 2 || selected.size >= maxFiles) break;
-      if (!selected.has(match)) {
-        selected.set(match, "entry point");
-        entryCount++;
-      }
-    }
-  }
-  try {
-    const { stdout } = await exec3(
-      "git",
-      ["log", "--since=3 months ago", "--format=", "--name-only"],
-      { cwd: rootDir, maxBuffer: 5e6 }
-    );
-    const fileCounts = /* @__PURE__ */ new Map();
-    for (const line of stdout.split("\n")) {
-      if (!line) continue;
-      if (line.includes("node_modules") || line.includes("/build/") || line.includes(".gradle") || line.includes("/generated/"))
-        continue;
-      const ext = path.extname(line).slice(1);
-      if (!SOURCE_EXTENSIONS.includes(ext)) continue;
-      fileCounts.set(line, (fileCounts.get(line) ?? 0) + 1);
-    }
-    const hotFiles = [...fileCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5);
-    for (const [file, count] of hotFiles) {
-      if (selected.size >= maxFiles) break;
-      if (!selected.has(file)) {
-        selected.set(file, `frequently changed (${count} commits in 3 months)`);
-      }
-    }
-  } catch {
-  }
-  const seenCategories = /* @__PURE__ */ new Set();
-  let patternCount = 0;
-  for (const pattern of ARCHITECTURAL_PATTERNS) {
-    if (patternCount >= 8 || selected.size >= maxFiles) break;
-    if (seenCategories.has(pattern.category)) continue;
-    const matches = await fg2(pattern.glob, {
-      cwd: rootDir,
-      ignore: ignorePatterns
-    });
-    if (matches.length > 0) {
-      for (const match of matches) {
-        if (!selected.has(match)) {
-          selected.set(match, pattern.reason);
-          seenCategories.add(pattern.category);
-          patternCount++;
-          break;
-        }
-      }
-    }
-  }
-  for (const customGlob of projectConfig.patterns ?? []) {
-    if (selected.size >= maxFiles) break;
-    const matches = await fg2(customGlob, {
-      cwd: rootDir,
-      ignore: ignorePatterns
-    });
-    for (const match of matches) {
-      if (selected.size >= maxFiles) break;
-      if (!selected.has(match)) {
-        selected.set(match, "custom pattern (project config)");
-        break;
-      }
-    }
-  }
-  const testPatternGroups = [
-    // JS/TS tests
-    { patterns: ["**/*.test.*", "**/*.spec.*"], label: "JS/TS test" },
-    // JVM tests
-    { patterns: ["**/*Test.kt", "**/*Test.java"], label: "JVM test" },
-    // Python tests
-    { patterns: ["**/test_*.py", "**/*_test.py"], label: "Python test" },
-    // Go tests
-    { patterns: ["**/*_test.go"], label: "Go test" },
-    // Swift tests
-    { patterns: ["**/*Tests.swift", "**/*Test.swift"], label: "Swift test" },
-    // Rust tests
-    { patterns: ["**/*_test.rs"], label: "Rust test" }
-  ];
-  let testCount = 0;
-  for (const group of testPatternGroups) {
-    if (testCount >= 3 || selected.size >= maxFiles) break;
-    const testFiles = await fg2(group.patterns, {
-      cwd: rootDir,
-      ignore: ignorePatterns
-    });
-    if (testFiles.length > 0) {
-      for (const file of testFiles) {
-        if (!selected.has(file)) {
-          selected.set(file, `test example (${group.label})`);
-          testCount++;
-          break;
-        }
-      }
-    }
-  }
-  const sourceGlobs = SOURCE_EXTENSIONS.map((ext) => `**/*.${ext}`);
-  const allSourceFiles = await fg2(sourceGlobs, {
-    cwd: rootDir,
-    ignore: ignorePatterns
-  });
-  const dirRepresentatives = /* @__PURE__ */ new Map();
-  const boringFiles = /\.(gradle|gradle\.kts|json|toml|yaml|yml|xml|properties)$/;
-  for (const file of allSourceFiles) {
-    const topDir = file.split("/")[0];
-    if (!dirRepresentatives.has(topDir) && !boringFiles.test(file)) {
-      dirRepresentatives.set(topDir, file);
-    }
-  }
-  for (const [, file] of dirRepresentatives) {
-    if (selected.size >= maxFiles) break;
-    if (!selected.has(file)) {
-      selected.set(file, "directory representative");
-    }
-  }
-  const results = [];
-  for (const [filePath, reason] of selected) {
-    try {
-      const fullPath = path.resolve(rootDir, filePath);
-      if (!fullPath.startsWith(path.resolve(rootDir))) continue;
-      if (isSensitiveFile(filePath)) continue;
-      if (trackedFiles && !trackedFiles.has(filePath)) continue;
-      const stat = await fs2.stat(fullPath);
-      if (stat.size > 1e5) continue;
-      const content = await fs2.readFile(fullPath, "utf-8");
-      const lines = content.split("\n");
-      const preview = lines.slice(0, PREVIEW_LINES).join("\n");
-      results.push({
-        path: filePath,
-        preview,
-        totalLines: lines.length,
-        sizeBytes: stat.size,
-        reason
-      });
-    } catch {
-    }
-  }
-  return results;
-}
-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
-import fs4 from "fs/promises";
-import path4 from "path";
-import { execFile as execFile6 } from "child_process";
-import { promisify as promisify6 } from "util";
-import fg4 from "fast-glob";
-init_test_map();
-
-// src/llm/providers.ts
-import { execFile as execFile5, spawn } from "child_process";
-import { promisify as promisify5 } from "util";
-
-// src/llm/config.ts
-import fs3 from "fs/promises";
-import path3 from "path";
-import os from "os";
-import { execFile as execFile4 } from "child_process";
-import { promisify as promisify4 } from "util";
-var exec4 = promisify4(execFile4);
-var CONFIG_DIR = path3.join(os.homedir(), ".mason");
-var CONFIG_FILE = path3.join(CONFIG_DIR, "config.json");
-
-// src/llm/providers.ts
-var exec5 = promisify5(execFile5);
-
-// src/snapshot/snapshot.ts
-var exec6 = promisify6(execFile6);
-function snapshotDir(rootDir) {
-  return path4.join(rootDir, ".mason");
-}
-function snapshotPath(rootDir) {
-  return path4.join(snapshotDir(rootDir), "snapshot.json");
-}
-async function loadSnapshot(rootDir) {
-  try {
-    const raw = await fs4.readFile(snapshotPath(rootDir), "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed.version !== 2) return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-async function saveSnapshot(rootDir, snapshot) {
-  await fs4.mkdir(snapshotDir(rootDir), { recursive: true });
-  await fs4.writeFile(
-    snapshotPath(rootDir),
-    JSON.stringify(snapshot, null, 2),
-    "utf-8"
-  );
-}
-async function getCurrentGitHash(rootDir) {
-  try {
-    const { stdout } = await exec6("git", ["rev-parse", "HEAD"], {
-      cwd: rootDir
-    });
-    return stdout.trim();
-  } catch {
-    return "unknown";
-  }
-}
-
-// src/mcp/tools.ts
-var exec8 = promisify8(execFile8);
-var IGNORE3 = [
-  "**/node_modules/**",
-  "**/dist/**",
-  "**/build/**",
-  "**/.gradle/**",
-  "**/target/**",
-  "**/.git/**",
-  "**/vendor/**",
-  "**/__pycache__/**",
-  "**/venv/**",
-  "**/.venv/**",
-  "**/*.min.*",
-  "**/*.map"
-];
-async function buildContext(dir) {
-  return {
-    rootDir: dir,
-    gitAvailable: await isGitRepo(dir)
-  };
-}
-async function analyzeProject(dir) {
-  const rootDir = path6.resolve(dir);
-  const context = await buildContext(rootDir);
-  const results = await runAll(context);
-  const projectSnapshot = await detectProjectSnapshot(rootDir);
-  const output = {
-    project: projectSnapshot,
-    analyzers: results.map((r) => ({
-      name: r.analyzer,
-      durationMs: r.durationMs,
-      findings: r.findings.map((f) => ({
-        category: f.category,
-        confidence: f.confidence,
-        summary: f.summary,
-        evidence: f.evidence,
-        suggestedRule: f.ruleCandidate
-      })),
-      gaps: r.gaps.map((g) => ({
-        question: g.question,
-        context: g.context
-      }))
-    }))
-  };
-  return JSON.stringify(output, null, 2);
-}
-async function detectProjectSnapshot(rootDir) {
-  const buildFiles = [
-    "package.json",
-    "tsconfig.json",
-    "build.gradle.kts",
-    "build.gradle",
-    "settings.gradle.kts",
-    "settings.gradle",
-    "gradle/libs.versions.toml",
-    "Cargo.toml",
-    "go.mod",
-    "go.sum",
-    "pyproject.toml",
-    "setup.py",
-    "requirements.txt",
-    "Pipfile",
-    "Gemfile",
-    "Package.swift",
-    "Makefile",
-    "CMakeLists.txt",
-    "Dockerfile",
-    "docker-compose.yml",
-    "docker-compose.yaml",
-    ".github/workflows",
-    ".gitlab-ci.yml",
-    "Jenkinsfile"
-  ];
-  const present = [];
-  for (const file of buildFiles) {
-    try {
-      await fs6.access(path6.join(rootDir, file));
-      present.push(file);
-    } catch {
-    }
-  }
-  const testDirs = [
-    "test",
-    "tests",
-    "__tests__",
-    "spec",
-    "src/test",
-    "src/tests",
-    "**/src/test",
-    "**/src/androidTest",
-    "**/src/iosTest"
-  ];
-  const testInfo = {};
-  for (const pattern of testDirs) {
-    const files = await fg6(`${pattern}/**/*`, {
-      cwd: rootDir,
-      ignore: IGNORE3,
-      onlyFiles: true
-    });
-    if (files.length > 0) {
-      testInfo[pattern] = files.length;
-    }
-  }
-  const testFilePatterns = [
-    { pattern: "**/*.test.*", label: "*.test.*" },
-    { pattern: "**/*.spec.*", label: "*.spec.*" },
-    { pattern: "**/*Test.kt", label: "*Test.kt" },
-    { pattern: "**/*Test.java", label: "*Test.java" },
-    { pattern: "**/test_*.py", label: "test_*.py" },
-    { pattern: "**/*_test.go", label: "*_test.go" },
-    { pattern: "**/*Tests.swift", label: "*Tests.swift" },
-    { pattern: "**/*_test.rs", label: "*_test.rs" }
-  ];
-  for (const { pattern, label } of testFilePatterns) {
-    const files = await fg6(pattern, { cwd: rootDir, ignore: IGNORE3 });
-    if (files.length > 0) {
-      testInfo[label] = files.length;
-    }
-  }
-  const sourceFiles = await fg6("**/*.{ts,tsx,js,jsx,kt,kts,java,py,go,rs,swift,rb,cs,cpp,c,dart}", {
-    cwd: rootDir,
-    ignore: IGNORE3
-  });
-  const fileCounts = {};
-  for (const file of sourceFiles) {
-    const ext = path6.extname(file).slice(1);
-    fileCounts[ext] = (fileCounts[ext] ?? 0) + 1;
-  }
-  return {
-    configFilesPresent: present,
-    sourceFileCounts: fileCounts,
-    totalSourceFiles: sourceFiles.length,
-    testInfo: Object.keys(testInfo).length > 0 ? testInfo : void 0
-  };
-}
-async function getCodeSamples(dir, count = 15) {
-  const rootDir = path6.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.",
-    files: samples.map((s) => ({
-      path: s.path,
-      reason: s.reason,
-      totalLines: s.totalLines,
-      sizeBytes: s.sizeBytes,
-      preview: s.preview
-    }))
-  };
-  return JSON.stringify(output, null, 2);
-}
-async function getProjectStructure(dir) {
-  const rootDir = path6.resolve(dir);
-  const allFiles = await fg6("**/*", {
-    cwd: rootDir,
-    ignore: IGNORE3,
-    onlyFiles: true
-  });
-  const dirInfo = /* @__PURE__ */ new Map();
-  for (const file of allFiles) {
-    const parts = file.split("/");
-    for (let depth = 1; depth <= Math.min(parts.length, 2); depth++) {
-      const dirPath = parts.slice(0, depth).join("/");
-      if (!dirInfo.has(dirPath)) {
-        dirInfo.set(dirPath, { fileCount: 0, extensions: /* @__PURE__ */ new Map() });
-      }
-      const info = dirInfo.get(dirPath);
-      info.fileCount++;
-      const ext = path6.extname(file).slice(1);
-      if (ext) {
-        info.extensions.set(ext, (info.extensions.get(ext) ?? 0) + 1);
-      }
-    }
-  }
-  const directories = [...dirInfo.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([dirPath, info]) => {
-    const extensions = {};
-    for (const [ext, count] of info.extensions) {
-      extensions[ext] = count;
-    }
-    return { path: dirPath, fileCount: info.fileCount, extensions };
-  });
-  const topLevelFiles = allFiles.filter((f) => !f.includes("/"));
-  const output = {
-    totalFiles: allFiles.length,
-    topLevelFiles,
-    directories
-  };
-  return JSON.stringify(output, null, 2);
-}
-async function getTestMap(dir) {
-  const { buildTestMap: buildTestMap2 } = await Promise.resolve().then(() => (init_test_map(), test_map_exports));
-  const result = await buildTestMap2(dir);
-  return JSON.stringify(result, null, 2);
-}
-async function getSnapshot(dir) {
-  const rootDir = path6.resolve(dir);
-  const snapshot = await loadSnapshot(rootDir);
-  if (!snapshot) {
-    return JSON.stringify({
-      exists: false,
-      message: "No concept map found. Run 'mason snapshot' to create one, or call save_snapshot with features and flows."
-    });
-  }
-  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);
-    const entry = { files: unique };
-    if (feat.tests && feat.tests.length > 0) {
-      entry.tests = feat.tests;
-    }
-    compactFeatures[name] = entry;
-  }
-  const compactFlows = {};
-  for (const [name, flow] of Object.entries(snapshot.flows)) {
-    compactFlows[name] = flow.chain;
-  }
-  const output = {
-    exists: true,
-    updatedAt: snapshot.updatedAt,
-    features: compactFeatures,
-    flows: compactFlows,
-    stale: isStale
-  };
-  if (isStale) {
-    output.message = "Snapshot is behind HEAD. Run 'mason snapshot-update' or call save_snapshot to refresh.";
-  }
-  return JSON.stringify(output);
-}
-async function fullAnalysis(dir) {
-  const rootDir = path6.resolve(dir);
-  const [analysis, structure, samples, testMap, snapshot] = await Promise.all([
-    analyzeProject(dir),
-    getProjectStructure(dir),
-    getCodeSamples(dir, 25),
-    getTestMap(dir),
-    loadSnapshot(rootDir)
-  ]);
-  const output = {
-    note: "Full project analysis. Code samples are previews (~60 lines). Use get_file_content to read any file in full.",
-    analysis: JSON.parse(analysis),
-    structure: JSON.parse(structure),
-    codeSamples: JSON.parse(samples),
-    testMap: JSON.parse(testMap)
-  };
-  if (snapshot) {
-    output.conceptMap = {
-      updatedAt: snapshot.updatedAt,
-      features: snapshot.features,
-      flows: snapshot.flows
-    };
-    output.note = "Full project analysis with concept map. The concept map shows which files implement each feature and how data flows through them. Use it to jump straight to relevant files instead of exploring. Use get_file_content to read specific files.";
-  }
-  return JSON.stringify(output, null, 2);
-}
-function sanitizePaths(rootDir, files) {
-  return files.filter((f) => {
-    const resolved = path6.resolve(rootDir, f);
-    return resolved.startsWith(rootDir) && !f.startsWith("/") && !f.includes("..");
-  });
-}
-async function saveSnapshotData(dir, features, flows) {
-  const rootDir = path6.resolve(dir);
-  const gitHash = await getCurrentGitHash(rootDir);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  for (const feat of Object.values(features)) {
-    feat.files = sanitizePaths(rootDir, feat.files);
-    if (feat.tests) feat.tests = sanitizePaths(rootDir, feat.tests);
-  }
-  for (const flow of Object.values(flows)) {
-    flow.chain = sanitizePaths(rootDir, flow.chain);
-  }
-  const existing = await loadSnapshot(rootDir);
-  if (existing) {
-    existing.features = { ...existing.features, ...features };
-    existing.flows = { ...existing.flows, ...flows };
-    existing.updatedAt = now;
-    existing.gitHash = gitHash;
-    await saveSnapshot(rootDir, existing);
-    return JSON.stringify({
-      status: "updated",
-      features: Object.keys(existing.features).length,
-      flows: Object.keys(existing.flows).length
-    });
-  }
-  const snapshot = {
-    version: 2,
-    createdAt: now,
-    updatedAt: now,
-    gitHash,
-    features,
-    flows
-  };
-  await saveSnapshot(rootDir, snapshot);
-  return JSON.stringify({
-    status: "created",
-    features: Object.keys(features).length,
-    flows: Object.keys(flows).length
-  });
-}
-async function getImpact(dir, files) {
-  const { analyzeImpact: analyzeImpact2 } = await Promise.resolve().then(() => (init_impact(), impact_exports));
-  const rootDir = path6.resolve(dir);
-  const result = await analyzeImpact2(rootDir, files);
-  return JSON.stringify(result, null, 2);
-}
-
-// src/mcp/server.ts
-function createMcpServer() {
-  const server = new McpServer(
-    {
-      name: "mason",
-      version: "0.3.7"
-    },
-    {
-      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 read specific files natively for full content.",
-    {
-      dir: z.string().describe("Absolute path to the project root directory")
-    },
-    async ({ dir }) => {
-      const result = await fullAnalysis(dir);
-      return {
-        content: [{ type: "text", text: result }]
-      };
-    }
-  );
-  server.tool(
-    "analyze_project",
-    "Run git history analysis on a codebase. Returns commit convention patterns, stale directories, and frequently changed files. These are aggregate stats across hundreds of commits that would be expensive to compute manually.",
-    {
-      dir: z.string().describe("Absolute path to the project root directory")
-    },
-    async ({ dir }) => {
-      const result = await analyzeProject(dir);
-      return {
-        content: [{ type: "text", text: result }]
-      };
-    }
-  );
-  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. 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)")
-    },
-    async ({ dir, count }) => {
-      const result = await getCodeSamples(dir, count);
-      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.",
-    {
-      dir: z.string().describe("Absolute path to the project root directory")
-    },
-    async ({ dir }) => {
-      const result = await getSnapshot(dir);
-      return {
-        content: [{ type: "text", text: result }]
-      };
-    }
-  );
-  server.tool(
-    "save_snapshot",
-    "Save a concept-to-files map as a persistent project snapshot. Maps feature names and data flows to the files that implement them. Persists across conversations \u2014 future sessions can call get_snapshot to instantly find relevant files. No API key needed \u2014 you are the LLM generating the map.",
-    {
-      dir: z.string().describe("Absolute path to the project root directory"),
-      features: z.record(
-        z.object({
-          description: z.string().describe("One-line description of the feature"),
-          files: z.array(z.string()).describe("File paths that implement this feature"),
-          tests: z.array(z.string()).optional().describe("Test file paths for this feature")
-        })
-      ).describe("Map of feature names to their implementing files"),
-      flows: z.record(
-        z.object({
-          description: z.string().describe("One-line description of the flow"),
-          chain: z.array(z.string()).describe("Ordered list of file paths showing data/call flow")
-        })
-      ).describe("Map of flow names to ordered file chains")
-    },
-    async ({ dir, features, flows }) => {
-      const result = await saveSnapshotData(dir, features, flows);
-      return {
-        content: [{ type: "text", text: result }]
-      };
-    }
-  );
-  server.tool(
-    "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"),
-      files: z.array(z.string()).describe("File paths or names to analyze (e.g., ['WeatherRepository.kt'] or ['src/services/auth.ts'])")
-    },
-    async ({ dir, files }) => {
-      const result = await getImpact(dir, files);
-      return {
-        content: [{ type: "text", text: result }]
-      };
-    }
-  );
-  return server;
-}
-async function startMcpServer() {
-  const server = createMcpServer();
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-
-// bin/mason-mcp.ts
-startMcpServer().catch((err) => {
-  process.stderr.write(`Mason MCP server error: ${err}
-`);
-  process.exit(1);
-});
-//# sourceMappingURL=mason-mcp.js.map