mason-context 0.1.0

package/dist/bin/mason-mcp.js

@@ -0,0 +1,1206 @@
+#!/usr/bin/env node
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/mcp/tools.ts
+import 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";
+
+// src/analyzers/git-history.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/analyzers/base.ts
+import fs from "fs/promises";
+import fg from "fast-glob";
+var BaseAnalyzer = class {
+  async findFiles(patterns, root) {
+    return fg(patterns, {
+      cwd: root,
+      ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"],
+      absolute: true
+    });
+  }
+  async readFile(filePath) {
+    return fs.readFile(filePath, "utf-8");
+  }
+  createFinding(partial) {
+    return {
+      analyzer: this.name,
+      category: partial.category,
+      confidence: partial.confidence,
+      summary: partial.summary,
+      evidence: partial.evidence ?? [],
+      ruleCandidate: partial.ruleCandidate ?? null
+    };
+  }
+  createResult(findings, gaps, startTime) {
+    return {
+      analyzer: this.name,
+      findings,
+      gaps,
+      durationMs: Date.now() - startTime
+    };
+  }
+};
+
+// src/analyzers/git-history.ts
+var exec = promisify(execFile);
+var GitHistoryAnalyzer = class extends BaseAnalyzer {
+  name = "git-history";
+  async analyze(context) {
+    const startTime = Date.now();
+    const findings = [];
+    const gaps = [];
+    if (!context.gitAvailable) {
+      return this.createResult([], [], startTime);
+    }
+    const [staleFindings, staleGaps] = await this.findStaleDirectories(context);
+    findings.push(...staleFindings);
+    gaps.push(...staleGaps);
+    const hotFindings = await this.findHotFiles(context);
+    findings.push(...hotFindings);
+    const commitFindings = await this.analyzeCommitPatterns(context);
+    findings.push(...commitFindings);
+    return this.createResult(findings, gaps, startTime);
+  }
+  async git(args, cwd) {
+    try {
+      const { stdout } = await exec("git", args, { cwd, maxBuffer: 1e7 });
+      return stdout.trim();
+    } catch {
+      return "";
+    }
+  }
+  async findStaleDirectories(context) {
+    const findings = [];
+    const gaps = [];
+    const output = await this.git(
+      ["log", "--all", "--format=%ci", "--name-only", "--diff-filter=AMCR", "-n", "500"],
+      context.rootDir
+    );
+    if (!output) return [findings, gaps];
+    const dirLastTouch = /* @__PURE__ */ new Map();
+    let currentDate = null;
+    for (const line of output.split("\n")) {
+      if (!line) continue;
+      if (/^\d{4}-\d{2}-\d{2}/.test(line)) {
+        currentDate = new Date(line);
+      } else if (currentDate) {
+        const topDir = line.split("/")[0];
+        if (topDir && !topDir.startsWith(".") && !topDir.includes("node_modules")) {
+          const existing = dirLastTouch.get(topDir);
+          if (!existing || currentDate > existing) {
+            dirLastTouch.set(topDir, currentDate);
+          }
+        }
+      }
+    }
+    const sixMonthsAgo = /* @__PURE__ */ new Date();
+    sixMonthsAgo.setMonth(sixMonthsAgo.getMonth() - 6);
+    for (const [dir, lastTouch] of dirLastTouch) {
+      if (lastTouch < sixMonthsAgo) {
+        const monthsStale = Math.floor(
+          (Date.now() - lastTouch.getTime()) / (1e3 * 60 * 60 * 24 * 30)
+        );
+        findings.push(
+          this.createFinding({
+            category: "risk",
+            confidence: 0.7,
+            summary: `Directory "${dir}" hasn't been modified in ${monthsStale} months`,
+            evidence: [
+              { filePath: dir, detail: `Last commit: ${lastTouch.toISOString().split("T")[0]}` }
+            ],
+            ruleCandidate: `Do not refactor or modify files in "${dir}/" unless explicitly asked \u2014 this area has been stable for ${monthsStale} months and may be legacy code.`
+          })
+        );
+        gaps.push({
+          analyzer: this.name,
+          question: `Directory "${dir}" hasn't been touched in ${monthsStale} months. Is it deprecated, stable, or legacy?`,
+          context: `Last modified: ${lastTouch.toISOString().split("T")[0]}`,
+          answerKey: `stale-dir-${dir}`
+        });
+      }
+    }
+    return [findings, gaps];
+  }
+  async findHotFiles(context) {
+    const findings = [];
+    const output = await this.git(
+      ["log", "--since=3 months ago", "--format=", "--name-only"],
+      context.rootDir
+    );
+    if (!output) return findings;
+    const fileCounts = /* @__PURE__ */ new Map();
+    for (const line of output.split("\n")) {
+      if (!line || line.startsWith(".") || line.includes("node_modules")) continue;
+      fileCounts.set(line, (fileCounts.get(line) ?? 0) + 1);
+    }
+    const sorted = [...fileCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
+    if (sorted.length > 0 && sorted[0][1] >= 5) {
+      const hotFiles = sorted.filter(([, count]) => count >= 5);
+      if (hotFiles.length > 0) {
+        findings.push(
+          this.createFinding({
+            category: "risk",
+            confidence: 0.8,
+            summary: `${hotFiles.length} files changed frequently in the last 3 months`,
+            evidence: hotFiles.map(([file, count]) => ({
+              filePath: file,
+              detail: `${count} commits`
+            })),
+            ruleCandidate: `These files change frequently and are high-risk for conflicts: ${hotFiles.map(([f]) => f).join(", ")}. Take extra care when modifying them.`
+          })
+        );
+      }
+    }
+    return findings;
+  }
+  async analyzeCommitPatterns(context) {
+    const findings = [];
+    const output = await this.git(
+      ["log", "--format=%s", "-n", "100"],
+      context.rootDir
+    );
+    if (!output) return findings;
+    const messages = output.split("\n").filter(Boolean);
+    const conventionalPattern = /^(feat|fix|chore|docs|style|refactor|test|perf|ci|build|revert)(\(.+\))?:/;
+    const conventionalCount = messages.filter(
+      (m) => conventionalPattern.test(m)
+    ).length;
+    const conventionalRatio = conventionalCount / messages.length;
+    if (conventionalRatio > 0.5) {
+      findings.push(
+        this.createFinding({
+          category: "convention",
+          confidence: Math.min(conventionalRatio + 0.1, 1),
+          summary: `${Math.round(conventionalRatio * 100)}% of recent commits use conventional commit format`,
+          evidence: [
+            {
+              filePath: ".git",
+              detail: `${conventionalCount} of ${messages.length} commits match`
+            }
+          ],
+          ruleCandidate: "Use conventional commit format: type(scope): description (e.g., feat(auth): add login endpoint)"
+        })
+      );
+    }
+    const ticketPattern = /[A-Z]+-\d+|#\d+/;
+    const ticketCount = messages.filter((m) => ticketPattern.test(m)).length;
+    const ticketRatio = ticketCount / messages.length;
+    if (ticketRatio > 0.3) {
+      findings.push(
+        this.createFinding({
+          category: "convention",
+          confidence: ticketRatio,
+          summary: `${Math.round(ticketRatio * 100)}% of commits reference issue/ticket IDs`,
+          evidence: [
+            {
+              filePath: ".git",
+              detail: `${ticketCount} of ${messages.length} commits have ticket refs`
+            }
+          ],
+          ruleCandidate: "Include issue/ticket references in commit messages when applicable."
+        })
+      );
+    }
+    return findings;
+  }
+};
+
+// src/analyzers/index.ts
+var analyzers = [new GitHistoryAnalyzer()];
+async function runAll(context) {
+  return Promise.all(analyzers.map((a) => a.analyze(context)));
+}
+
+// src/utils/git.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var exec2 = promisify2(execFile2);
+async function isGitRepo(dir) {
+  try {
+    await exec2("git", ["rev-parse", "--git-dir"], { cwd: dir });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/mcp/sampler.ts
+import fs2 from "fs/promises";
+import path from "path";
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+import fg2 from "fast-glob";
+var exec3 = promisify3(execFile3);
+var SOURCE_EXTENSIONS = [
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mts",
+  "mjs",
+  "kt",
+  "kts",
+  "java",
+  "py",
+  "go",
+  "rs",
+  "swift",
+  "rb",
+  "cs",
+  "cpp",
+  "c",
+  "h",
+  "dart"
+];
+var CONFIG_FILES = [
+  // Build & project config
+  "package.json",
+  "tsconfig.json",
+  "build.gradle.kts",
+  "build.gradle",
+  "settings.gradle.kts",
+  "settings.gradle",
+  "Cargo.toml",
+  "go.mod",
+  "pyproject.toml",
+  "Gemfile",
+  "*.csproj",
+  // Version catalogs & dependency locks
+  "gradle/libs.versions.toml",
+  // Code quality & formatting
+  ".editorconfig",
+  ".eslintrc.*",
+  "eslint.config.*",
+  ".prettierrc",
+  "rustfmt.toml",
+  ".swiftlint.yml",
+  // CI/CD
+  ".github/workflows/*.yml",
+  ".gitlab-ci.yml",
+  "Jenkinsfile",
+  // Containerization
+  "Dockerfile",
+  "docker-compose.yml",
+  "docker-compose.yaml"
+];
+var ENTRY_POINT_PATTERNS = [
+  "src/main.*",
+  "src/index.*",
+  "src/app.*",
+  "main.*",
+  "index.*",
+  "app.*",
+  "App.*",
+  "**/Main.kt",
+  "**/Application.kt",
+  "**/main.py",
+  "**/main.go",
+  "**/main.rs",
+  "**/lib.rs",
+  "**/Program.cs"
+];
+var ARCHITECTURAL_PATTERNS = [
+  // State/data flow
+  { glob: "**/*ViewModel.*", category: "state", reason: "viewmodel (state management)" },
+  { glob: "**/*Store.*", category: "state", reason: "store (state management)" },
+  { glob: "**/*Reducer.*", category: "state", reason: "reducer (state management)" },
+  // Data layer — interface
+  { glob: "**/*Repository.*", category: "data-interface", reason: "repository interface (data layer contract)" },
+  { glob: "**/*Dao.*", category: "data-interface", reason: "DAO (data access)" },
+  { glob: "**/*DataSource.*", category: "data-interface", reason: "data source" },
+  // Data layer — implementation (where actual patterns live: mappers, retry, IO dispatchers)
+  { glob: "**/*RepositoryImpl.*", category: "data-impl", reason: "repository implementation (data layer patterns)" },
+  { glob: "**/*ServiceImpl.*", category: "data-impl", reason: "service implementation" },
+  { glob: "**/*Impl.*", category: "data-impl", reason: "implementation (concrete patterns)" },
+  // Data transformation
+  { glob: "**/*Mapper.*", category: "transform", reason: "mapper (data transformation)" },
+  { glob: "**/*Converter.*", category: "transform", reason: "converter (data transformation)" },
+  { glob: "**/*Adapter.*", category: "transform", reason: "adapter (interface adaptation)" },
+  // Dependency injection / wiring
+  { glob: "**/*Module.*", category: "di", reason: "module (DI/wiring)" },
+  { glob: "**/*Provider.*", category: "di", reason: "provider (DI/wiring)" },
+  { glob: "**/*Container.*", category: "di", reason: "container (DI/wiring)" },
+  { glob: "**/*Factory.*", category: "di", reason: "factory (object creation)" },
+  // API / network
+  { glob: "**/*Service.*", category: "api", reason: "service (business/API layer)" },
+  { glob: "**/*Client.*", category: "api", reason: "client (API/network layer)" },
+  { glob: "**/*Api.*", category: "api", reason: "API interface definition" },
+  // Interface contracts / protocols
+  { glob: "**/*Interface.*", category: "contract", reason: "interface definition" },
+  { glob: "**/*Protocol.*", category: "contract", reason: "protocol definition" },
+  { glob: "**/*Trait.*", category: "contract", reason: "trait definition" },
+  // Routing / navigation
+  { glob: "**/*Router.*", category: "routing", reason: "router (navigation/routing)" },
+  { glob: "**/*Route.*", category: "routing", reason: "route definition" },
+  { glob: "**/*NavHost.*", category: "routing", reason: "navigation host" },
+  { glob: "**/*Controller.*", category: "routing", reason: "controller (request handling)" },
+  { glob: "**/*Handler.*", category: "routing", reason: "handler (request handling)" },
+  // Middleware / interceptors
+  { glob: "**/*Middleware.*", category: "middleware", reason: "middleware (request pipeline)" },
+  { glob: "**/*Interceptor.*", category: "middleware", reason: "interceptor (cross-cutting)" },
+  { glob: "**/*Plugin.*", category: "middleware", reason: "plugin (extensibility)" },
+  // Models / types
+  { glob: "**/*Model.*", category: "model", reason: "model (domain types)" },
+  { glob: "**/*Entity.*", category: "model", reason: "entity (persistence types)" },
+  { glob: "**/*Dto.*", category: "model", reason: "DTO (data transfer types)" },
+  { glob: "**/*Schema.*", category: "model", reason: "schema (data validation)" },
+  // Use cases / commands
+  { glob: "**/*UseCase.*", category: "usecase", reason: "use case (business logic)" },
+  { glob: "**/*Interactor.*", category: "usecase", reason: "interactor (business logic)" },
+  { glob: "**/*Command.*", category: "usecase", reason: "command (CQRS pattern)" }
+];
+var IGNORE_PATTERNS = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.gradle/**",
+  "**/target/**",
+  "**/.git/**",
+  "**/vendor/**",
+  "**/__pycache__/**",
+  "**/venv/**",
+  "**/.venv/**",
+  "**/*.min.*",
+  "**/*.map",
+  "**/package-lock.json",
+  "**/yarn.lock",
+  "**/pnpm-lock.yaml",
+  "**/*.lock",
+  "**/*.generated.*",
+  "**/generated/**",
+  "**/R.java",
+  "**/BuildConfig.java"
+];
+var PREVIEW_LINES = 60;
+async function loadProjectConfig(rootDir) {
+  try {
+    const raw = await fs2.readFile(
+      path.join(rootDir, ".mason", "config.json"),
+      "utf-8"
+    );
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function 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 exec3(
+      "git",
+      ["log", "--since=3 months ago", "--format=", "--name-only"],
+      { cwd: rootDir, maxBuffer: 5e6 }
+    );
+    const fileCounts = /* @__PURE__ */ new Map();
+    for (const line of stdout.split("\n")) {
+      if (!line) continue;
+      if (line.includes("node_modules") || line.includes("/build/") || line.includes(".gradle") || line.includes("/generated/"))
+        continue;
+      const ext = path.extname(line).slice(1);
+      if (!SOURCE_EXTENSIONS.includes(ext)) continue;
+      fileCounts.set(line, (fileCounts.get(line) ?? 0) + 1);
+    }
+    const hotFiles = [...fileCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5);
+    for (const [file, count] of hotFiles) {
+      if (selected.size >= maxFiles) break;
+      if (!selected.has(file)) {
+        selected.set(file, `frequently changed (${count} commits in 3 months)`);
+      }
+    }
+  } catch {
+  }
+  const seenCategories = /* @__PURE__ */ new Set();
+  let patternCount = 0;
+  for (const pattern of ARCHITECTURAL_PATTERNS) {
+    if (patternCount >= 8 || selected.size >= maxFiles) break;
+    if (seenCategories.has(pattern.category)) continue;
+    const matches = await fg2(pattern.glob, {
+      cwd: rootDir,
+      ignore: ignorePatterns
+    });
+    if (matches.length > 0) {
+      for (const match of matches) {
+        if (!selected.has(match)) {
+          selected.set(match, pattern.reason);
+          seenCategories.add(pattern.category);
+          patternCount++;
+          break;
+        }
+      }
+    }
+  }
+  for (const customGlob of projectConfig.patterns ?? []) {
+    if (selected.size >= maxFiles) break;
+    const matches = await fg2(customGlob, {
+      cwd: rootDir,
+      ignore: ignorePatterns
+    });
+    for (const match of matches) {
+      if (selected.size >= maxFiles) break;
+      if (!selected.has(match)) {
+        selected.set(match, "custom pattern (project config)");
+        break;
+      }
+    }
+  }
+  const testPatternGroups = [
+    // JS/TS tests
+    { patterns: ["**/*.test.*", "**/*.spec.*"], label: "JS/TS test" },
+    // JVM tests
+    { patterns: ["**/*Test.kt", "**/*Test.java"], label: "JVM test" },
+    // Python tests
+    { patterns: ["**/test_*.py", "**/*_test.py"], label: "Python test" },
+    // Go tests
+    { patterns: ["**/*_test.go"], label: "Go test" },
+    // Swift tests
+    { patterns: ["**/*Tests.swift", "**/*Test.swift"], label: "Swift test" },
+    // Rust tests
+    { patterns: ["**/*_test.rs"], label: "Rust test" }
+  ];
+  let testCount = 0;
+  for (const group of testPatternGroups) {
+    if (testCount >= 3 || selected.size >= maxFiles) break;
+    const testFiles = await fg2(group.patterns, {
+      cwd: rootDir,
+      ignore: ignorePatterns
+    });
+    if (testFiles.length > 0) {
+      for (const file of testFiles) {
+        if (!selected.has(file)) {
+          selected.set(file, `test example (${group.label})`);
+          testCount++;
+          break;
+        }
+      }
+    }
+  }
+  const sourceGlobs = SOURCE_EXTENSIONS.map((ext) => `**/*.${ext}`);
+  const allSourceFiles = await fg2(sourceGlobs, {
+    cwd: rootDir,
+    ignore: ignorePatterns
+  });
+  const dirRepresentatives = /* @__PURE__ */ new Map();
+  const boringFiles = /\.(gradle|gradle\.kts|json|toml|yaml|yml|xml|properties)$/;
+  for (const file of allSourceFiles) {
+    const topDir = file.split("/")[0];
+    if (!dirRepresentatives.has(topDir) && !boringFiles.test(file)) {
+      dirRepresentatives.set(topDir, file);
+    }
+  }
+  for (const [, file] of dirRepresentatives) {
+    if (selected.size >= maxFiles) break;
+    if (!selected.has(file)) {
+      selected.set(file, "directory representative");
+    }
+  }
+  const results = [];
+  for (const [filePath, reason] of selected) {
+    try {
+      const fullPath = path.join(rootDir, filePath);
+      const stat = await fs2.stat(fullPath);
+      if (stat.size > 1e5) continue;
+      const content = await fs2.readFile(fullPath, "utf-8");
+      const lines = content.split("\n");
+      const preview = lines.slice(0, PREVIEW_LINES).join("\n");
+      results.push({
+        path: filePath,
+        preview,
+        totalLines: lines.length,
+        sizeBytes: stat.size,
+        reason
+      });
+    } catch {
+    }
+  }
+  return results;
+}
+async function readFullFile(rootDir, filePath) {
+  try {
+    const fullPath = path.join(path.resolve(rootDir), filePath);
+    if (!fullPath.startsWith(path.resolve(rootDir))) return null;
+    const content = await fs2.readFile(fullPath, "utf-8");
+    return {
+      path: filePath,
+      content,
+      totalLines: content.split("\n").length
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/snapshot/snapshot.ts
+import fs4 from "fs/promises";
+import path3 from "path";
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify6 } from "util";
+
+// src/llm/providers.ts
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify5 } from "util";
+
+// src/llm/config.ts
+import fs3 from "fs/promises";
+import path2 from "path";
+import os from "os";
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+var exec4 = promisify4(execFile4);
+var CONFIG_DIR = path2.join(os.homedir(), ".mason");
+var CONFIG_FILE = path2.join(CONFIG_DIR, "config.json");
+
+// src/llm/providers.ts
+var exec5 = promisify5(execFile5);
+
+// src/snapshot/snapshot.ts
+var exec6 = promisify6(execFile6);
+function snapshotDir(rootDir) {
+  return 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";
+  }
+}
+
+// src/mcp/tools.ts
+var exec7 = promisify7(execFile7);
+var IGNORE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.gradle/**",
+  "**/target/**",
+  "**/.git/**",
+  "**/vendor/**",
+  "**/__pycache__/**",
+  "**/venv/**",
+  "**/.venv/**",
+  "**/*.min.*",
+  "**/*.map"
+];
+async function buildContext(dir) {
+  return {
+    rootDir: dir,
+    gitAvailable: await isGitRepo(dir)
+  };
+}
+async function analyzeProject(dir) {
+  const rootDir = 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 info = dirInfo.get(dirPath);
+      info.fileCount++;
+      const ext = path4.extname(file).slice(1);
+      if (ext) {
+        info.extensions.set(ext, (info.extensions.get(ext) ?? 0) + 1);
+      }
+    }
+  }
+  const directories = [...dirInfo.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([dirPath, info]) => {
+    const extensions = {};
+    for (const [ext, count] of info.extensions) {
+      extensions[ext] = count;
+    }
+    return { path: dirPath, fileCount: info.fileCount, extensions };
+  });
+  const topLevelFiles = allFiles.filter((f) => !f.includes("/"));
+  const output = {
+    totalFiles: allFiles.length,
+    topLevelFiles,
+    directories
+  };
+  return JSON.stringify(output, null, 2);
+}
+async function getTestMap(dir) {
+  const 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
+  });
+}
+
+// src/mcp/server.ts
+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);
+}
+
+// bin/mason-mcp.ts
+startMcpServer().catch((err) => {
+  process.stderr.write(`Mason MCP server error: ${err}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=mason-mcp.js.map