mason-context 0.1.0

package/dist/bin/mason.js

@@ -0,0 +1,2024 @@
+#!/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 } 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}`;
+}
+async function callClaudeCLI(system, userMessage) {
+  const fs7 = await import("fs/promises");
+  const os2 = await import("os");
+  const path6 = await import("path");
+  const prompt = `${system}
+
+${userMessage}`;
+  const tmpFile = path6.join(os2.tmpdir(), `mason-prompt-${Date.now()}.txt`);
+  try {
+    await fs7.writeFile(tmpFile, prompt, "utf-8");
+    const promptContent = await fs7.readFile(tmpFile, "utf-8");
+    const { stdout } = await exec4(
+      "sh",
+      ["-c", `cat "${tmpFile}" | claude -p`],
+      { maxBuffer: 1e7, timeout: 3e5 }
+    );
+    return stdout.trim();
+  } finally {
+    await fs7.unlink(tmpFile).catch(() => {
+    });
+  }
+}
+async function callGeminiCLI(system, userMessage) {
+  const fs7 = await import("fs/promises");
+  const os2 = await import("os");
+  const path6 = await import("path");
+  const prompt = `${system}
+
+${userMessage}`;
+  const tmpFile = path6.join(os2.tmpdir(), `mason-prompt-${Date.now()}.txt`);
+  try {
+    await fs7.writeFile(tmpFile, prompt, "utf-8");
+    const { stdout } = await exec4(
+      "sh",
+      ["-c", `cat "${tmpFile}" | gemini -p ""`],
+      { maxBuffer: 1e7, timeout: 3e5 }
+    );
+    return stdout.trim();
+  } finally {
+    await fs7.unlink(tmpFile).catch(() => {
+    });
+  }
+}
+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 sampleFiles(rootDir, maxFiles = 25) {
+  const selected = /* @__PURE__ */ new Map();
+  const projectConfig = await loadProjectConfig(rootDir);
+  const ignorePatterns = [...IGNORE_PATTERNS, ...projectConfig.ignore ?? []];
+  for (const filePath of projectConfig.alwaysInclude ?? []) {
+    if (selected.size >= maxFiles) break;
+    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.join(rootDir, filePath);
+      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;
+}
+async function readFullFile(rootDir, filePath) {
+  try {
+    const fullPath = path2.join(path2.resolve(rootDir), filePath);
+    if (!fullPath.startsWith(path2.resolve(rootDir))) 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;
+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;
+  }
+});
+
+// src/snapshot/prompt.ts
+function buildSnapshotPrompt(files) {
+  const fileBlocks = files.map(
+    (f) => `=== ${f.path} ===
+${f.content.slice(0, 3e3)}${f.content.length > 3e3 ? "\n... (truncated)" : ""}`
+  ).join("\n\n");
+  return `Create a concept-to-files map for this codebase. Here are the key source files:
+
+${fileBlocks}`;
+}
+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 path3 from "path";
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify6 } from "util";
+function snapshotDir(rootDir) {
+  return path3.join(rootDir, ".mason");
+}
+function snapshotPath(rootDir) {
+  return path3.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 = path3.resolve(rootDir);
+  const sampled = await sampleFiles(resolvedRoot, 25);
+  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 userMessage = buildSnapshotPrompt(filesWithContent);
+  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 = path3.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 = path3.resolve(rootDir);
+  const hooksDir = path3.join(resolvedRoot, ".git", "hooks");
+  try {
+    await fs4.access(hooksDir);
+  } catch {
+    throw new Error("Not a git repository (no .git/hooks directory)");
+  }
+  const hookPath = path3.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_providers();
+    init_prompt();
+    exec6 = promisify6(execFile6);
+  }
+});
+
+// src/mcp/tools.ts
+import fs5 from "fs/promises";
+import path4 from "path";
+import { execFile as execFile7 } from "child_process";
+import { promisify as promisify7 } from "util";
+import fg3 from "fast-glob";
+async function buildContext(dir) {
+  return {
+    rootDir: dir,
+    gitAvailable: await isGitRepo(dir)
+  };
+}
+async function analyzeProject(dir) {
+  const rootDir = path4.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 fs5.access(path4.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 fg3(`${pattern}/**/*`, {
+      cwd: rootDir,
+      ignore: IGNORE,
+      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 fg3(pattern, { cwd: rootDir, ignore: IGNORE });
+    if (files.length > 0) {
+      testInfo[label] = files.length;
+    }
+  }
+  const sourceFiles = await fg3("**/*.{ts,tsx,js,jsx,kt,kts,java,py,go,rs,swift,rb,cs,cpp,c,dart}", {
+    cwd: rootDir,
+    ignore: IGNORE
+  });
+  const fileCounts = {};
+  for (const file of sourceFiles) {
+    const ext = path4.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 = path4.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 getFileContent(dir, filePath) {
+  const rootDir = path4.resolve(dir);
+  const result = await readFullFile(rootDir, filePath);
+  if (!result) {
+    return JSON.stringify({ error: `Could not read file: ${filePath}` });
+  }
+  return JSON.stringify(result, null, 2);
+}
+async function getProjectStructure(dir) {
+  const rootDir = path4.resolve(dir);
+  const allFiles = await fg3("**/*", {
+    cwd: rootDir,
+    ignore: IGNORE,
+    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 = path4.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 rootDir = path4.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 = path4.basename(file).replace(/\.[^.]+$/, "");
+    const existing = sourceByBaseName.get(baseName) ?? [];
+    existing.push(file);
+    sourceByBaseName.set(baseName, existing);
+  }
+  const pairs = [];
+  const unmatched = [];
+  for (const testFile of testFiles) {
+    const testBaseName = path4.basename(testFile).replace(/\.[^.]+$/, "");
+    const sourceName = testBaseName.replace(/Test$|Tests$|Spec$|\.test$|\.spec$/, "").replace(/^test_|_test$/, "");
+    if (!sourceName) {
+      unmatched.push(testFile);
+      continue;
+    }
+    const candidates = sourceByBaseName.get(sourceName);
+    if (candidates && candidates.length > 0) {
+      const testDir = path4.dirname(testFile);
+      const bestMatch = candidates.reduce((best, candidate) => {
+        const candidateDir = path4.dirname(candidate);
+        const bestDir = path4.dirname(best);
+        const candidateOverlap = commonSegments(testDir, candidateDir);
+        const bestOverlap = commonSegments(testDir, bestDir);
+        return candidateOverlap > bestOverlap ? candidate : best;
+      });
+      pairs.push({
+        test: testFile,
+        source: bestMatch,
+        confidence: candidates.length === 1 ? "exact" : "best-guess"
+      });
+    } else {
+      unmatched.push(testFile);
+    }
+  }
+  const output = {
+    totalTestFiles: testFiles.length,
+    paired: pairs,
+    unmatched
+  };
+  return JSON.stringify(output, null, 2);
+}
+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;
+}
+async function getSnapshot(dir) {
+  const rootDir = path4.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 output = {
+    exists: true,
+    createdAt: snapshot.createdAt,
+    updatedAt: snapshot.updatedAt,
+    featureCount: Object.keys(snapshot.features).length,
+    flowCount: Object.keys(snapshot.flows).length,
+    features: snapshot.features,
+    flows: snapshot.flows,
+    stale: isStale
+  };
+  if (isStale) {
+    output.message = "Snapshot is behind HEAD. Some features/flows may reference changed files. Run 'mason snapshot-update' or call save_snapshot to refresh.";
+  }
+  return JSON.stringify(output, null, 2);
+}
+async function fullAnalysis(dir) {
+  const rootDir = path4.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);
+}
+async function saveSnapshotData(dir, features, flows) {
+  const rootDir = path4.resolve(dir);
+  const gitHash = await getCurrentGitHash(rootDir);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  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 configureProject(dir, config) {
+  const rootDir = path4.resolve(dir);
+  const configDir = path4.join(rootDir, ".mason");
+  const configPath = path4.join(configDir, "config.json");
+  let existing = {};
+  try {
+    const raw = await fs5.readFile(configPath, "utf-8");
+    existing = JSON.parse(raw);
+  } catch {
+  }
+  if (config.patterns) existing.patterns = config.patterns;
+  if (config.alwaysInclude) existing.alwaysInclude = config.alwaysInclude;
+  if (config.ignore) existing.ignore = config.ignore;
+  await fs5.mkdir(configDir, { recursive: true });
+  await fs5.writeFile(configPath, JSON.stringify(existing, null, 2), "utf-8");
+  return JSON.stringify({
+    status: "saved",
+    path: configPath,
+    config: existing
+  });
+}
+var exec7, IGNORE;
+var init_tools = __esm({
+  "src/mcp/tools.ts"() {
+    "use strict";
+    init_analyzers();
+    init_git();
+    init_sampler();
+    init_snapshot();
+    exec7 = promisify7(execFile7);
+    IGNORE = [
+      "**/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.1.0"
+    },
+    {
+      instructions: "Mason is a context engineering tool. Always call get_snapshot before using Explore agents, Glob, or Grep to understand the codebase. The snapshot is a concept map that maps features and flows to their implementing files \u2014 it eliminates the need to search. This applies to ANY question about architecture, features, flows, how things work, cross-feature interactions, or bug investigation. Workflow: 1) Call get_snapshot first. 2) If no snapshot, call full_analysis instead. 3) Use get_file_content to read the files the snapshot points to. 4) Call save_snapshot to persist your understanding for future sessions. 5) Call write_claude_md for documentation."
+    }
+  );
+  server.tool(
+    "full_analysis",
+    "Run a complete project analysis in one call. Returns git history stats, project structure with file counts, curated code sample previews (~60 lines each), and test-to-source file mapping. This is the recommended starting point \u2014 call this first, then use get_file_content to read specific files in full.",
+    {
+      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. Use get_file_content to read the full content of any file that looks interesting.",
+    {
+      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_file_content",
+    "Read the full content of a specific file. Use this after get_code_samples to drill into files you want to understand fully.",
+    {
+      dir: z.string().describe("Absolute path to the project root directory"),
+      file_path: z.string().describe("Relative path to the file within the project (e.g., 'src/main.ts')")
+    },
+    async ({ dir, file_path }) => {
+      const result = await getFileContent(dir, file_path);
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    }
+  );
+  server.tool(
+    "get_project_structure",
+    "Get the directory structure of a project with file counts and extension breakdown per directory. Shows top-level files and annotated directory listing up to 2 levels deep. Useful for understanding project layout before diving into code.",
+    {
+      dir: z.string().describe("Absolute path to the project root directory")
+    },
+    async ({ dir }) => {
+      const result = await getProjectStructure(dir);
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    }
+  );
+  server.tool(
+    "get_test_map",
+    "Map test files to their corresponding source files by name matching. Shows which source files have tests and which don't. Useful for understanding test coverage patterns and test organization conventions.",
+    {
+      dir: z.string().describe("Absolute path to the project root directory")
+    },
+    async ({ dir }) => {
+      const result = await getTestMap(dir);
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    }
+  );
+  server.tool(
+    "get_snapshot",
+    "Get the project's concept map \u2014 a lookup table from features and flows to the files that implement them. Use this to jump straight to relevant files instead of exploring. Example: 'home screen' \u2192 [HomeScreen.kt, HomeViewModel.kt, HomeModule.kt]. If stale, run 'mason snapshot-update' to refresh.",
+    {
+      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(
+    "configure_project",
+    "Configure Mason for this project. Add custom file patterns to sample, files to always include, or paths to ignore. Saved to .mason/config.json. Use this when the default architectural patterns miss important files in the project.",
+    {
+      dir: z.string().describe("Absolute path to the project root directory"),
+      patterns: z.array(z.string()).optional().describe("Custom glob patterns for architecturally important files (e.g., '**/*Gateway.*', '**/*Bloc.*')"),
+      alwaysInclude: z.array(z.string()).optional().describe("Specific file paths to always include in samples (e.g., 'src/core/config.ts')"),
+      ignore: z.array(z.string()).optional().describe("Additional glob patterns to ignore (e.g., '**/fixtures/**')")
+    },
+    async ({ dir, patterns, alwaysInclude, ignore }) => {
+      const result = await configureProject(dir, {
+        patterns,
+        alwaysInclude,
+        ignore
+      });
+      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 fs6 from "fs/promises";
+import path5 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() {
+  const program2 = new Command();
+  program2.name("mason").description(
+    "Context engineering CLI & MCP server \u2014 generates intelligent CLAUDE.md files"
+  ).version("0.1.0");
+  program2.command("setup").description("Register Mason as an MCP server with Claude Code").option("--scope <scope>", "Config scope: user or project", "user").action(async (opts) => {
+    const { execFile: execFile8 } = await import("child_process");
+    const { promisify: promisify8 } = await import("util");
+    const exec8 = promisify8(execFile8);
+    try {
+      await exec8("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 exec8("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 = path5.resolve(dir);
+    const runConfig = opts.model ? { ...config, model: opts.model } : config;
+    const spinner = ora("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 = path5.join(rootDir, ".claude");
+      await fs6.mkdir(claudeDir, { recursive: true });
+      const outPath = path5.join(claudeDir, "CLAUDE.md");
+      await fs6.writeFile(outPath, markdown, "utf-8");
+      success(`Generated ${outPath}`);
+    } 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 = path5.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("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 = path5.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("analyze").description("Analyze the codebase and print findings").argument("[dir]", "Directory to analyze", ".").action(async (dir) => {
+    const rootDir = path5.resolve(dir);
+    const spinner = ora("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