@yawlabs/ctxlint 0.2.2 → 0.4.0

package/dist/index.js

@@ -1,1279 +1,9 @@
 #!/usr/bin/env node
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 
 // src/index.ts
-import { Command } from "commander";
-import ora from "ora";
-
-// 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 loadPackageJson(projectRoot) {
-  try {
-    const content = fs.readFileSync(path.join(projectRoot, "package.json"), "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-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",
-  ".github/instructions/*.md",
-  ".windsurfrules",
-  ".windsurf/rules/*.md",
-  "GEMINI.md",
-  "JULES.md",
-  ".clinerules",
-  "CONVENTIONS.md",
-  "CODEX.md",
-  ".aiderules",
-  ".aide/rules/*.md",
-  ".amazonq/rules/*.md",
-  ".goose/instructions.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;
-}
-function resetPathsCache() {
-  cachedProjectFiles = null;
-}
-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;
-    let fixTarget;
-    const rename = await findRenames(projectRoot, ref.value);
-    if (rename) {
-      fixTarget = rename.newPath;
-      suggestion = `Did you mean ${rename.newPath}?`;
-      detail = `Renamed ${rename.daysAgo} days ago in commit ${rename.commitHash}`;
-    } else {
-      const match = findClosestMatch(normalizedRef, projectFiles);
-      if (match) {
-        fixTarget = match;
-        suggestion = `Did you mean ${match}?`;
-      }
-    }
-    issues.push({
-      severity: "error",
-      check: "paths",
-      line: ref.line,
-      message: `${ref.value} does not exist`,
-      suggestion,
-      detail,
-      fix: fixTarget ? { file: file.filePath, line: ref.line, oldText: ref.value, newText: fixTarget } : void 0
-    });
-  }
-  return issues;
+if (process.argv.includes("--mcp")) {
+  await import("./server-7C2IQ7VV.js");
+} else {
+  const { runCli } = await import("./cli-VYWAONGX.js");
+  await runCli();
 }
-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)?|bun(?:\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|bun)\s+(test|start|build|dev|lint|format|check|typecheck|clean|serve|preview|e2e)\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 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 DEFAULT_THRESHOLDS = {
-  info: 1e3,
-  warning: 3e3,
-  error: 8e3,
-  aggregate: 5e3
-};
-var currentThresholds = DEFAULT_THRESHOLDS;
-function setTokenThresholds(overrides) {
-  currentThresholds = { ...DEFAULT_THRESHOLDS, ...overrides };
-}
-function resetTokenThresholds() {
-  currentThresholds = DEFAULT_THRESHOLDS;
-}
-async function checkTokens(file, _projectRoot) {
-  const issues = [];
-  const tokens = file.totalTokens;
-  if (tokens >= currentThresholds.error) {
-    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 >= currentThresholds.warning) {
-    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 >= currentThresholds.info) {
-    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 > currentThresholds.aggregate && 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 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 = loadPackageJson(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 escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-// src/core/reporter.ts
-import chalk from "chalk";
-function formatText(result, verbose = false) {
-  const lines = [];
-  lines.push("");
-  lines.push(chalk.bold(`ctxlint v${result.version}`));
-  lines.push("");
-  lines.push(`Scanning ${result.projectRoot}...`);
-  lines.push("");
-  const totalTokens = result.summary.totalTokens;
-  lines.push(
-    `Found ${result.files.length} context file${result.files.length !== 1 ? "s" : ""} (${totalTokens.toLocaleString()} tokens total)`
-  );
-  for (const file of result.files) {
-    let desc = `  ${file.path} (${file.tokens.toLocaleString()} tokens, ${file.lines} lines)`;
-    if (file.isSymlink && file.symlinkTarget) {
-      desc = `  ${file.path} ${chalk.dim(`\u2192 ${file.symlinkTarget} (symlink)`)}`;
-    }
-    lines.push(desc);
-  }
-  lines.push("");
-  for (const file of result.files) {
-    const fileIssues = file.issues;
-    if (fileIssues.length === 0 && !verbose) continue;
-    lines.push(chalk.underline(file.path));
-    if (fileIssues.length === 0) {
-      lines.push(chalk.green("  \u2713 All checks passed"));
-    } else {
-      for (const issue of fileIssues) {
-        lines.push(formatIssue(issue));
-      }
-    }
-    lines.push("");
-  }
-  const { errors, warnings, info } = result.summary;
-  const parts = [];
-  if (errors > 0) parts.push(chalk.red(`${errors} error${errors !== 1 ? "s" : ""}`));
-  if (warnings > 0) parts.push(chalk.yellow(`${warnings} warning${warnings !== 1 ? "s" : ""}`));
-  if (info > 0) parts.push(chalk.blue(`${info} info`));
-  if (parts.length > 0) {
-    lines.push(`Summary: ${parts.join(", ")}`);
-  } else {
-    lines.push(chalk.green("No issues found!"));
-  }
-  lines.push(`  Token usage: ${totalTokens.toLocaleString()} tokens per agent session`);
-  if (result.summary.estimatedWaste > 0) {
-    lines.push(`  Estimated waste: ~${result.summary.estimatedWaste} tokens (redundant content)`);
-  }
-  lines.push("");
-  return lines.join("\n");
-}
-function formatJson(result) {
-  return JSON.stringify(result, null, 2);
-}
-function formatTokenReport(result) {
-  const lines = [];
-  lines.push("");
-  lines.push(chalk.bold("Token Usage Report"));
-  lines.push("");
-  const maxPathLen = Math.max(...result.files.map((f) => f.path.length), 4);
-  lines.push(
-    `  ${chalk.dim("File".padEnd(maxPathLen))}  ${chalk.dim("Tokens".padStart(8))}  ${chalk.dim("Lines".padStart(6))}`
-  );
-  lines.push(`  ${"\u2500".repeat(maxPathLen)}  ${"\u2500".repeat(8)}  ${"\u2500".repeat(6)}`);
-  for (const file of result.files) {
-    const tokenStr = file.tokens.toLocaleString().padStart(8);
-    const lineStr = file.lines.toString().padStart(6);
-    lines.push(`  ${file.path.padEnd(maxPathLen)}  ${tokenStr}  ${lineStr}`);
-  }
-  lines.push(`  ${"\u2500".repeat(maxPathLen)}  ${"\u2500".repeat(8)}  ${"\u2500".repeat(6)}`);
-  lines.push(
-    `  ${"Total".padEnd(maxPathLen)}  ${result.summary.totalTokens.toLocaleString().padStart(8)}`
-  );
-  if (result.summary.estimatedWaste > 0) {
-    lines.push("");
-    lines.push(
-      chalk.yellow(
-        `  ~${result.summary.estimatedWaste} tokens estimated waste from redundant content`
-      )
-    );
-  }
-  lines.push("");
-  return lines.join("\n");
-}
-function formatIssue(issue) {
-  const icon = issue.severity === "error" ? chalk.red("\u2717") : issue.severity === "warning" ? chalk.yellow("\u26A0") : chalk.blue("\u2139");
-  const lineRef = issue.line > 0 ? `Line ${issue.line}: ` : "";
-  let line = `  ${icon} ${lineRef}${issue.message}`;
-  if (issue.suggestion) {
-    line += `
-    ${chalk.dim("\u2192")} ${chalk.dim(issue.suggestion)}`;
-  }
-  if (issue.detail) {
-    line += `
-    ${chalk.dim(issue.detail)}`;
-  }
-  return line;
-}
-
-// src/core/fixer.ts
-import * as fs4 from "fs";
-import chalk2 from "chalk";
-function applyFixes(result) {
-  const fixesByFile = /* @__PURE__ */ new Map();
-  for (const file of result.files) {
-    for (const issue of file.issues) {
-      if (issue.fix) {
-        const existing = fixesByFile.get(issue.fix.file) || [];
-        existing.push(issue.fix);
-        fixesByFile.set(issue.fix.file, existing);
-      }
-    }
-  }
-  let totalFixes = 0;
-  const filesModified = [];
-  for (const [filePath, fixes] of fixesByFile) {
-    const content = fs4.readFileSync(filePath, "utf-8");
-    const lines = content.split("\n");
-    let modified = false;
-    const sortedFixes = [...fixes].sort((a, b) => b.line - a.line);
-    for (const fix of sortedFixes) {
-      const lineIdx = fix.line - 1;
-      if (lineIdx < 0 || lineIdx >= lines.length) continue;
-      const line = lines[lineIdx];
-      if (line.includes(fix.oldText)) {
-        lines[lineIdx] = line.replace(fix.oldText, fix.newText);
-        modified = true;
-        totalFixes++;
-        console.log(
-          chalk2.green("  Fixed") + ` Line ${fix.line}: ${chalk2.dim(fix.oldText)} ${chalk2.dim("\u2192")} ${fix.newText}`
-        );
-      }
-    }
-    if (modified) {
-      fs4.writeFileSync(filePath, lines.join("\n"), "utf-8");
-      filesModified.push(filePath);
-    }
-  }
-  return { totalFixes, filesModified };
-}
-
-// src/core/config.ts
-import * as fs5 from "fs";
-import * as path7 from "path";
-var CONFIG_FILENAMES = [".ctxlintrc", ".ctxlintrc.json"];
-function loadConfig(projectRoot) {
-  for (const filename of CONFIG_FILENAMES) {
-    const filePath = path7.join(projectRoot, filename);
-    try {
-      const content = fs5.readFileSync(filePath, "utf-8");
-      return JSON.parse(content);
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-
-// src/index.ts
-import * as path8 from "path";
-
-// src/version.ts
-function loadVersion() {
-  if (true) return "0.2.2";
-  const fs6 = __require("fs");
-  const path9 = __require("path");
-  const pkgPath = path9.resolve(__dirname, "../package.json");
-  const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
-  return pkg.version;
-}
-var VERSION = loadVersion();
-
-// src/index.ts
-var ALL_CHECKS = ["paths", "commands", "staleness", "tokens", "redundancy"];
-var program = new Command();
-program.name("ctxlint").description(
-  "Lint your AI agent context files (CLAUDE.md, AGENTS.md, etc.) against your actual codebase"
-).version(VERSION).argument("[path]", "Project directory to scan", ".").option("--strict", "Exit code 1 on any warning or error (for CI)", false).option("--checks <checks>", "Comma-separated list of checks to run", "").option("--format <format>", "Output format: text or json", "text").option("--tokens", "Show token breakdown per file", false).option("--verbose", "Show passing checks too", false).option("--fix", "Auto-fix broken paths using git history and fuzzy matching", false).option("--ignore <checks>", "Comma-separated list of checks to ignore", "").action(async (projectPath, opts) => {
-  const resolvedPath = path8.resolve(projectPath);
-  const config = loadConfig(resolvedPath);
-  const options = {
-    projectPath: resolvedPath,
-    checks: opts.checks ? opts.checks.split(",").map((c) => c.trim()) : config?.checks || ALL_CHECKS,
-    strict: opts.strict || config?.strict || false,
-    format: opts.format,
-    verbose: opts.verbose,
-    fix: opts.fix,
-    ignore: opts.ignore ? opts.ignore.split(",").map((c) => c.trim()) : config?.ignore || [],
-    tokensOnly: opts.tokens
-  };
-  if (config?.tokenThresholds) {
-    setTokenThresholds(config.tokenThresholds);
-  }
-  const activeChecks = options.checks.filter((c) => !options.ignore.includes(c));
-  const spinner = options.format === "text" ? ora("Scanning for context files...").start() : void 0;
-  try {
-    const discovered = await scanForContextFiles(options.projectPath);
-    if (discovered.length === 0) {
-      spinner?.stop();
-      if (options.format === "json") {
-        console.log(
-          JSON.stringify({
-            version: VERSION,
-            scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            projectRoot: options.projectPath,
-            files: [],
-            summary: { errors: 0, warnings: 0, info: 0, totalTokens: 0, estimatedWaste: 0 }
-          })
-        );
-      } else {
-        console.log("\nNo context files found.\n");
-      }
-      process.exit(0);
-    }
-    if (spinner)
-      spinner.text = `Parsing ${discovered.length} context file${discovered.length !== 1 ? "s" : ""}...`;
-    const parsed = discovered.map((f) => parseContextFile(f));
-    if (spinner) spinner.text = "Running checks...";
-    const fileResults = [];
-    for (const file of parsed) {
-      const issues = [];
-      if (activeChecks.includes("paths")) {
-        issues.push(...await checkPaths(file, options.projectPath));
-      }
-      if (activeChecks.includes("commands")) {
-        issues.push(...await checkCommands(file, options.projectPath));
-      }
-      if (activeChecks.includes("staleness")) {
-        issues.push(...await checkStaleness(file, options.projectPath));
-      }
-      if (activeChecks.includes("tokens")) {
-        issues.push(...await checkTokens(file, options.projectPath));
-      }
-      if (activeChecks.includes("redundancy")) {
-        issues.push(...await checkRedundancy(file, options.projectPath));
-      }
-      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);
-          }
-        }
-      }
-    }
-    const result = {
-      version: VERSION,
-      scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      projectRoot: options.projectPath,
-      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
-      }
-    };
-    spinner?.stop();
-    if (options.fix) {
-      const fixSummary = applyFixes(result);
-      if (fixSummary.totalFixes > 0) {
-        console.log(
-          `
-Fixed ${fixSummary.totalFixes} issue${fixSummary.totalFixes !== 1 ? "s" : ""} in ${fixSummary.filesModified.length} file${fixSummary.filesModified.length !== 1 ? "s" : ""}.
-`
-        );
-      }
-    }
-    if (options.tokensOnly) {
-      console.log(formatTokenReport(result));
-    } else if (options.format === "json") {
-      console.log(formatJson(result));
-    } else {
-      console.log(formatText(result, options.verbose));
-    }
-    if (options.strict && (result.summary.errors > 0 || result.summary.warnings > 0)) {
-      process.exit(1);
-    }
-  } catch (err) {
-    spinner?.stop();
-    console.error("Error:", err instanceof Error ? err.message : err);
-    process.exit(2);
-  } finally {
-    freeEncoder();
-    resetGit();
-    resetPathsCache();
-    resetTokenThresholds();
-  }
-});
-program.command("init").description("Set up a git pre-commit hook that runs ctxlint --strict").action(async () => {
-  const fs6 = await import("fs");
-  const hooksDir = path8.resolve(".git", "hooks");
-  if (!fs6.existsSync(path8.resolve(".git"))) {
-    console.error('Error: not a git repository. Run "git init" first.');
-    process.exit(1);
-  }
-  if (!fs6.existsSync(hooksDir)) {
-    fs6.mkdirSync(hooksDir, { recursive: true });
-  }
-  const hookPath = path8.join(hooksDir, "pre-commit");
-  const hookContent = `#!/bin/sh
-# ctxlint pre-commit hook
-npx @yawlabs/ctxlint --strict
-`;
-  if (fs6.existsSync(hookPath)) {
-    const existing = fs6.readFileSync(hookPath, "utf-8");
-    if (existing.includes("ctxlint")) {
-      console.log("Pre-commit hook already includes ctxlint.");
-      return;
-    }
-    fs6.appendFileSync(hookPath, "\n" + hookContent);
-    console.log("Added ctxlint to existing pre-commit hook.");
-  } else {
-    fs6.writeFileSync(hookPath, hookContent, { mode: 493 });
-    console.log("Created pre-commit hook at .git/hooks/pre-commit");
-  }
-  console.log("ctxlint will now run automatically before each commit.");
-});
-program.parse();