@yawlabs/ctxlint 0.1.0

package/dist/mcp/server.js

@@ -0,0 +1,1076 @@
+// 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/core/scanner.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { glob } from "glob";
+
+// src/utils/fs.ts
+import * as fs from "fs";
+import * as path from "path";
+function fileExists(filePath) {
+  try {
+    fs.accessSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isDirectory(filePath) {
+  try {
+    return fs.statSync(filePath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isSymlink(filePath) {
+  try {
+    return fs.lstatSync(filePath).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function readSymlinkTarget(filePath) {
+  try {
+    return fs.readlinkSync(filePath);
+  } catch {
+    return void 0;
+  }
+}
+function readFileContent(filePath) {
+  return fs.readFileSync(filePath, "utf-8");
+}
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "vendor",
+  ".next",
+  ".nuxt",
+  "coverage",
+  "__pycache__"
+]);
+function getAllProjectFiles(projectRoot) {
+  const files = [];
+  function walk(dir, depth) {
+    if (depth > 10) return;
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (IGNORED_DIRS.has(entry.name)) continue;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          walk(fullPath, depth + 1);
+        } else {
+          files.push(path.relative(projectRoot, fullPath));
+        }
+      }
+    } catch {
+    }
+  }
+  walk(projectRoot, 0);
+  return files;
+}
+
+// src/core/scanner.ts
+var CONTEXT_FILE_PATTERNS = [
+  "CLAUDE.md",
+  "CLAUDE.local.md",
+  "AGENTS.md",
+  ".cursorrules",
+  ".cursor/rules/*.md",
+  ".cursor/rules/*.mdc",
+  "copilot-instructions.md",
+  ".github/copilot-instructions.md",
+  ".windsurfrules",
+  ".windsurf/rules/*.md",
+  "GEMINI.md",
+  "JULES.md",
+  ".clinerules",
+  "CONVENTIONS.md"
+];
+var IGNORED_DIRS2 = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "vendor"]);
+async function scanForContextFiles(projectRoot) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const dirsToScan = [projectRoot];
+  try {
+    const entries = fs2.readdirSync(projectRoot, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !IGNORED_DIRS2.has(entry.name) && !entry.name.startsWith(".")) {
+        dirsToScan.push(path2.join(projectRoot, entry.name));
+      }
+    }
+  } catch {
+  }
+  for (const dir of dirsToScan) {
+    for (const pattern of CONTEXT_FILE_PATTERNS) {
+      const matches = await glob(pattern, {
+        cwd: dir,
+        absolute: true,
+        nodir: true,
+        dot: true
+      });
+      for (const match of matches) {
+        const normalized = path2.normalize(match);
+        if (seen.has(normalized)) continue;
+        seen.add(normalized);
+        const relativePath = path2.relative(projectRoot, normalized);
+        const symlink = isSymlink(normalized);
+        const target = symlink ? readSymlinkTarget(normalized) : void 0;
+        found.push({
+          absolutePath: normalized,
+          relativePath: relativePath.replace(/\\/g, "/"),
+          isSymlink: symlink,
+          symlinkTarget: target
+        });
+      }
+    }
+  }
+  return found.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+
+// src/utils/tokens.ts
+import { encoding_for_model } from "tiktoken";
+var encoder = null;
+function getEncoder() {
+  if (!encoder) {
+    encoder = encoding_for_model("gpt-4");
+  }
+  return encoder;
+}
+function countTokens(text) {
+  try {
+    const enc = getEncoder();
+    const tokens = enc.encode(text);
+    return tokens.length;
+  } catch {
+    return Math.ceil(text.length / 4);
+  }
+}
+function freeEncoder() {
+  if (encoder) {
+    encoder.free();
+    encoder = null;
+  }
+}
+
+// src/core/parser.ts
+var PATH_PATTERN = /(?:^|[\s`"'(])((\.{0,2}\/)?(?:[\w@.-]+\/)+[\w.*-]+(?:\.\w+)?)(?=[\s`"'),;:]|$)/gm;
+var PATH_EXCLUDE = /^(https?:\/\/|ftp:\/\/|mailto:|n\/a|w\/o|I\/O|i\/o|e\.g\.|N\/A|\.deb\/|\.rpm[.\/]|\.tar[.\/]|\.zip[.\/])/i;
+var COMMAND_PREFIXES = /^\s*[\$>]\s+(.+)$/;
+var COMMON_COMMANDS = /^(npm\s+run|npx|pnpm|yarn|make|cargo|go\s+(run|build|test)|python|pytest|vitest|jest|bun|deno)\b/;
+function parseContextFile(file) {
+  const content = readFileContent(file.absolutePath);
+  const lines = content.split("\n");
+  const sections = parseSections(lines);
+  const paths = extractPathReferences(lines, sections);
+  const commands = extractCommandReferences(lines, sections);
+  return {
+    filePath: file.absolutePath,
+    relativePath: file.relativePath,
+    isSymlink: file.isSymlink,
+    symlinkTarget: file.symlinkTarget,
+    totalTokens: countTokens(content),
+    totalLines: lines.length,
+    content,
+    sections,
+    references: {
+      paths,
+      commands
+    }
+  };
+}
+function parseSections(lines) {
+  const sections = [];
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(/^(#{1,6})\s+(.+)/);
+    if (match) {
+      if (sections.length > 0) {
+        const prev = sections[sections.length - 1];
+        if (prev.endLine === -1) {
+          prev.endLine = i - 1;
+        }
+      }
+      sections.push({
+        title: match[2].trim(),
+        startLine: i + 1,
+        // 1-indexed
+        endLine: -1,
+        level: match[1].length
+      });
+    }
+  }
+  if (sections.length > 0) {
+    const last = sections[sections.length - 1];
+    if (last.endLine === -1) {
+      last.endLine = lines.length;
+    }
+  }
+  return sections;
+}
+function getSectionForLine(line, sections) {
+  for (let i = sections.length - 1; i >= 0; i--) {
+    if (line >= sections[i].startLine) {
+      return sections[i].title;
+    }
+  }
+  return void 0;
+}
+function extractPathReferences(lines, sections) {
+  const paths = [];
+  let inCodeBlock = false;
+  let codeBlockLang = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trimStart().startsWith("```")) {
+      if (!inCodeBlock) {
+        inCodeBlock = true;
+        codeBlockLang = line.trimStart().slice(3).trim().toLowerCase();
+      } else {
+        inCodeBlock = false;
+        codeBlockLang = "";
+      }
+      continue;
+    }
+    if (inCodeBlock && isExampleCodeBlock(codeBlockLang)) {
+      continue;
+    }
+    PATH_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = PATH_PATTERN.exec(line)) !== null) {
+      const value = match[1];
+      if (PATH_EXCLUDE.test(value)) continue;
+      if (value.length < 3) continue;
+      if (/^v?\d+\.\d+\//.test(value)) continue;
+      const column = match.index + match[0].length - match[1].length + 1;
+      paths.push({
+        value,
+        line: i + 1,
+        // 1-indexed
+        column,
+        section: getSectionForLine(i + 1, sections)
+      });
+    }
+  }
+  return paths;
+}
+function isExampleCodeBlock(lang) {
+  return [
+    "javascript",
+    "js",
+    "typescript",
+    "ts",
+    "python",
+    "py",
+    "go",
+    "rust",
+    "java",
+    "c",
+    "cpp",
+    "ruby",
+    "php",
+    "json",
+    "yaml",
+    "yml",
+    "toml",
+    "xml",
+    "html",
+    "css",
+    "sql",
+    "graphql",
+    "jsx",
+    "tsx"
+  ].includes(lang);
+}
+function extractCommandReferences(lines, sections) {
+  const commands = [];
+  let inCodeBlock = false;
+  let codeBlockLang = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trimStart().startsWith("```")) {
+      if (!inCodeBlock) {
+        inCodeBlock = true;
+        codeBlockLang = line.trimStart().slice(3).trim().toLowerCase();
+      } else {
+        inCodeBlock = false;
+        codeBlockLang = "";
+      }
+      continue;
+    }
+    const prefixMatch = line.match(COMMAND_PREFIXES);
+    if (prefixMatch) {
+      commands.push({
+        value: prefixMatch[1].trim(),
+        line: i + 1,
+        column: prefixMatch.index + prefixMatch[0].length - prefixMatch[1].length + 1,
+        section: getSectionForLine(i + 1, sections)
+      });
+      continue;
+    }
+    if (inCodeBlock && ["bash", "sh", "shell", "zsh", ""].includes(codeBlockLang)) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("//")) {
+        if (COMMON_COMMANDS.test(trimmed) || trimmed.startsWith("$") || trimmed.startsWith(">")) {
+          const cmd = trimmed.replace(/^\s*[\$>]\s*/, "");
+          if (cmd) {
+            const cmdStart = line.indexOf(trimmed) + trimmed.indexOf(cmd);
+            commands.push({
+              value: cmd,
+              line: i + 1,
+              column: cmdStart + 1,
+              section: getSectionForLine(i + 1, sections)
+            });
+          }
+        }
+      }
+      continue;
+    }
+    const inlineMatches = line.matchAll(/`([^`]+)`/g);
+    for (const m of inlineMatches) {
+      const cmd = m[1].trim();
+      if (COMMON_COMMANDS.test(cmd)) {
+        commands.push({
+          value: cmd,
+          line: i + 1,
+          column: (m.index ?? 0) + 2,
+          section: getSectionForLine(i + 1, sections)
+        });
+      }
+    }
+  }
+  return commands;
+}
+
+// src/core/checks/paths.ts
+import * as path3 from "path";
+import levenshteinPkg from "fast-levenshtein";
+import { glob as glob2 } from "glob";
+
+// src/utils/git.ts
+import simpleGit from "simple-git";
+var gitInstance = null;
+var gitProjectRoot = null;
+function getGit(projectRoot) {
+  if (!gitInstance || gitProjectRoot !== projectRoot) {
+    gitInstance = simpleGit(projectRoot);
+    gitProjectRoot = projectRoot;
+  }
+  return gitInstance;
+}
+function resetGit() {
+  gitInstance = null;
+  gitProjectRoot = null;
+}
+async function isGitRepo(projectRoot) {
+  try {
+    const git = simpleGit(projectRoot);
+    await git.revparse(["--is-inside-work-tree"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getFileLastModified(projectRoot, filePath) {
+  try {
+    const git = getGit(projectRoot);
+    const log = await git.log({ file: filePath, maxCount: 1 });
+    if (log.latest?.date) {
+      return new Date(log.latest.date);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function getCommitsSince(projectRoot, filePath, since) {
+  try {
+    const git = getGit(projectRoot);
+    const log = await git.log({
+      file: filePath,
+      "--since": since.toISOString()
+    });
+    return log.total;
+  } catch {
+    return 0;
+  }
+}
+async function findRenames(projectRoot, filePath) {
+  try {
+    const git = getGit(projectRoot);
+    const result = await git.raw([
+      "log",
+      "--diff-filter=R",
+      "--find-renames",
+      "--name-status",
+      "--format=%H %ai",
+      "-10",
+      "--",
+      filePath
+    ]);
+    if (!result.trim()) return null;
+    const lines = result.trim().split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.startsWith("R")) {
+        const parts = line.split("	");
+        if (parts.length >= 3) {
+          const hashLine = lines[i - 1] || "";
+          const hashMatch = hashLine.match(/^([a-f0-9]+)\s+(.+)/);
+          const commitHash = hashMatch?.[1]?.substring(0, 7) || "unknown";
+          const dateStr = hashMatch?.[2];
+          const daysAgo = dateStr ? Math.floor((Date.now() - new Date(dateStr).getTime()) / (1e3 * 60 * 60 * 24)) : 0;
+          return {
+            oldPath: parts[1],
+            newPath: parts[2],
+            commitHash,
+            daysAgo
+          };
+        }
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/core/checks/paths.ts
+var levenshtein = levenshteinPkg.get;
+var cachedProjectFiles = null;
+function getProjectFiles(projectRoot) {
+  if (cachedProjectFiles?.root === projectRoot) return cachedProjectFiles.files;
+  const files = getAllProjectFiles(projectRoot);
+  cachedProjectFiles = { root: projectRoot, files };
+  return files;
+}
+async function checkPaths(file, projectRoot) {
+  const issues = [];
+  const projectFiles = getProjectFiles(projectRoot);
+  const contextDir = path3.dirname(file.filePath);
+  for (const ref of file.references.paths) {
+    const baseDir = ref.value.startsWith("./") || ref.value.startsWith("../") ? contextDir : projectRoot;
+    const resolvedPath = path3.resolve(baseDir, ref.value);
+    const normalizedRef = ref.value.replace(/\\/g, "/");
+    if (normalizedRef.includes("*")) {
+      const matches = await glob2(normalizedRef, { cwd: baseDir, nodir: false });
+      if (matches.length === 0) {
+        issues.push({
+          severity: "error",
+          check: "paths",
+          line: ref.line,
+          message: `${ref.value} matches no files`,
+          suggestion: "Verify the glob pattern is correct"
+        });
+      }
+      continue;
+    }
+    const isDir = normalizedRef.endsWith("/");
+    if (isDir) {
+      const dirPath = path3.resolve(baseDir, normalizedRef);
+      if (!isDirectory(dirPath)) {
+        issues.push({
+          severity: "error",
+          check: "paths",
+          line: ref.line,
+          message: `${ref.value} directory does not exist`
+        });
+      }
+      continue;
+    }
+    if (fileExists(resolvedPath) || isDirectory(resolvedPath)) {
+      continue;
+    }
+    let suggestion;
+    let detail;
+    const rename = await findRenames(projectRoot, ref.value);
+    if (rename) {
+      suggestion = `Did you mean ${rename.newPath}?`;
+      detail = `Renamed ${rename.daysAgo} days ago in commit ${rename.commitHash}`;
+    } else {
+      const match = findClosestMatch(normalizedRef, projectFiles);
+      if (match) {
+        suggestion = `Did you mean ${match}?`;
+      }
+    }
+    issues.push({
+      severity: "error",
+      check: "paths",
+      line: ref.line,
+      message: `${ref.value} does not exist`,
+      suggestion,
+      detail
+    });
+  }
+  return issues;
+}
+function findClosestMatch(target, files) {
+  const targetNorm = target.replace(/\\/g, "/");
+  const targetBase = path3.basename(targetNorm);
+  let bestMatch = null;
+  let bestDistance = Infinity;
+  for (const file of files) {
+    const fileNorm = file.replace(/\\/g, "/");
+    if (path3.basename(fileNorm) === targetBase && fileNorm !== targetNorm) {
+      const dist = levenshtein(targetNorm, fileNorm);
+      if (dist < bestDistance) {
+        bestDistance = dist;
+        bestMatch = fileNorm;
+      }
+    }
+  }
+  if (!bestMatch) {
+    for (const file of files) {
+      const fileNorm = file.replace(/\\/g, "/");
+      const dist = levenshtein(targetNorm, fileNorm);
+      if (dist < bestDistance && dist <= Math.max(targetNorm.length * 0.4, 5)) {
+        bestDistance = dist;
+        bestMatch = fileNorm;
+      }
+    }
+  }
+  return bestMatch;
+}
+
+// src/core/checks/commands.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+var NPM_SCRIPT_PATTERN = /^(?:npm\s+run|pnpm(?:\s+run)?|yarn(?:\s+run)?)\s+(\S+)/;
+var MAKE_PATTERN = /^make\s+(\S+)/;
+async function checkCommands(file, projectRoot) {
+  const issues = [];
+  const pkgJson = loadPackageJson(projectRoot);
+  const makefile = loadMakefile(projectRoot);
+  for (const ref of file.references.commands) {
+    const cmd = ref.value;
+    const scriptMatch = cmd.match(NPM_SCRIPT_PATTERN);
+    if (scriptMatch && pkgJson) {
+      const scriptName = scriptMatch[1];
+      if (pkgJson.scripts && !(scriptName in pkgJson.scripts)) {
+        const available = Object.keys(pkgJson.scripts).join(", ");
+        issues.push({
+          severity: "error",
+          check: "commands",
+          line: ref.line,
+          message: `"${cmd}" \u2014 script "${scriptName}" not found in package.json`,
+          suggestion: available ? `Available scripts: ${available}` : void 0
+        });
+      }
+      continue;
+    }
+    const shorthandMatch = cmd.match(/^(npm|pnpm|yarn)\s+(test|start|build|dev|lint|format)\b/);
+    if (shorthandMatch && pkgJson) {
+      const scriptName = shorthandMatch[2];
+      if (pkgJson.scripts && !(scriptName in pkgJson.scripts)) {
+        issues.push({
+          severity: "error",
+          check: "commands",
+          line: ref.line,
+          message: `"${cmd}" \u2014 script "${scriptName}" not found in package.json`
+        });
+      }
+      continue;
+    }
+    const makeMatch = cmd.match(MAKE_PATTERN);
+    if (makeMatch) {
+      const target = makeMatch[1];
+      if (makefile && !hasMakeTarget(makefile, target)) {
+        issues.push({
+          severity: "error",
+          check: "commands",
+          line: ref.line,
+          message: `"${cmd}" \u2014 target "${target}" not found in Makefile`
+        });
+      } else if (!makefile) {
+        issues.push({
+          severity: "error",
+          check: "commands",
+          line: ref.line,
+          message: `"${cmd}" \u2014 no Makefile found in project`
+        });
+      }
+      continue;
+    }
+    const toolMatch = cmd.match(/^(vitest|jest|pytest|mocha|eslint|prettier|tsc)\b/);
+    if (toolMatch && pkgJson) {
+      const tool = toolMatch[1];
+      const allDeps = {
+        ...pkgJson.dependencies,
+        ...pkgJson.devDependencies
+      };
+      if (!(tool in allDeps)) {
+        const binPath = path4.join(projectRoot, "node_modules", ".bin", tool);
+        try {
+          fs3.accessSync(binPath);
+        } catch {
+          issues.push({
+            severity: "warning",
+            check: "commands",
+            line: ref.line,
+            message: `"${cmd}" \u2014 "${tool}" not found in dependencies or node_modules/.bin`
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function loadPackageJson(projectRoot) {
+  try {
+    const content = fs3.readFileSync(path4.join(projectRoot, "package.json"), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function loadMakefile(projectRoot) {
+  try {
+    return fs3.readFileSync(path4.join(projectRoot, "Makefile"), "utf-8");
+  } catch {
+    return null;
+  }
+}
+function hasMakeTarget(makefile, target) {
+  const pattern = new RegExp(`^${target.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*:`, "m");
+  return pattern.test(makefile);
+}
+
+// src/core/checks/staleness.ts
+import * as path5 from "path";
+var WARNING_DAYS = 30;
+var INFO_DAYS = 14;
+async function checkStaleness(file, projectRoot) {
+  const issues = [];
+  if (!await isGitRepo(projectRoot)) {
+    return issues;
+  }
+  const relativePath = path5.relative(projectRoot, file.filePath).replace(/\\/g, "/");
+  const lastModified = await getFileLastModified(projectRoot, relativePath);
+  if (!lastModified || isNaN(lastModified.getTime())) {
+    return issues;
+  }
+  const daysSinceUpdate = Math.floor((Date.now() - lastModified.getTime()) / (1e3 * 60 * 60 * 24));
+  if (daysSinceUpdate < INFO_DAYS) {
+    return issues;
+  }
+  const referencedPaths = /* @__PURE__ */ new Set();
+  for (const ref of file.references.paths) {
+    const parts = ref.value.split("/");
+    if (parts.length > 1) {
+      referencedPaths.add(parts.slice(0, -1).join("/"));
+    }
+    referencedPaths.add(ref.value);
+  }
+  let totalCommits = 0;
+  let mostActiveRef = "";
+  let mostActiveCommits = 0;
+  for (const refPath of referencedPaths) {
+    const commits = await getCommitsSince(projectRoot, refPath, lastModified);
+    totalCommits += commits;
+    if (commits > mostActiveCommits) {
+      mostActiveCommits = commits;
+      mostActiveRef = refPath;
+    }
+  }
+  if (totalCommits === 0) {
+    return issues;
+  }
+  const severity = daysSinceUpdate >= WARNING_DAYS ? "warning" : "info";
+  issues.push({
+    severity,
+    check: "staleness",
+    line: 1,
+    message: `Last updated ${daysSinceUpdate} days ago. ${mostActiveRef} has ${mostActiveCommits} commits since.`,
+    suggestion: "Review and update this context file to reflect recent changes.",
+    detail: `${totalCommits} total commits to referenced paths since last update.`
+  });
+  return issues;
+}
+
+// src/core/checks/tokens.ts
+var INFO_THRESHOLD = 1e3;
+var WARNING_THRESHOLD = 3e3;
+var ERROR_THRESHOLD = 8e3;
+async function checkTokens(file, _projectRoot) {
+  const issues = [];
+  const tokens = file.totalTokens;
+  if (tokens >= ERROR_THRESHOLD) {
+    issues.push({
+      severity: "error",
+      check: "tokens",
+      line: 1,
+      message: `${tokens.toLocaleString()} tokens \u2014 consumes significant context window space`,
+      suggestion: "Consider splitting into focused sections or removing redundant content."
+    });
+  } else if (tokens >= WARNING_THRESHOLD) {
+    issues.push({
+      severity: "warning",
+      check: "tokens",
+      line: 1,
+      message: `${tokens.toLocaleString()} tokens \u2014 large context file`,
+      suggestion: "Consider trimming \u2014 research shows diminishing returns past ~300 lines."
+    });
+  } else if (tokens >= INFO_THRESHOLD) {
+    issues.push({
+      severity: "info",
+      check: "tokens",
+      line: 1,
+      message: `Uses ~${tokens.toLocaleString()} tokens per session`
+    });
+  }
+  return issues;
+}
+function checkAggregateTokens(files) {
+  const total = files.reduce((sum, f) => sum + f.tokens, 0);
+  if (total > 5e3 && files.length > 1) {
+    return {
+      severity: "warning",
+      check: "tokens",
+      line: 0,
+      message: `${files.length} context files consume ${total.toLocaleString()} tokens combined`,
+      suggestion: "Consider consolidating or trimming to reduce per-session context cost."
+    };
+  }
+  return null;
+}
+
+// src/core/checks/redundancy.ts
+import * as fs4 from "fs";
+import * as path6 from "path";
+var PACKAGE_TECH_MAP = {
+  react: ["React", "react"],
+  "react-dom": ["React DOM", "ReactDOM"],
+  next: ["Next.js", "NextJS", "next.js"],
+  express: ["Express", "express.js"],
+  fastify: ["Fastify"],
+  typescript: ["TypeScript"],
+  vue: ["Vue", "Vue.js", "vue.js"],
+  angular: ["Angular"],
+  svelte: ["Svelte", "SvelteKit"],
+  tailwindcss: ["Tailwind", "TailwindCSS", "tailwind"],
+  prisma: ["Prisma"],
+  drizzle: ["Drizzle"],
+  "drizzle-orm": ["Drizzle"],
+  jest: ["Jest"],
+  vitest: ["Vitest"],
+  mocha: ["Mocha"],
+  eslint: ["ESLint"],
+  prettier: ["Prettier"],
+  webpack: ["Webpack"],
+  vite: ["Vite"],
+  esbuild: ["esbuild"],
+  tsup: ["tsup"],
+  rollup: ["Rollup"],
+  graphql: ["GraphQL"],
+  mongoose: ["Mongoose"],
+  sequelize: ["Sequelize"],
+  "socket.io": ["Socket.IO", "socket.io"],
+  redis: ["Redis"],
+  ioredis: ["Redis"],
+  postgres: ["PostgreSQL", "Postgres"],
+  pg: ["PostgreSQL", "Postgres"],
+  mysql2: ["MySQL"],
+  sqlite3: ["SQLite"],
+  "better-sqlite3": ["SQLite"],
+  zod: ["Zod"],
+  joi: ["Joi"],
+  axios: ["Axios"],
+  lodash: ["Lodash", "lodash"],
+  underscore: ["Underscore"],
+  moment: ["Moment", "moment.js"],
+  dayjs: ["Day.js", "dayjs"],
+  "date-fns": ["date-fns"],
+  docker: ["Docker"],
+  kubernetes: ["Kubernetes", "K8s"],
+  terraform: ["Terraform"],
+  storybook: ["Storybook"],
+  playwright: ["Playwright"],
+  cypress: ["Cypress"],
+  puppeteer: ["Puppeteer"]
+};
+async function checkRedundancy(file, projectRoot) {
+  const issues = [];
+  const pkgJson = loadPackageJson2(projectRoot);
+  if (pkgJson) {
+    const allDeps = /* @__PURE__ */ new Set([
+      ...Object.keys(pkgJson.dependencies || {}),
+      ...Object.keys(pkgJson.devDependencies || {})
+    ]);
+    const lines2 = file.content.split("\n");
+    for (let i = 0; i < lines2.length; i++) {
+      const line = lines2[i];
+      for (const [pkg, mentions] of Object.entries(PACKAGE_TECH_MAP)) {
+        if (!allDeps.has(pkg)) continue;
+        for (const mention of mentions) {
+          const patterns = [
+            new RegExp(
+              `\\b(?:use|using|built with|powered by|written in)\\s+${escapeRegex(mention)}\\b`,
+              "i"
+            ),
+            new RegExp(`\\bwe\\s+use\\s+${escapeRegex(mention)}\\b`, "i"),
+            new RegExp(
+              `\\b${escapeRegex(mention)}\\s+(?:project|app|application|codebase)\\b`,
+              "i"
+            ),
+            new RegExp(`\\bThis is a\\s+${escapeRegex(mention)}\\b`, "i")
+          ];
+          for (const pattern of patterns) {
+            if (pattern.test(line)) {
+              const wastedTokens = countTokens(line.trim());
+              issues.push({
+                severity: "info",
+                check: "redundancy",
+                line: i + 1,
+                message: `"${mention}" is in package.json ${pkgJson.dependencies?.[pkg] ? "dependencies" : "devDependencies"} \u2014 agent can infer this`,
+                suggestion: `~${wastedTokens} tokens could be saved`
+              });
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  const lines = file.content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const dirMatch = line.match(
+      /(?:are|go|live|found|located|stored)\s+(?:in|at|under)\s+[`"]?(\S+\/)[`"]?/i
+    );
+    if (dirMatch) {
+      const dir = dirMatch[1].replace(/[`"]/g, "");
+      const fullPath = path6.resolve(projectRoot, dir);
+      if (isDirectory(fullPath)) {
+        issues.push({
+          severity: "info",
+          check: "redundancy",
+          line: i + 1,
+          message: `Directory "${dir}" exists and is discoverable \u2014 agent can find this by listing files`,
+          suggestion: "Only keep if there is non-obvious context about this directory"
+        });
+      }
+    }
+  }
+  return issues;
+}
+function checkDuplicateContent(files) {
+  const issues = [];
+  for (let i = 0; i < files.length; i++) {
+    for (let j = i + 1; j < files.length; j++) {
+      const overlap = calculateLineOverlap(files[i].content, files[j].content);
+      if (overlap > 0.6) {
+        issues.push({
+          severity: "warning",
+          check: "redundancy",
+          line: 1,
+          message: `${files[i].relativePath} and ${files[j].relativePath} have ${Math.round(overlap * 100)}% content overlap`,
+          suggestion: "Consider consolidating into a single context file"
+        });
+      }
+    }
+  }
+  return issues;
+}
+function calculateLineOverlap(contentA, contentB) {
+  const linesA = new Set(
+    contentA.split("\n").map((l) => l.trim()).filter((l) => l.length > 10)
+  );
+  const linesB = new Set(
+    contentB.split("\n").map((l) => l.trim()).filter((l) => l.length > 10)
+  );
+  if (linesA.size === 0 || linesB.size === 0) return 0;
+  let overlap = 0;
+  for (const line of linesA) {
+    if (linesB.has(line)) overlap++;
+  }
+  return overlap / Math.min(linesA.size, linesB.size);
+}
+function loadPackageJson2(projectRoot) {
+  try {
+    const content = fs4.readFileSync(path6.join(projectRoot, "package.json"), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/mcp/server.ts
+import * as path7 from "path";
+var VERSION = "0.1.0";
+var ALL_CHECKS = ["paths", "commands", "staleness", "tokens", "redundancy"];
+var server = new McpServer({
+  name: "ctxlint",
+  version: VERSION
+});
+server.tool(
+  "ctxlint_audit",
+  "Audit all AI agent context files (CLAUDE.md, AGENTS.md, etc.) in the project for stale references, invalid commands, redundant content, and token waste.",
+  {
+    projectPath: z.string().optional().describe("Path to the project root. Defaults to current working directory."),
+    checks: z.array(z.enum(["paths", "commands", "staleness", "tokens", "redundancy"])).optional().describe("Which checks to run. Defaults to all.")
+  },
+  async ({ projectPath, checks }) => {
+    const root = path7.resolve(projectPath || process.cwd());
+    const activeChecks = checks || ALL_CHECKS;
+    try {
+      const result = await runAudit(root, activeChecks);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: msg }) }],
+        isError: true
+      };
+    } finally {
+      freeEncoder();
+      resetGit();
+    }
+  }
+);
+server.tool(
+  "ctxlint_validate_path",
+  "Check if a file path referenced in a context file actually exists in the project. Returns the file status and suggests corrections if the path is invalid.",
+  {
+    path: z.string().describe("The file path to validate"),
+    projectPath: z.string().optional().describe("Project root. Defaults to cwd.")
+  },
+  async ({ path: filePath, projectPath }) => {
+    try {
+      const root = path7.resolve(projectPath || process.cwd());
+      const resolved = path7.resolve(root, filePath);
+      const result = {
+        path: filePath,
+        exists: fileExists(resolved) || isDirectory(resolved)
+      };
+      if (!result.exists) {
+        const rename = await findRenames(root, filePath);
+        if (rename) {
+          result.renamed = true;
+          result.newPath = rename.newPath;
+          result.renameCommit = rename.commitHash;
+          result.daysAgo = rename.daysAgo;
+        }
+      }
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: msg }) }],
+        isError: true
+      };
+    } finally {
+      resetGit();
+    }
+  }
+);
+server.tool(
+  "ctxlint_token_report",
+  "Get a token count breakdown for all context files in the project. Shows per-file and aggregate token usage, plus estimated waste from redundant content.",
+  {
+    projectPath: z.string().optional().describe("Project root. Defaults to cwd.")
+  },
+  async ({ projectPath }) => {
+    const root = path7.resolve(projectPath || process.cwd());
+    try {
+      const discovered = await scanForContextFiles(root);
+      const parsed = discovered.map((f) => parseContextFile(f));
+      const files = parsed.map((f) => ({
+        path: f.relativePath,
+        tokens: f.totalTokens,
+        lines: f.totalLines,
+        isSymlink: f.isSymlink
+      }));
+      const totalTokens = files.reduce((sum, f) => sum + f.tokens, 0);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ files, totalTokens }, null, 2)
+          }
+        ]
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: msg }) }],
+        isError: true
+      };
+    } finally {
+      freeEncoder();
+    }
+  }
+);
+async function runAudit(projectRoot, activeChecks) {
+  const discovered = await scanForContextFiles(projectRoot);
+  const parsed = discovered.map((f) => parseContextFile(f));
+  const fileResults = [];
+  for (const file of parsed) {
+    const issues = [];
+    if (activeChecks.includes("paths")) issues.push(...await checkPaths(file, projectRoot));
+    if (activeChecks.includes("commands")) issues.push(...await checkCommands(file, projectRoot));
+    if (activeChecks.includes("staleness"))
+      issues.push(...await checkStaleness(file, projectRoot));
+    if (activeChecks.includes("tokens")) issues.push(...await checkTokens(file, projectRoot));
+    if (activeChecks.includes("redundancy"))
+      issues.push(...await checkRedundancy(file, projectRoot));
+    fileResults.push({
+      path: file.relativePath,
+      isSymlink: file.isSymlink,
+      symlinkTarget: file.symlinkTarget,
+      tokens: file.totalTokens,
+      lines: file.totalLines,
+      issues
+    });
+  }
+  if (activeChecks.includes("tokens")) {
+    const aggIssue = checkAggregateTokens(
+      fileResults.map((f) => ({ path: f.path, tokens: f.tokens }))
+    );
+    if (aggIssue && fileResults.length > 0) fileResults[0].issues.push(aggIssue);
+  }
+  if (activeChecks.includes("redundancy")) {
+    const dupIssues = checkDuplicateContent(parsed);
+    if (dupIssues.length > 0 && fileResults.length > 0) fileResults[0].issues.push(...dupIssues);
+  }
+  let estimatedWaste = 0;
+  for (const fr of fileResults) {
+    for (const issue of fr.issues) {
+      if (issue.check === "redundancy" && issue.suggestion) {
+        const tokenMatch = issue.suggestion.match(/~(\d+)\s+tokens/);
+        if (tokenMatch) estimatedWaste += parseInt(tokenMatch[1], 10);
+      }
+    }
+  }
+  return {
+    version: VERSION,
+    scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    projectRoot,
+    files: fileResults,
+    summary: {
+      errors: fileResults.reduce(
+        (sum, f) => sum + f.issues.filter((i) => i.severity === "error").length,
+        0
+      ),
+      warnings: fileResults.reduce(
+        (sum, f) => sum + f.issues.filter((i) => i.severity === "warning").length,
+        0
+      ),
+      info: fileResults.reduce(
+        (sum, f) => sum + f.issues.filter((i) => i.severity === "info").length,
+        0
+      ),
+      totalTokens: fileResults.reduce((sum, f) => sum + f.tokens, 0),
+      estimatedWaste
+    }
+  };
+}
+var transport = new StdioServerTransport();
+await server.connect(transport);