@yawlabs/ctxlint 0.9.6 → 0.9.7

package/dist/index.js

@@ -34322,29 +34322,24 @@ async function scanForContextFiles(projectRoot, options = {}) {
     }
   }
   collectDirs(projectRoot, 0);
-  for (const dir of dirsToScan) {
-    for (const pattern of patterns) {
-      const matches = await Ze(pattern, {
-        cwd: dir,
-        absolute: true,
-        nodir: true,
-        dot: true
+  const perDirMatches = await Promise.all(
+    dirsToScan.map((dir) => Ze(patterns, { cwd: dir, absolute: true, nodir: true, dot: true }))
+  );
+  for (const matches of perDirMatches) {
+    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,
+        type: "context"
       });
-      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,
-          type: "context"
-        });
-      }
     }
   }
   return found.sort((a, b2) => a.relativePath.localeCompare(b2.relativePath));
@@ -40501,17 +40496,54 @@ async function getFileLastModified(projectRoot, filePath) {
     return null;
   }
 }
-async function getCommitsSince(projectRoot, filePath, since) {
+async function getCommitsSinceBatch(projectRoot, paths, since) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const p2 of paths) counts.set(p2, 0);
+  if (paths.length === 0) return counts;
   try {
     const git = getGit(projectRoot);
-    const log = await git.log({
-      file: filePath,
-      "--since": since.toISOString()
-    });
-    return log.total;
+    const SENTINEL = "___CTXLINT_COMMIT___";
+    const raw = await git.raw([
+      "log",
+      `--since=${since.toISOString()}`,
+      "--name-only",
+      `--format=${SENTINEL}`
+    ]);
+    const normalize3 = (p2) => p2.replace(/\\/g, "/");
+    const requested = new Set(paths.map(normalize3));
+    const lines = raw.split("\n");
+    let inCommit = false;
+    const seenThisCommit = /* @__PURE__ */ new Set();
+    const flush = () => {
+      for (const p2 of seenThisCommit) {
+        counts.set(p2, (counts.get(p2) ?? 0) + 1);
+      }
+      seenThisCommit.clear();
+    };
+    for (const line of lines) {
+      if (line === SENTINEL) {
+        if (inCommit) flush();
+        inCommit = true;
+        continue;
+      }
+      if (!inCommit) continue;
+      const trimmed2 = line.trim();
+      if (!trimmed2) continue;
+      const changed = normalize3(trimmed2);
+      for (const req of requested) {
+        if (changed === req || changed.startsWith(req.endsWith("/") ? req : req + "/")) {
+          seenThisCommit.add(req);
+        }
+      }
+    }
+    if (inCommit) flush();
   } catch {
-    return 0;
   }
+  const out = /* @__PURE__ */ new Map();
+  for (const p2 of paths) {
+    out.set(p2, counts.get(p2.replace(/\\/g, "/")) ?? 0);
+  }
+  return out;
 }
 async function findRenames(projectRoot, filePath) {
   try {
@@ -40853,7 +40885,7 @@ var require_levenshtein = __commonJS({
       } catch (err) {
         console.log("Collator could not be initialized and wouldn't be used");
       }
-      var levenshtein2 = require_mod();
+      var levenshtein3 = require_mod();
       var prevRow = [], str2Char = [];
       var Levenshtein = {
         /**
@@ -40898,7 +40930,7 @@ var require_levenshtein = __commonJS({
             }
             return nextCol;
           }
-          return levenshtein2.distance(str1, str2);
+          return levenshtein3.distance(str1, str2);
         }
       };
       if (typeof define !== "undefined" && define !== null && define.amd) {
@@ -41193,11 +41225,14 @@ async function checkStaleness(file2, projectRoot) {
   for (const ref of file2.references.paths) {
     referencedPaths.add(ref.value);
   }
+  if (referencedPaths.size === 0) {
+    return issues;
+  }
+  const counts = await getCommitsSinceBatch(projectRoot, [...referencedPaths], lastModified);
   let totalCommits = 0;
   let mostActiveRef = "";
   let mostActiveCommits = 0;
-  for (const refPath of referencedPaths) {
-    const commits = await getCommitsSince(projectRoot, refPath, lastModified);
+  for (const [refPath, commits] of counts) {
     totalCommits += commits;
     if (commits > mostActiveCommits) {
       mostActiveCommits = commits;
@@ -41688,54 +41723,88 @@ function detectDirectives(file2) {
 function checkContradictions(files) {
   if (files.length < 2) return [];
   const issues = [];
-  const allDirectives = [];
-  for (const file2 of files) {
-    allDirectives.push(...detectDirectives(file2));
-  }
   const byCategory = /* @__PURE__ */ new Map();
-  for (const d of allDirectives) {
-    const existing = byCategory.get(d.category) || [];
-    existing.push(d);
-    byCategory.set(d.category, existing);
+  const directiveIndex = /* @__PURE__ */ new Map();
+  for (const file2 of files) {
+    for (const d of detectDirectives(file2)) {
+      let list = byCategory.get(d.category);
+      if (!list) {
+        list = [];
+        byCategory.set(d.category, list);
+      }
+      list.push(d);
+      let idx = directiveIndex.get(d.category);
+      if (!idx) {
+        idx = /* @__PURE__ */ new Map();
+        directiveIndex.set(d.category, idx);
+      }
+      const key = `${d.file}::${d.label}`;
+      if (!idx.has(key)) idx.set(key, d);
+    }
   }
   for (const [category, directives] of byCategory) {
-    const byFile = /* @__PURE__ */ new Map();
-    for (const d of directives) {
-      const existing = byFile.get(d.file) || [];
-      existing.push(d);
-      byFile.set(d.file, existing);
-    }
     const labels = new Set(directives.map((d) => d.label));
     if (labels.size <= 1) continue;
     const fileLabels = /* @__PURE__ */ new Map();
     for (const d of directives) {
-      const existing = fileLabels.get(d.file) || /* @__PURE__ */ new Set();
+      let existing = fileLabels.get(d.file);
+      if (!existing) {
+        existing = /* @__PURE__ */ new Set();
+        fileLabels.set(d.file, existing);
+      }
       existing.add(d.label);
-      fileLabels.set(d.file, existing);
-    }
-    const fileEntries = [...fileLabels.entries()];
-    for (let i2 = 0; i2 < fileEntries.length; i2++) {
-      for (let j3 = i2 + 1; j3 < fileEntries.length; j3++) {
-        const [fileA, labelsA] = fileEntries[i2];
-        const [fileB, labelsB] = fileEntries[j3];
-        for (const labelA of labelsA) {
-          for (const labelB of labelsB) {
-            if (labelA !== labelB) {
-              const directiveA = directives.find((d) => d.file === fileA && d.label === labelA);
-              const directiveB = directives.find((d) => d.file === fileB && d.label === labelB);
-              issues.push({
-                severity: "warning",
-                check: "contradictions",
-                ruleId: "contradictions/conflict",
-                line: directiveA.line,
-                message: `${category} conflict: "${directiveA.label}" in ${fileA} vs "${directiveB.label}" in ${fileB}`,
-                suggestion: `Align on one ${category} across all context files`,
-                detail: `${fileA}:${directiveA.line} says "${directiveA.text}" but ${fileB}:${directiveB.line} says "${directiveB.text}"`
-              });
-            }
-          }
+    }
+    const conflictingFiles = [...fileLabels.keys()].filter((f) => {
+      const myLabels = fileLabels.get(f);
+      for (const [otherFile, otherLabels] of fileLabels) {
+        if (otherFile === f) continue;
+        for (const l of myLabels) {
+          if (!otherLabels.has(l)) return true;
+        }
+      }
+      return false;
+    });
+    if (conflictingFiles.length < 2) continue;
+    const idx = directiveIndex.get(category);
+    if (conflictingFiles.length === 2) {
+      const [fileA, fileB] = conflictingFiles;
+      const labelsA = fileLabels.get(fileA);
+      const labelsB = fileLabels.get(fileB);
+      for (const labelA of labelsA) {
+        for (const labelB of labelsB) {
+          if (labelA === labelB) continue;
+          const directiveA = idx.get(`${fileA}::${labelA}`);
+          const directiveB = idx.get(`${fileB}::${labelB}`);
+          issues.push({
+            severity: "warning",
+            check: "contradictions",
+            ruleId: "contradictions/conflict",
+            line: directiveA.line,
+            message: `${category} conflict: "${directiveA.label}" in ${fileA} vs "${directiveB.label}" in ${fileB}`,
+            suggestion: `Align on one ${category} across all context files`,
+            detail: `${fileA}:${directiveA.line} says "${directiveA.text}" but ${fileB}:${directiveB.line} says "${directiveB.text}"`
+          });
         }
       }
+    } else {
+      const entries = [];
+      for (const f of conflictingFiles) {
+        for (const l of fileLabels.get(f)) {
+          entries.push(idx.get(`${f}::${l}`));
+        }
+      }
+      const firstEntry = entries[0];
+      const summary = entries.map((e) => `"${e.label}" in ${e.file}`).join(", ");
+      const detail = entries.map((e) => `${e.file}:${e.line} says "${e.text}"`).join("\n");
+      issues.push({
+        severity: "warning",
+        check: "contradictions",
+        ruleId: "contradictions/conflict",
+        line: firstEntry.line,
+        message: `${category} conflict across ${conflictingFiles.length} files: ${summary}`,
+        suggestion: `Align on one ${category} across all context files`,
+        detail
+      });
     }
   }
   return issues;
@@ -42413,6 +42482,7 @@ async function checkMcpCommands(config2, projectRoot) {
     }
     if (server2.args) {
       for (const arg of server2.args) {
+        if (URL_PREFIX.test(arg)) continue;
         if (LOCAL_PATH_PATTERN.test(arg) || FILE_PATH_PATTERN.test(arg)) {
           const resolved = path8.resolve(projectRoot, arg);
           if (!fileExistsSafe(resolved)) {
@@ -42438,12 +42508,13 @@ function fileExistsSafe(filePath) {
     return false;
   }
 }
-var LOCAL_PATH_PATTERN, FILE_PATH_PATTERN;
+var LOCAL_PATH_PATTERN, FILE_PATH_PATTERN, URL_PREFIX;
 var init_commands2 = __esm({
   "src/core/checks/mcp/commands.ts"() {
     "use strict";
     LOCAL_PATH_PATTERN = /^\.\.?\//;
     FILE_PATH_PATTERN = /^[^-].*\/.*\.\w+$/;
+    URL_PREFIX = /^(https?|file|s3|gs|ssh|git):\/\//i;
   }
 });
 
@@ -43766,7 +43837,7 @@ import { readFileSync as readFileSync4 } from "node:fs";
 import { resolve as resolve8, dirname as dirname3 } from "node:path";
 import { fileURLToPath } from "node:url";
 function loadVersion() {
-  if (true) return "0.9.6";
+  if (true) return "0.9.7";
   const __dir = dirname3(fileURLToPath(import.meta.url));
   const pkgPath = resolve8(__dir, "../package.json");
   const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
@@ -44597,6 +44668,7 @@ function applyFixes(result, options = {}) {
     }
   }
   const fixesByFile = /* @__PURE__ */ new Map();
+  const dedupeKeys = /* @__PURE__ */ new Map();
   const skippedSymlinks = /* @__PURE__ */ new Set();
   for (const file2 of result.files) {
     for (const issue2 of file2.issues) {
@@ -44605,6 +44677,14 @@ function applyFixes(result, options = {}) {
           skippedSymlinks.add(file2.path);
           continue;
         }
+        const key = `${issue2.fix.line}:${issue2.fix.oldText}:${issue2.fix.newText}`;
+        let seenInFile = dedupeKeys.get(issue2.fix.file);
+        if (!seenInFile) {
+          seenInFile = /* @__PURE__ */ new Set();
+          dedupeKeys.set(issue2.fix.file, seenInFile);
+        }
+        if (seenInFile.has(key)) continue;
+        seenInFile.add(key);
         const existing = fixesByFile.get(issue2.fix.file) || [];
         existing.push(issue2.fix);
         fixesByFile.set(issue2.fix.file, existing);
@@ -51751,6 +51831,76 @@ var init_reporter = __esm({
 // src/core/config.ts
 import * as fs8 from "node:fs";
 import * as path10 from "node:path";
+function formatJsonError(content, err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const posMatch = msg.match(/position (\d+)/);
+  if (posMatch) {
+    return `${msg} (${posToLineCol(content, Number(posMatch[1]))})`;
+  }
+  if (/line \d+/.test(msg)) return msg;
+  const pos = findFirstErrorPos(content, msg);
+  if (pos !== null) {
+    return `${msg} (${posToLineCol(content, pos)})`;
+  }
+  return msg;
+}
+function posToLineCol(content, pos) {
+  let line = 1;
+  let col = 1;
+  for (let i2 = 0; i2 < pos && i2 < content.length; i2++) {
+    if (content[i2] === "\n") {
+      line++;
+      col = 1;
+    } else {
+      col++;
+    }
+  }
+  return `line ${line}, column ${col}`;
+}
+function findFirstErrorPos(content, errMsg) {
+  const snippetMatch = errMsg.match(/\.\.\."([^"]+(?:"[^"]*)*?)"\s+is not valid JSON/);
+  if (snippetMatch) {
+    const snippet = snippetMatch[1];
+    const needle = snippet.split(/\s/).find((s) => s.length > 1);
+    if (needle) {
+      const idx = content.indexOf(needle);
+      if (idx !== -1) return idx;
+    }
+  }
+  const tokenMatch = errMsg.match(/Unexpected token\s+['"]?([^'",]+?)['"]?,/);
+  if (tokenMatch) {
+    const tok = tokenMatch[1];
+    const idx = content.indexOf(tok);
+    if (idx !== -1) return idx;
+  }
+  return null;
+}
+function suggestKey(unknown2) {
+  let best = null;
+  let bestDist = Infinity;
+  for (const known of KNOWN_CONFIG_KEYS) {
+    const d = levenshtein2(unknown2, known);
+    if (d < bestDist) {
+      bestDist = d;
+      best = known;
+    }
+  }
+  if (best && bestDist <= Math.max(2, Math.floor(unknown2.length / 3))) {
+    return best;
+  }
+  return null;
+}
+function warnUnknownKeys(config2, source) {
+  if (!config2 || typeof config2 !== "object" || Array.isArray(config2)) return;
+  const keys = Object.keys(config2);
+  const known = new Set(KNOWN_CONFIG_KEYS);
+  for (const k3 of keys) {
+    if (known.has(k3)) continue;
+    const hint = suggestKey(k3);
+    const suggestion = hint ? ` \u2014 did you mean "${hint}"?` : "";
+    console.error(`Warning: unknown config key "${k3}" in ${source}${suggestion}`);
+  }
+}
 function loadConfig(projectRoot) {
   for (const filename of CONFIG_FILENAMES) {
     const filePath = path10.join(projectRoot, filename);
@@ -51760,19 +51910,39 @@ function loadConfig(projectRoot) {
     } catch {
       continue;
     }
+    let parsed;
     try {
-      return JSON.parse(content);
+      parsed = JSON.parse(content);
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      throw new Error(`Invalid JSON in ${filePath}: ${msg}`, { cause: err });
+      throw new Error(`Invalid JSON in ${filePath}: ${formatJsonError(content, err)}`, {
+        cause: err
+      });
     }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error(
+        `Invalid config in ${filePath}: expected a JSON object at the root, got ${Array.isArray(parsed) ? "an array" : typeof parsed}`
+      );
+    }
+    warnUnknownKeys(parsed, filePath);
+    return parsed;
   }
   return null;
 }
-var CONFIG_FILENAMES;
+var import_fast_levenshtein2, levenshtein2, KNOWN_CONFIG_KEYS, CONFIG_FILENAMES;
 var init_config2 = __esm({
   "src/core/config.ts"() {
     "use strict";
+    import_fast_levenshtein2 = __toESM(require_levenshtein(), 1);
+    levenshtein2 = import_fast_levenshtein2.default.get;
+    KNOWN_CONFIG_KEYS = [
+      "checks",
+      "ignore",
+      "strict",
+      "tokenThresholds",
+      "contextFiles",
+      "mcp",
+      "mcpGlobal"
+    ];
     CONFIG_FILENAMES = [".ctxlintrc", ".ctxlintrc.json"];
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yawlabs/ctxlint",
-  "version": "0.9.6",
+  "version": "0.9.7",
   "description": "Lint your AI agent context files, MCP server configs, and session data against your actual codebase",
   "bin": {
     "ctxlint": "dist/index.js"