mason-context 0.3.7 → 0.6.0

package/dist/bin/mason.js

@@ -1,2338 +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/analyzers/base.ts
-import fs from "fs/promises";
-import fg from "fast-glob";
-var BaseAnalyzer;
-var init_base = __esm({
-  "src/analyzers/base.ts"() {
-    "use strict";
-    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
-import { execFile } from "child_process";
-import { promisify } from "util";
-var exec, GitHistoryAnalyzer;
-var init_git_history = __esm({
-  "src/analyzers/git-history.ts"() {
-    "use strict";
-    init_base();
-    exec = promisify(execFile);
-    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
-async function runAll(context) {
-  return Promise.all(analyzers.map((a) => a.analyze(context)));
-}
-var analyzers;
-var init_analyzers = __esm({
-  "src/analyzers/index.ts"() {
-    "use strict";
-    init_git_history();
-    analyzers = [new GitHistoryAnalyzer()];
-  }
-});
-
-// src/utils/git.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-async function isGitRepo(dir) {
-  try {
-    await exec2("git", ["rev-parse", "--git-dir"], { cwd: dir });
-    return true;
-  } catch {
-    return false;
-  }
-}
-var exec2;
-var init_git = __esm({
-  "src/utils/git.ts"() {
-    "use strict";
-    exec2 = promisify2(execFile2);
-  }
-});
-
-// src/llm/config.ts
-import fs2 from "fs/promises";
-import path from "path";
-import os from "os";
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
-async function loadConfig() {
-  try {
-    const raw = await fs2.readFile(CONFIG_FILE, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-async function saveConfig(config) {
-  await fs2.mkdir(CONFIG_DIR, { recursive: true });
-  await fs2.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
-}
-function getDefaultModel(provider) {
-  return DEFAULT_MODELS[provider];
-}
-function validateProvider(value) {
-  const valid = ["claude", "gemini", "openai", "ollama"];
-  if (!valid.includes(value)) {
-    throw new Error(
-      `Invalid provider "${value}". Must be one of: ${valid.join(", ")}`
-    );
-  }
-  return value;
-}
-async function detectCLI(provider) {
-  const cliName = provider === "claude" ? "claude" : provider === "gemini" ? "gemini" : provider === "ollama" ? "ollama" : null;
-  if (!cliName) return { available: false };
-  try {
-    const { stdout } = await exec3(cliName, ["--version"]);
-    return { available: true, version: stdout.trim() };
-  } catch {
-    return { available: false };
-  }
-}
-function needsApiKey(provider) {
-  return provider === "openai";
-}
-var exec3, CONFIG_DIR, CONFIG_FILE, DEFAULT_MODELS;
-var init_config = __esm({
-  "src/llm/config.ts"() {
-    "use strict";
-    exec3 = promisify3(execFile3);
-    CONFIG_DIR = path.join(os.homedir(), ".mason");
-    CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
-    DEFAULT_MODELS = {
-      claude: "claude-sonnet-4-20250514",
-      gemini: "gemini-2.5-flash",
-      openai: "gpt-4o",
-      ollama: "llama3"
-    };
-  }
-});
-
-// src/llm/providers.ts
-import { execFile as execFile4, spawn } from "child_process";
-import { promisify as promisify4 } from "util";
-async function callLLM(config, userMessage, systemPrompt) {
-  const model = config.model ?? getDefaultModel(config.provider);
-  const system = systemPrompt ?? CLAUDE_MD_SYSTEM_PROMPT;
-  switch (config.provider) {
-    case "claude":
-      if (config.apiKey) {
-        return {
-          type: "response",
-          text: await callClaudeAPI(config.apiKey, model, system, userMessage)
-        };
-      }
-      return {
-        type: "response",
-        text: await callClaudeCLI(system, userMessage)
-      };
-    case "ollama":
-      return {
-        type: "response",
-        text: await callOllamaCLI(
-          config.ollamaHost ?? "http://localhost:11434",
-          model,
-          system,
-          userMessage
-        )
-      };
-    case "gemini":
-      if (config.apiKey) {
-        return {
-          type: "response",
-          text: await callGeminiAPI(config.apiKey, model, system, userMessage)
-        };
-      }
-      return {
-        type: "response",
-        text: await callGeminiCLI(system, userMessage)
-      };
-    case "openai":
-      if (config.apiKey) {
-        return {
-          type: "response",
-          text: await callOpenAIAPI(config.apiKey, model, system, userMessage)
-        };
-      }
-      return {
-        type: "prompt",
-        text: formatPromptForCopy(system, userMessage)
-      };
-  }
-}
-function formatPromptForCopy(system, userMessage) {
-  return `${system}
-
----
-
-${userMessage}`;
-}
-function spawnWithStdin(command, args, input) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn(command, args, {
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 3e5
-    });
-    const onSigint = () => proc.kill("SIGINT");
-    process.on("SIGINT", onSigint);
-    let stdout = "";
-    let stderr = "";
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-    proc.on("close", (code) => {
-      process.off("SIGINT", onSigint);
-      if (code === 0) {
-        resolve(stdout.trim());
-      } else {
-        reject(new Error(`${command} exited with code ${code}: ${stderr}`));
-      }
-    });
-    proc.on("error", (err) => {
-      process.off("SIGINT", onSigint);
-      reject(err);
-    });
-    proc.stdin.write(input);
-    proc.stdin.end();
-  });
-}
-async function callClaudeCLI(system, userMessage) {
-  return spawnWithStdin("claude", ["-p", "--system-prompt", system], userMessage);
-}
-async function callGeminiCLI(system, userMessage) {
-  const prompt = `<system>
-${system}
-</system>
-
-${userMessage}`;
-  return spawnWithStdin("gemini", ["-p", ""], prompt);
-}
-async function callOllamaCLI(host, model, system, userMessage) {
-  const response = await fetch(`${host}/api/chat`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      model,
-      stream: false,
-      messages: [
-        { role: "system", content: system },
-        { role: "user", content: userMessage }
-      ]
-    })
-  });
-  const result = await response.json();
-  return result.message?.content ?? "";
-}
-async function callClaudeAPI(apiKey, model, system, userMessage) {
-  const { default: Anthropic } = await import("@anthropic-ai/sdk");
-  const client = new Anthropic({ apiKey });
-  const response = await client.messages.create({
-    model,
-    max_tokens: 8192,
-    system,
-    messages: [{ role: "user", content: userMessage }]
-  });
-  const textBlock = response.content.find((b) => b.type === "text");
-  return textBlock?.text ?? "";
-}
-async function callGeminiAPI(apiKey, model, system, userMessage) {
-  const { default: OpenAI } = await import("openai");
-  const client = new OpenAI({
-    apiKey,
-    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/"
-  });
-  const response = await client.chat.completions.create({
-    model,
-    max_tokens: 8192,
-    messages: [
-      { role: "system", content: system },
-      { role: "user", content: userMessage }
-    ]
-  });
-  return response.choices[0]?.message?.content ?? "";
-}
-async function callOpenAIAPI(apiKey, model, system, userMessage) {
-  const { default: OpenAI } = await import("openai");
-  const client = new OpenAI({ apiKey });
-  const response = await client.chat.completions.create({
-    model,
-    max_tokens: 8192,
-    messages: [
-      { role: "system", content: system },
-      { role: "user", content: userMessage }
-    ]
-  });
-  return response.choices[0]?.message?.content ?? "";
-}
-var exec4, CLAUDE_MD_SYSTEM_PROMPT;
-var init_providers = __esm({
-  "src/llm/providers.ts"() {
-    "use strict";
-    init_config();
-    exec4 = promisify4(execFile4);
-    CLAUDE_MD_SYSTEM_PROMPT = `You are Mason, a context engineering tool. You've been given a comprehensive analysis of a codebase including:
-- Git history stats (commit patterns, frequently changed files, stale directories)
-- Project structure (directory layout, file counts by type)
-- Curated code samples (key architectural files with previews)
-- Test-to-source file mapping
-
-Your job: write a COMPLETE CLAUDE.md file from scratch based ONLY on the analysis data provided below. Do NOT read any existing files in the project. Do NOT reference or preserve any existing CLAUDE.md. Generate the entire document fresh.
-
-CRITICAL: Output ONLY the raw markdown content. No preamble, no summary, no "Here's the CLAUDE.md:", no explanation, no questions, no commentary. Start directly with "# CLAUDE.md" and end with the last line of content. Your entire response will be written directly to a file.
-
-The CLAUDE.md should include:
-- Project overview (what it is, tech stack, architecture)
-- Module/package structure and boundaries
-- Code conventions and patterns you observe in the samples
-- Testing conventions and coverage
-- Build and development commands
-- Important files and hot spots
-- Any warnings or gotchas
-
-Be specific and actionable. Reference actual file paths. Don't be generic \u2014 every rule should be grounded in what you see in the data.`;
-  }
-});
-
-// src/mcp/sampler.ts
-import fs3 from "fs/promises";
-import path2 from "path";
-import { execFile as execFile5 } from "child_process";
-import { promisify as promisify5 } from "util";
-import fg2 from "fast-glob";
-async function loadProjectConfig(rootDir) {
-  try {
-    const raw = await fs3.readFile(
-      path2.join(rootDir, ".mason", "config.json"),
-      "utf-8"
-    );
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-async function getTrackedFiles(rootDir) {
-  try {
-    const { stdout } = await exec5("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 = path2.resolve(rootDir, filePath);
-    if (!resolvedPath.startsWith(path2.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 exec5(
-      "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 = path2.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 = path2.resolve(rootDir, filePath);
-      if (!fullPath.startsWith(path2.resolve(rootDir))) continue;
-      if (isSensitiveFile(filePath)) continue;
-      if (trackedFiles && !trackedFiles.has(filePath)) continue;
-      const stat = await fs3.stat(fullPath);
-      if (stat.size > 1e5) continue;
-      const content = await fs3.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;
-}
-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,
-      content,
-      totalLines: content.split("\n").length
-    };
-  } catch {
-    return null;
-  }
-}
-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";
-    exec5 = promisify5(execFile5);
-    SOURCE_EXTENSIONS = [
-      "ts",
-      "tsx",
-      "js",
-      "jsx",
-      "mts",
-      "mjs",
-      "kt",
-      "kts",
-      "java",
-      "py",
-      "go",
-      "rs",
-      "swift",
-      "rb",
-      "cs",
-      "cpp",
-      "c",
-      "h",
-      "dart"
-    ];
-    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"
-    ];
-    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"
-    ];
-    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)" }
-    ];
-    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"
-    ];
-    PREVIEW_LINES = 60;
-    SENSITIVE_PATTERNS = [
-      /^\.env$/,
-      /^\.env\./,
-      /\.pem$/,
-      /\.key$/,
-      /\.p12$/,
-      /\.pfx$/,
-      /\.jks$/,
-      /id_rsa/,
-      /id_ed25519/,
-      /credentials\./,
-      /secret/i,
-      /\.keystore$/,
-      /local\.properties$/
-    ];
-  }
-});
-
-// src/test-map.ts
-var test_map_exports = {};
-__export(test_map_exports, {
-  buildTestMap: () => buildTestMap
-});
-import path3 from "path";
-import fg3 from "fast-glob";
-async function buildTestMap(dir) {
-  const rootDir = path3.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 = path3.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 = path3.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 = path3.dirname(testFile);
-      const bestMatch = candidates.reduce((best, candidate) => {
-        const candidateDir = path3.dirname(candidate);
-        const bestDir = path3.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/snapshot/prompt.ts
-function buildSnapshotPrompt(files, testPairs) {
-  const fileBlocks = files.map(
-    (f) => `=== ${f.path} ===
-${f.content.slice(0, 3e3)}${f.content.length > 3e3 ? "\n... (truncated)" : ""}`
-  ).join("\n\n");
-  let prompt = `Create a concept-to-files map for this codebase. Here are the key source files:
-
-${fileBlocks}`;
-  if (testPairs && testPairs.length > 0) {
-    const testBlock = testPairs.map((p) => `${p.test} \u2192 ${p.source}`).join("\n");
-    prompt += `
-
-Here are the test-to-source file mappings. Use these to populate the "tests" field for each feature:
-
-${testBlock}`;
-  }
-  return prompt;
-}
-function buildIncrementalPrompt(files, existingSnapshot) {
-  const fileBlocks = files.map(
-    (f) => `=== ${f.path} ===
-${f.content.slice(0, 3e3)}${f.content.length > 3e3 ? "\n... (truncated)" : ""}`
-  ).join("\n\n");
-  return `Here is the existing concept map for this project:
-${JSON.stringify(existingSnapshot, null, 2)}
-
-These files have been added or changed. Update the concept map to incorporate them. Return the FULL updated map (not just the changes).
-
-Changed/new files:
-${fileBlocks}`;
-}
-var SNAPSHOT_SYSTEM_PROMPT;
-var init_prompt = __esm({
-  "src/snapshot/prompt.ts"() {
-    "use strict";
-    SNAPSHOT_SYSTEM_PROMPT = `You are Mason, a context engineering tool. You're given source files from a codebase. Your job is to create a concept-to-files map that helps an AI coding assistant instantly find the right files for any task.
-
-Respond with ONLY a JSON object. No markdown, no explanation, no code fences. Just the raw JSON.
-
-The JSON must have two keys: "features" and "flows".
-
-"features" maps user-facing feature names or concepts to the files that implement them. Group files by what a developer would naturally ask about. Use plain language names ("home screen", not "HomeScreenModule").
-
-"flows" maps data/action flows to ordered chains of files showing how data moves through the system. These help when someone asks "what happens when X?"
-
-Example output:
-{
-  "features": {
-    "user authentication": {
-      "description": "Login, signup, token refresh, and session management",
-      "files": ["src/services/AuthService.ts", "src/middleware/AuthMiddleware.ts", "src/models/User.ts", "src/routes/auth.ts"],
-      "tests": ["tests/auth.test.ts"]
-    },
-    "payment processing": {
-      "description": "Stripe integration for subscriptions and one-time payments",
-      "files": ["src/services/PaymentService.ts", "src/webhooks/stripe.ts", "src/models/Subscription.ts"],
-      "tests": ["tests/payment.test.ts"]
-    }
-  },
-  "flows": {
-    "user login": {
-      "description": "User submits credentials, gets JWT token",
-      "chain": ["src/routes/auth.ts", "src/services/AuthService.ts", "src/models/User.ts"]
-    },
-    "process payment": {
-      "description": "User initiates payment, Stripe charges card, webhook confirms",
-      "chain": ["src/routes/payment.ts", "src/services/PaymentService.ts", "src/webhooks/stripe.ts"]
-    }
-  }
-}
-
-Rules:
-- Use the FULL relative file paths exactly as given in the input
-- Group by what a human would naturally ask about, not by technical structure
-- Each feature should have 2-8 files \u2014 not too granular, not too broad
-- Flows should show the actual call chain order
-- Include test files in the "tests" field when they exist
-- Cover ALL the files you're given \u2014 don't skip any`;
-  }
-});
-
-// src/snapshot/snapshot.ts
-var snapshot_exports = {};
-__export(snapshot_exports, {
-  createSnapshot: () => createSnapshot,
-  getCurrentGitHash: () => getCurrentGitHash,
-  installHook: () => installHook,
-  loadSnapshot: () => loadSnapshot,
-  saveSnapshot: () => saveSnapshot,
-  updateSnapshot: () => updateSnapshot
-});
-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";
-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";
-  }
-}
-function parseSnapshotResponse(raw) {
-  let cleaned = raw.trim();
-  if (cleaned.startsWith("```")) {
-    cleaned = cleaned.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
-  }
-  try {
-    const parsed = JSON.parse(cleaned);
-    return {
-      features: parsed.features ?? {},
-      flows: parsed.flows ?? {}
-    };
-  } catch {
-    const match = raw.match(/\{[\s\S]*\}/);
-    if (match) {
-      try {
-        const parsed = JSON.parse(match[0]);
-        return {
-          features: parsed.features ?? {},
-          flows: parsed.flows ?? {}
-        };
-      } catch {
-        return { features: {}, flows: {} };
-      }
-    }
-    return { features: {}, flows: {} };
-  }
-}
-async function createSnapshot(rootDir, config) {
-  const resolvedRoot = path4.resolve(rootDir);
-  const allFiles = await fg4(
-    "**/*.{ts,tsx,js,jsx,kt,kts,java,py,go,rs,swift,rb,cs,cpp,c,dart}",
-    {
-      cwd: resolvedRoot,
-      ignore: [
-        "**/node_modules/**",
-        "**/dist/**",
-        "**/build/**",
-        "**/.gradle/**",
-        "**/target/**",
-        "**/.git/**",
-        "**/vendor/**",
-        "**/__pycache__/**",
-        "**/venv/**",
-        "**/.venv/**",
-        "**/*.min.*",
-        "**/*.map",
-        "**/generated/**",
-        "**/R.java",
-        "**/BuildConfig.java"
-      ]
-    }
-  );
-  const sampleCount = Math.min(80, Math.max(20, Math.round(allFiles.length * 0.15)));
-  const sampled = await sampleFiles(resolvedRoot, sampleCount);
-  const filesWithContent = [];
-  for (const sample of sampled) {
-    const full = await readFullFile(resolvedRoot, sample.path);
-    if (full) {
-      filesWithContent.push({ path: full.path, content: full.content });
-    }
-  }
-  const gitHash = await getCurrentGitHash(resolvedRoot);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  if (filesWithContent.length === 0) {
-    return {
-      version: 2,
-      createdAt: now,
-      updatedAt: now,
-      gitHash,
-      features: {},
-      flows: {}
-    };
-  }
-  const testMap = await buildTestMap(resolvedRoot);
-  const userMessage = buildSnapshotPrompt(filesWithContent, testMap.paired);
-  const result = await callLLM(config, userMessage, SNAPSHOT_SYSTEM_PROMPT);
-  const resultText = typeof result === "string" ? result : result.type === "response" ? result.text : "";
-  if (!resultText) {
-    throw new Error(
-      "No CLI or API key available for this provider. Use claude or ollama (no key needed), or provide an API key."
-    );
-  }
-  const { features, flows } = parseSnapshotResponse(resultText);
-  const snapshot = {
-    version: 2,
-    createdAt: now,
-    updatedAt: now,
-    gitHash,
-    features,
-    flows
-  };
-  await saveSnapshot(resolvedRoot, snapshot);
-  return snapshot;
-}
-async function updateSnapshot(rootDir, config) {
-  const resolvedRoot = path4.resolve(rootDir);
-  const existing = await loadSnapshot(resolvedRoot);
-  if (!existing) {
-    const snapshot = await createSnapshot(rootDir, config);
-    const featureCount = Object.keys(snapshot.features).length;
-    const flowCount = Object.keys(snapshot.flows).length;
-    return {
-      status: "created",
-      details: `New snapshot: ${featureCount} features, ${flowCount} flows`
-    };
-  }
-  let changedFiles = [];
-  try {
-    const { stdout } = await exec6(
-      "git",
-      ["diff", "--name-only", existing.gitHash, "HEAD"],
-      { cwd: resolvedRoot }
-    );
-    changedFiles = stdout.trim().split("\n").filter((f) => f.length > 0);
-  } catch {
-    const snapshot = await createSnapshot(rootDir, config);
-    const featureCount = Object.keys(snapshot.features).length;
-    return { status: "rebuilt", details: `${featureCount} features` };
-  }
-  if (changedFiles.length === 0) {
-    return { status: "up-to-date", details: "No changes since last snapshot" };
-  }
-  const sampled = await sampleFiles(resolvedRoot, 30);
-  const sampledPaths = new Set(sampled.map((s) => s.path));
-  const snapshotFiles = /* @__PURE__ */ new Set();
-  for (const feature of Object.values(existing.features)) {
-    for (const f of feature.files) snapshotFiles.add(f);
-    for (const t of feature.tests ?? []) snapshotFiles.add(t);
-  }
-  for (const flow of Object.values(existing.flows)) {
-    for (const f of flow.chain) snapshotFiles.add(f);
-  }
-  const relevantChanges = changedFiles.filter(
-    (f) => sampledPaths.has(f) || snapshotFiles.has(f)
-  );
-  if (relevantChanges.length === 0) {
-    existing.gitHash = await getCurrentGitHash(resolvedRoot);
-    existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await saveSnapshot(resolvedRoot, existing);
-    return {
-      status: "unchanged",
-      details: `${changedFiles.length} files changed but none affect the concept map`
-    };
-  }
-  const filesWithContent = [];
-  for (const filePath of relevantChanges) {
-    const full = await readFullFile(resolvedRoot, filePath);
-    if (full) {
-      filesWithContent.push({ path: full.path, content: full.content });
-    }
-  }
-  if (filesWithContent.length === 0) {
-    return { status: "unchanged", details: "Changed files could not be read" };
-  }
-  const userMessage = buildIncrementalPrompt(filesWithContent, {
-    features: existing.features,
-    flows: existing.flows
-  });
-  const result = await callLLM(config, userMessage, SNAPSHOT_SYSTEM_PROMPT);
-  const resultText = typeof result === "string" ? result : result.type === "response" ? result.text : "";
-  if (!resultText) {
-    throw new Error("No CLI or API key available for this provider.");
-  }
-  const { features, flows } = parseSnapshotResponse(resultText);
-  const gitHash = await getCurrentGitHash(resolvedRoot);
-  existing.features = features;
-  existing.flows = flows;
-  existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  existing.gitHash = gitHash;
-  await saveSnapshot(resolvedRoot, existing);
-  return {
-    status: "updated",
-    details: `${Object.keys(features).length} features, ${Object.keys(flows).length} flows (${relevantChanges.length} files changed)`
-  };
-}
-async function installHook(rootDir) {
-  const resolvedRoot = path4.resolve(rootDir);
-  const hooksDir = path4.join(resolvedRoot, ".git", "hooks");
-  try {
-    await fs4.access(hooksDir);
-  } catch {
-    throw new Error("Not a git repository (no .git/hooks directory)");
-  }
-  const hookPath = path4.join(hooksDir, "post-commit");
-  const hookContent = `#!/bin/sh
-# Mason: auto-update project snapshot after commit
-# Runs in background so it doesn't block your workflow
-mason snapshot-update "$(git rev-parse --show-toplevel)" &
-`;
-  try {
-    const existing = await fs4.readFile(hookPath, "utf-8");
-    if (existing.includes("mason snapshot-update")) {
-      return;
-    }
-    await fs4.appendFile(hookPath, "\n" + hookContent);
-  } catch {
-    await fs4.writeFile(hookPath, hookContent, { mode: 493 });
-  }
-}
-var exec6;
-var init_snapshot = __esm({
-  "src/snapshot/snapshot.ts"() {
-    "use strict";
-    init_sampler();
-    init_test_map();
-    init_providers();
-    init_prompt();
-    exec6 = promisify6(execFile6);
-  }
-});
-
-// 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/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";
-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 info2 = dirInfo.get(dirPath);
-      info2.fileCount++;
-      const ext = path6.extname(file).slice(1);
-      if (ext) {
-        info2.extensions.set(ext, (info2.extensions.get(ext) ?? 0) + 1);
-      }
-    }
-  }
-  const directories = [...dirInfo.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([dirPath, info2]) => {
-    const extensions = {};
-    for (const [ext, count] of info2.extensions) {
-      extensions[ext] = count;
-    }
-    return { path: dirPath, fileCount: info2.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);
-}
-var exec8, IGNORE3;
-var init_tools = __esm({
-  "src/mcp/tools.ts"() {
-    "use strict";
-    init_analyzers();
-    init_git();
-    init_sampler();
-    init_snapshot();
-    exec8 = promisify8(execFile8);
-    IGNORE3 = [
-      "**/node_modules/**",
-      "**/dist/**",
-      "**/build/**",
-      "**/.gradle/**",
-      "**/target/**",
-      "**/.git/**",
-      "**/vendor/**",
-      "**/__pycache__/**",
-      "**/venv/**",
-      "**/.venv/**",
-      "**/*.min.*",
-      "**/*.map"
-    ];
-  }
-});
-
-// src/mcp/server.ts
-var server_exports = {};
-__export(server_exports, {
-  createMcpServer: () => createMcpServer,
-  startMcpServer: () => startMcpServer
-});
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-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);
-}
-var init_server = __esm({
-  "src/mcp/server.ts"() {
-    "use strict";
-    init_tools();
-  }
-});
-
-// src/cli.ts
-init_analyzers();
-init_git();
-init_config();
-init_providers();
-init_tools();
-import { Command } from "commander";
-import fs7 from "fs/promises";
-import path7 from "path";
-import ora from "ora";
-import chalk2 from "chalk";
-
-// src/utils/logger.ts
-import chalk from "chalk";
-var verbose = false;
-function info(msg) {
-  console.log(chalk.blue("\u2139"), msg);
-}
-function success(msg) {
-  console.log(chalk.green("\u2714"), msg);
-}
-function error(msg) {
-  console.error(chalk.red("\u2716"), msg);
-}
-function debug(msg) {
-  if (verbose) {
-    console.log(chalk.gray("\u22EF"), msg);
-  }
-}
-
-// src/cli.ts
-async function buildContext2(dir) {
-  return {
-    rootDir: dir,
-    gitAvailable: await isGitRepo(dir)
-  };
-}
-function printFindings(results) {
-  for (const result of results) {
-    if (result.findings.length === 0) {
-      debug(`${result.analyzer}: no findings`);
-      continue;
-    }
-    console.log(
-      chalk2.bold(`
-\u{1F4CB} ${result.analyzer}`) + chalk2.gray(` (${result.durationMs}ms)`)
-    );
-    for (const finding of result.findings) {
-      const conf = chalk2.gray(`[${Math.round(finding.confidence * 100)}%]`);
-      console.log(`  ${conf} ${finding.summary}`);
-      for (const ev of finding.evidence) {
-        console.log(chalk2.gray(`       ${ev.filePath}: ${ev.detail}`));
-      }
-    }
-  }
-}
-function extractMarkdown(raw) {
-  const trimmed = raw.trim();
-  if (trimmed.startsWith("# ")) return trimmed;
-  const fenceMatch = trimmed.match(/```(?:markdown|md)?\n([\s\S]*?)```/);
-  if (fenceMatch) return fenceMatch[1].trim();
-  const headingIndex = trimmed.search(/^# /m);
-  if (headingIndex >= 0) return trimmed.slice(headingIndex).trim();
-  const subheadingIndex = trimmed.search(/^## /m);
-  if (subheadingIndex >= 0) return trimmed.slice(subheadingIndex).trim();
-  return trimmed;
-}
-function createCLI() {
-  process.on("SIGINT", () => process.exit(130));
-  const program2 = new Command();
-  program2.name("mason").description(
-    "Context engineering CLI & MCP server \u2014 generates intelligent CLAUDE.md files"
-  ).version("0.3.7");
-  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: execFile9 } = await import("child_process");
-    const { promisify: promisify9 } = await import("util");
-    const exec9 = promisify9(execFile9);
-    try {
-      await exec9("claude", ["--version"]);
-    } catch {
-      error(
-        "Claude Code CLI not found. Install it from https://claude.ai/code"
-      );
-      process.exit(1);
-    }
-    try {
-      const args = [
-        "mcp",
-        "add",
-        "mason",
-        "--scope",
-        opts.scope,
-        "--",
-        "npx",
-        "mason-ai",
-        "mcp"
-      ];
-      await exec9("claude", args);
-      success("Mason registered with Claude Code.");
-      info("Restart Claude Code to start using Mason's tools.");
-    } catch (err) {
-      error(
-        `Failed to register: ${err instanceof Error ? err.message : String(err)}`
-      );
-      process.exit(1);
-    }
-  });
-  program2.command("set-llm").description("Configure the LLM provider for standalone generation").argument("<provider>", "LLM provider: claude, gemini, openai, or ollama").argument("[api-key]", "API key (not needed for claude or ollama)").option("--model <model>", "Override the default model").option("--ollama-host <host>", "Ollama server URL", "http://localhost:11434").action(
-    async (provider, apiKey, opts) => {
-      const validProvider = validateProvider(provider);
-      if (needsApiKey(validProvider) && !apiKey) {
-        error(
-          `API key is required for ${validProvider}. Usage: mason set-llm ${validProvider} <api-key>`
-        );
-        process.exit(1);
-      }
-      if (!apiKey && !needsApiKey(validProvider)) {
-        const cli = await detectCLI(validProvider);
-        if (!cli.available) {
-          const hints = {
-            claude: "Claude Code CLI not found. Install it from https://claude.ai/code, or provide an API key: mason set-llm claude <api-key>",
-            gemini: "Gemini CLI not found. Install it from https://ai.google.dev/gemini-api/docs/cli, or provide an API key: mason set-llm gemini <api-key>",
-            ollama: "Ollama not found. Install it from https://ollama.ai"
-          };
-          error(hints[validProvider] ?? "CLI not found for this provider.");
-          process.exit(1);
-        }
-        info(
-          `Found ${validProvider} CLI (${cli.version ?? "installed"}). No API key needed.`
-        );
-      }
-      const config = {
-        provider: validProvider,
-        apiKey,
-        model: opts.model,
-        ollamaHost: validProvider === "ollama" ? opts.ollamaHost : void 0
-      };
-      await saveConfig(config);
-      const model = config.model ?? getDefaultModel(validProvider);
-      success(
-        `Configured ${validProvider} (model: ${model}). Run "mason generate" to create a CLAUDE.md.`
-      );
-    }
-  );
-  program2.command("generate").description("Analyze codebase and generate CLAUDE.md using configured LLM").argument("[dir]", "Directory to analyze", ".").option("--model <model>", "Override the configured model for this run").action(async (dir, opts) => {
-    const config = await loadConfig();
-    if (!config) {
-      error(
-        'No LLM configured. Run "mason set-llm <provider> <api-key>" first.'
-      );
-      process.exit(1);
-    }
-    const rootDir = path7.resolve(dir);
-    const runConfig = opts.model ? { ...config, model: opts.model } : config;
-    const spinner = ora({ discardStdin: false, text: "Analyzing codebase..." }).start();
-    const analysisData = await fullAnalysis(rootDir);
-    spinner.text = `Generating CLAUDE.md with ${runConfig.provider}...`;
-    try {
-      const result = await callLLM(
-        runConfig,
-        `Here is the full project analysis. Write a CLAUDE.md based on this data:
-
-${analysisData}`
-      );
-      spinner.stop();
-      if (result.type === "prompt") {
-        console.log(
-          chalk2.bold("\nNo API key or CLI available. Copy this prompt into your LLM:\n")
-        );
-        console.log(chalk2.gray("\u2500".repeat(60)));
-        console.log(result.text);
-        console.log(chalk2.gray("\u2500".repeat(60)));
-        console.log(
-          chalk2.gray("\nPaste the LLM's response into CLAUDE.md manually.")
-        );
-        return;
-      }
-      const markdown = extractMarkdown(result.text);
-      if (!markdown.trim()) {
-        error("LLM returned empty response.");
-        process.exit(1);
-      }
-      const claudeDir = path7.join(rootDir, ".claude");
-      await fs7.mkdir(claudeDir, { recursive: true });
-      const outPath = path7.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({ discardStdin: false, text: "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 = path7.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(
-        `Failed to generate: ${err instanceof Error ? err.message : String(err)}`
-      );
-      process.exit(1);
-    }
-  });
-  program2.command("snapshot").description("Generate a persistent project snapshot using LLM").argument("[dir]", "Directory to analyze", ".").option("--install-hook", "Install a post-commit git hook to auto-update").action(async (dir, opts) => {
-    const {
-      createSnapshot: createSnapshot2,
-      installHook: installHook2
-    } = await Promise.resolve().then(() => (init_snapshot(), snapshot_exports));
-    const rootDir = path7.resolve(dir);
-    if (opts.installHook) {
-      try {
-        await installHook2(rootDir);
-        success("Post-commit hook installed. Snapshot will auto-update on each commit.");
-      } catch (err) {
-        error(
-          `Failed to install hook: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-      return;
-    }
-    const config = await loadConfig();
-    if (!config) {
-      error(
-        'No LLM configured. Run "mason set-llm <provider> <api-key>" first.'
-      );
-      process.exit(1);
-    }
-    const spinner = ora({ discardStdin: false, text: "Building project snapshot..." }).start();
-    try {
-      const snapshot = await createSnapshot2(rootDir, config);
-      spinner.stop();
-      const featureCount = Object.keys(snapshot.features).length;
-      const flowCount = Object.keys(snapshot.flows).length;
-      success(
-        `Concept map created: ${featureCount} features, ${flowCount} flows \u2192 .mason/snapshot.json`
-      );
-    } catch (err) {
-      spinner.stop();
-      error(
-        `Failed to create snapshot: ${err instanceof Error ? err.message : String(err)}`
-      );
-      process.exit(1);
-    }
-  });
-  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 = path7.resolve(dir);
-    const config = await loadConfig();
-    if (!config) return;
-    try {
-      const result = await updateSnapshot2(rootDir, config);
-      if (result.status === "up-to-date" || result.status === "unchanged") {
-        return;
-      }
-      success(`Concept map ${result.status}: ${result.details}`);
-    } 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 = path7.resolve(opts.dir);
-    const spinner = ora({ discardStdin: false, text: "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 = path7.resolve(dir);
-    const spinner = ora({ discardStdin: false, text: "Analyzing codebase..." }).start();
-    const context = await buildContext2(rootDir);
-    const results = await runAll(context);
-    spinner.stop();
-    printFindings(results);
-    const totalFindings = results.reduce(
-      (sum, r) => sum + r.findings.length,
-      0
-    );
-    console.log(
-      chalk2.bold(`
-${totalFindings} findings from ${results.length} analyzers`)
-    );
-  });
-  program2.command("mcp").description("Start the MCP server (stdio transport)").action(async () => {
-    const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
-    await startMcpServer2();
-  });
-  return program2;
-}
-
-// bin/mason.ts
-var program = createCLI();
-program.parse();
-//# sourceMappingURL=mason.js.map