mason-context 0.3.3 → 0.3.5

package/README.md

@@ -114,6 +114,14 @@ mason snapshot                # create/update concept map
 
 Most providers work without an API key — `claude`, `gemini`, and `ollama` all use their respective CLIs directly.
 
+## Security
+
+**What the snapshot contains:** Feature names, relative file paths, and flow descriptions. No source code, secrets, or business logic.
+
+**What it doesn't touch:** Mason respects `.gitignore` (via `git ls-files`) and has a deny-list that blocks `.env`, `.pem`, `.key`, credentials, and other sensitive files from being sampled. Path traversal protection ensures all file access stays within the project root.
+
+**LLM data flow:** When generating a snapshot via CLI (`mason generate`, `mason snapshot`), Mason sends sampled file contents to your configured LLM provider. If you're using `claude`, `openai`, or `gemini`, this means source code is sent to an external API. Use `ollama` for fully local generation. The MCP server tools (`get_snapshot`, `get_impact`, etc.) do not send data to any LLM — they only read local files.
+
 ## Language support
 
 Mason is completely language-agnostic. It uses file naming patterns and git history rather than language-specific parsing, so it works with any project that has source files and a git repository — TypeScript, Kotlin, Python, Go, Rust, Swift, Java, C#, Dart, and more.

package/dist/bin/mason-mcp.js

@@ -686,10 +686,22 @@ async function loadProjectConfig(rootDir) {
     return {};
   }
 }
+async function getTrackedFiles(rootDir) {
+  try {
+    const { stdout } = await exec3("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
+      cwd: rootDir,
+      maxBuffer: 1e7
+    });
+    return new Set(stdout.trim().split("\n").filter(Boolean));
+  } catch {
+    return null;
+  }
+}
 async function sampleFiles(rootDir, maxFiles = 25) {
   const selected = /* @__PURE__ */ new Map();
   const projectConfig = await loadProjectConfig(rootDir);
   const ignorePatterns = [...IGNORE_PATTERNS, ...projectConfig.ignore ?? []];
+  const trackedFiles = await getTrackedFiles(rootDir);
   for (const filePath of projectConfig.alwaysInclude ?? []) {
     if (selected.size >= maxFiles) break;
     const resolvedPath = path.resolve(rootDir, filePath);
@@ -868,6 +880,7 @@ async function sampleFiles(rootDir, maxFiles = 25) {
       const fullPath = path.resolve(rootDir, filePath);
       if (!fullPath.startsWith(path.resolve(rootDir))) continue;
       if (isSensitiveFile(filePath)) continue;
+      if (trackedFiles && !trackedFiles.has(filePath)) continue;
       const stat = await fs2.stat(fullPath);
       if (stat.size > 1e5) continue;
       const content = await fs2.readFile(fullPath, "utf-8");
@@ -1226,10 +1239,23 @@ async function fullAnalysis(dir) {
   }
   return JSON.stringify(output, null, 2);
 }
+function sanitizePaths(rootDir, files) {
+  return files.filter((f) => {
+    const resolved = path6.resolve(rootDir, f);
+    return resolved.startsWith(rootDir) && !f.startsWith("/") && !f.includes("..");
+  });
+}
 async function saveSnapshotData(dir, features, flows) {
   const rootDir = path6.resolve(dir);
   const gitHash = await getCurrentGitHash(rootDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const feat of Object.values(features)) {
+    feat.files = sanitizePaths(rootDir, feat.files);
+    if (feat.tests) feat.tests = sanitizePaths(rootDir, feat.tests);
+  }
+  for (const flow of Object.values(flows)) {
+    flow.chain = sanitizePaths(rootDir, flow.chain);
+  }
   const existing = await loadSnapshot(rootDir);
   if (existing) {
     existing.features = { ...existing.features, ...features };
@@ -1270,7 +1296,7 @@ function createMcpServer() {
   const server = new McpServer(
     {
       name: "mason",
-      version: "0.3.3"
+      version: "0.3.5"
     },
     {
       instructions: "Mason is a context engineering tool. Always call get_snapshot before using Explore agents, Glob, or Grep to understand the codebase. The snapshot is a concept map that maps features and flows to their implementing files \u2014 it eliminates the need to search. This applies to ANY question about architecture, features, flows, how things work, cross-feature interactions, or bug investigation. Workflow: 1) Call get_snapshot first. 2) If no snapshot, call full_analysis and then save_snapshot to create one. 3) If the snapshot is stale, tell the user and offer to update it. 4) Use your native file reading tool to read files the snapshot points to. 5) Before modifying a file, call get_impact to check what else might be affected. 6) After making significant changes (new features, refactors, architecture changes), call save_snapshot to update the concept map."