instrlint 0.1.10 → 0.2.2

package/dist/cli.js

@@ -172,7 +172,8 @@ var KEYWORD_REGEX = new RegExp(
   "gi"
 );
 var PATH_REGEX = /(?<!\w)(?:\.{1,2}\/|(?:src|tests?|dist|lib|docs?|config|scripts?|packages?)\/)[^\s,;`'")\]>]+/g;
-var RULE_IMPERATIVE_WORDS = /\b(must|should|never|always|prefer|avoid|ensure|require|forbid|use|do not|don't)\b/i;
+var AT_REF_REGEX = /(?<![a-zA-Z0-9_])@((?:\.\.?\/)?[\w./-]+\.(?:md|txt|json|yaml|yml))\b/g;
+var RULE_IMPERATIVE_WORDS = /\b(must|should|never|always|prefer|avoid|ensure|require|forbid|use|do not|don't)\b|必須|應該|應當|永遠|總是|禁止|不要|不可|不得|避免|請使用|優先使用|請勿/i;
 var RULE_NEGATION_PATTERN = /\b(not|don't|do not)\s+\w+/i;
 var STRONG_IMPERATIVE = /\b(must|shall|always|never)\b/i;
 function parseYamlFrontmatter(content) {
@@ -228,6 +229,8 @@ function isRule(text) {
     if (STRONG_IMPERATIVE.test(body) && /^[A-Z]/.test(body)) return true;
     if (RULE_IMPERATIVE_WORDS.test(body) && /^[A-Z][a-z]/.test(body))
       return true;
+    if (RULE_IMPERATIVE_WORDS.test(body) && /^[\u4e00-\u9fff\u3400-\u4dbf]/.test(body))
+      return true;
   }
   return false;
 }
@@ -240,12 +243,15 @@ function extractKeywords(text) {
   return [...found];
 }
 function extractPaths(text) {
-  const matches = text.matchAll(PATH_REGEX);
   const found = [];
-  for (const m of matches) {
+  for (const m of text.matchAll(PATH_REGEX)) {
     const cleaned = m[0].replace(/[.,;)>\]'"]+$/, "");
     if (cleaned.length > 1) found.push(cleaned);
   }
+  for (const m of text.matchAll(AT_REF_REGEX)) {
+    const cleaned = (m[1] ?? "").replace(/[.,;)>\]'"]+$/, "");
+    if (cleaned.length > 0) found.push(cleaned);
+  }
   return [...new Set(found)];
 }
 function parseInstructionFile(filePath) {
@@ -885,7 +891,7 @@ function analyzeBudget(instructions) {
 }
 
 // src/detectors/config-overlap.ts
-import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync5, readdirSync as readdirSync4 } from "fs";
 import { join as join5 } from "path";
 function readJsonFile(projectRoot, filename) {
   try {
@@ -926,6 +932,31 @@ function getPrettierField(projectRoot, field) {
   }
   return void 0;
 }
+function readCsprojContent(projectRoot) {
+  const buildProps = readTextFile(projectRoot, "Directory.Build.props");
+  if (buildProps) return buildProps;
+  try {
+    const files = readdirSync4(projectRoot);
+    for (const f of files) {
+      if (f.endsWith(".csproj") || f.endsWith(".fsproj")) {
+        const content = readTextFile(projectRoot, f);
+        if (content) return content;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function checkCsprojProperty(projectRoot, tag, value) {
+  const content = readCsprojContent(projectRoot);
+  if (!content) return false;
+  return new RegExp(`<${tag}>\\s*${value}\\s*</${tag}>`, "i").test(content);
+}
+function checkEditorConfigPattern(projectRoot, pattern) {
+  const content = readTextFile(projectRoot, ".editorconfig");
+  if (!content) return false;
+  return pattern.test(content);
+}
 function checkEslintRule(projectRoot, ruleName) {
   const parsed = readJsonFile(projectRoot, ".eslintrc.json");
   if (!parsed || typeof parsed !== "object") return false;
@@ -1091,6 +1122,52 @@ var PATTERNS = [
     rulePattern: /\b(no|avoid|prefer\s*named)\s*(default\s*export)/i,
     configCheck: (root) => checkEslintRule(root, "import/no-default-export") || checkEslintRule(root, "no-restricted-exports"),
     configName: "eslint-plugin-import (no-default-export)"
+  },
+  // ─── C# patterns ─────────────────────────────────────────────────────────
+  {
+    id: "csharp-nullable",
+    rulePattern: /\b(nullable\s*reference\s*type|#nullable\s*enable|enable\s*nullable|null\s*reference\s*exception)\b/i,
+    configCheck: (root) => checkCsprojProperty(root, "Nullable", "enable") || checkCsprojProperty(root, "Nullable", "annotations") || checkCsprojProperty(root, "Nullable", "warnings"),
+    configName: ".csproj (<Nullable>enable</Nullable>)"
+  },
+  {
+    id: "csharp-implicit-usings",
+    rulePattern: /\b(global\s*usings?|implicit\s*usings?)\b/i,
+    configCheck: (root) => checkCsprojProperty(root, "ImplicitUsings", "enable"),
+    configName: ".csproj (<ImplicitUsings>enable</ImplicitUsings>)"
+  },
+  {
+    id: "csharp-test-framework",
+    rulePattern: /\b(xunit|nunit|mstest|microsoft\.testing\.framework)\b/i,
+    configCheck: (root) => {
+      const content = readCsprojContent(root);
+      if (!content) return false;
+      return /PackageReference\s+Include="(xunit|NUnit|MSTest|Microsoft\.Testing)/i.test(
+        content
+      );
+    },
+    configName: ".csproj (PackageReference xUnit / NUnit / MSTest)"
+  },
+  {
+    id: "csharp-formatter",
+    rulePattern: /\bdotnet\s*format\b/i,
+    configCheck: (root) => checkEditorConfigPattern(root, /^\[.*\.cs\]/m) && checkEditorConfigPattern(root, /^csharp_/m),
+    configName: ".editorconfig ([*.cs] csharp_style_* settings)"
+  },
+  {
+    id: "csharp-naming",
+    rulePattern: /\bdotnet_naming\b|PascalCase\s+for\s+(all\s+)?(public|class|method|property|type)\b/i,
+    configCheck: (root) => checkEditorConfigPattern(root, /^dotnet_naming_rule\./m),
+    configName: ".editorconfig (dotnet_naming_rule.*)"
+  },
+  {
+    id: "csharp-unused",
+    rulePattern: /\b(IDE0059|CS0168|CS0219|dead\s*code|unused.*IDE|roslyn.*unused)\b/i,
+    configCheck: (root) => checkEditorConfigPattern(
+      root,
+      /^dotnet_diagnostic\.(IDE0059|CS0168|CS0219)/m
+    ),
+    configName: ".editorconfig (dotnet_diagnostic.IDE0059 / CS0168)"
   }
 ];
 function collectRuleLines(instructions) {
@@ -1141,6 +1218,7 @@ function detectConfigOverlaps(instructions, projectRoot) {
 
 // src/utils/text.ts
 var STOP_WORDS = /* @__PURE__ */ new Set([
+  // English grammatical function words
   "the",
   "a",
   "an",
@@ -1154,10 +1232,30 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "of",
   "with",
   "that",
-  "this"
+  "this",
+  // Chinese filler bigrams (grammatical / no topic content)
+  "\u7684\u6642",
+  "\u6642\u5019",
+  "\u4E00\u500B",
+  "\u6240\u6709",
+  "\u6BCF\u500B"
 ]);
+var CJK_RUN = /[\u4e00-\u9fff\u3400-\u4dbf]+/g;
+var ASCII_WORD = /[a-z0-9]+/g;
 function tokenizeWords(text) {
-  return text.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 1);
+  const words = [];
+  const lower = text.toLowerCase();
+  for (const m of lower.matchAll(ASCII_WORD)) {
+    if (m[0].length > 1) words.push(m[0]);
+  }
+  for (const m of text.matchAll(CJK_RUN)) {
+    const run = m[0];
+    if (run.length < 2) continue;
+    for (let i = 0; i < run.length - 1; i++) {
+      words.push(run.slice(i, i + 2));
+    }
+  }
+  return words;
 }
 function removeStopWords(words) {
   return words.filter((w) => !STOP_WORDS.has(w));
@@ -1238,8 +1336,10 @@ function analyzeDeadRules(instructions, projectRoot) {
 
 // src/detectors/contradiction.ts
 var NEGATION_WORDS = ["never", "don't", "avoid", "forbid"];
+var CJK_NEGATIONS = ["\u7981\u6B62", "\u4E0D\u8981", "\u4E0D\u53EF", "\u4E0D\u5F97", "\u907F\u514D", "\u8ACB\u52FF", "\u52FF"];
+var CJK_ONLY_RE = /^[\u4e00-\u9fff\u3400-\u4dbf]+$/;
 function isNegated(text, word) {
-  const sentences = text.split(/[.!?]+\s+/);
+  const sentences = text.split(/[.!?。！？]+\s*/);
   const escapedWord = word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const wordPresent = new RegExp(`\\b${escapedWord}\\b`, "i");
   for (const sentence of sentences) {
@@ -1258,6 +1358,14 @@ function isNegated(text, word) {
     );
     if (notPattern.test(lower)) return true;
   }
+  if (CJK_ONLY_RE.test(word)) {
+    for (const sentence of sentences) {
+      if (!sentence.includes(word)) continue;
+      for (const neg of CJK_NEGATIONS) {
+        if (sentence.includes(neg)) return true;
+      }
+    }
+  }
   return false;
 }
 var POLARITY_STOP_WORDS = /* @__PURE__ */ new Set([
@@ -1294,7 +1402,26 @@ var POLARITY_STOP_WORDS = /* @__PURE__ */ new Set([
   "be",
   "by",
   "own",
-  "on"
+  "on",
+  // Chinese polarity / imperative bigrams (analogues of English never/always/use/must)
+  "\u6C38\u9060",
+  "\u7E3D\u662F",
+  "\u7981\u6B62",
+  "\u4E0D\u8981",
+  "\u4E0D\u53EF",
+  "\u4E0D\u5F97",
+  "\u907F\u514D",
+  "\u8ACB\u52FF",
+  "\u5FC5\u9808",
+  "\u61C9\u8A72",
+  "\u61C9\u7576",
+  // Chinese generic verb bigrams (HOW to comply, not WHAT topic)
+  "\u4F7F\u7528",
+  "\u63A1\u7528",
+  "\u57F7\u884C",
+  "\u9032\u884C",
+  "\u53EF\u4EE5",
+  "\u9700\u8981"
 ]);
 function collectRuleLines3(instructions) {
   const sources = [
@@ -1399,7 +1526,7 @@ function detectStaleRefs(instructions, projectRoot) {
 
 // src/detectors/scope-classifier.ts
 var PATH_REF_PATTERN = /\b(?:src|tests?|lib|dist)\//i;
-var HOOK_PATTERN = /\b(?:never|don't|do\s+not|forbid)\b.*\b(?:commit|push|merge|build|run)\b/i;
+var HOOK_PATTERN = /\b(?:never|don't|do\s+not|forbid)\b(?:\s+\w+){0,3}\s+\b(?:commit|push|merge|rebase|tag|checkout|amend)\b/i;
 function classifyScope(instructions) {
   const findings = [];
   const rootFile = instructions.rootFile;
@@ -2436,14 +2563,15 @@ function readInstalledVersion(path) {
     return null;
   }
 }
-function checkSkillUpdate(projectRoot) {
+function checkSkillUpdate(projectRoot, globalRoot) {
+  const resolvedGlobal = globalRoot ?? homedir();
   const candidates = [
     {
       path: join7(projectRoot, ".claude", "commands", "instrlint.md"),
       isProject: true
     },
     {
-      path: join7(homedir(), ".claude", "commands", "instrlint.md"),
+      path: join7(resolvedGlobal, ".claude", "commands", "instrlint.md"),
       isProject: false
     }
   ];
@@ -2486,7 +2614,7 @@ import { relative as relative3 } from "path";
 function shouldVerify(finding) {
   if (finding.category === "stale-ref") return false;
   if (finding.category === "budget") return false;
-  if (finding.category === "structure") return false;
+  if (finding.category === "structure") return true;
   if (finding.category === "dead-rule") return !finding.autoFixable;
   if (finding.category === "contradiction") return true;
   if (finding.category === "duplicate") {
@@ -2533,6 +2661,13 @@ function buildContext(finding, parsed, projectRoot) {
       ruleB: ruleRef(parsed, finding.file, finding.line ?? 0, projectRoot)
     };
   }
+  if (finding.category === "structure") {
+    return {
+      type: "structure",
+      rule: ruleRef(parsed, finding.file, finding.line ?? 0, projectRoot),
+      suggestion: finding.suggestion
+    };
+  }
   return null;
 }
 function hashFinding(finding) {
@@ -2547,6 +2682,10 @@ var QUESTIONS = {
   duplicate: {
     en: 'Are rules A and B true semantic duplicates \u2014 do they say the same thing in different words, such that keeping both adds no value? Respond with JSON only: {"verdict":"confirmed"|"rejected"|"uncertain","reason":"<\u226420 words>"}',
     "zh-TW": '\u898F\u5247 A \u548C\u898F\u5247 B \u5728\u8A9E\u610F\u4E0A\u771F\u7684\u662F\u91CD\u8907\u7684\u55CE\u2014\u2014\u7528\u4E0D\u540C\u7684\u63AA\u8FAD\u8AAA\u540C\u4E00\u4EF6\u4E8B\uFF0C\u4FDD\u7559\u5169\u689D\u6BEB\u7121\u984D\u5916\u50F9\u503C\uFF1F\u50C5\u7528 JSON \u56DE\u7B54\uFF1A{"verdict":"confirmed"|"rejected"|"uncertain","reason":"<20 \u5B57\u4EE5\u5167>"}'
+  },
+  structure: {
+    en: 'Is this structural suggestion accurate? Should this rule truly move to a git hook or path-scoped rule file, or is it an architectural principle / general guidance that belongs in CLAUDE.md? Respond with JSON only: {"verdict":"confirmed"|"rejected"|"uncertain","reason":"<\u226420 words>"}',
+    "zh-TW": '\u9019\u689D\u7D50\u69CB\u5EFA\u8B70\u662F\u5426\u6E96\u78BA\uFF1F\u9019\u689D\u898F\u5247\u771F\u7684\u66F4\u9069\u5408\u79FB\u5230 git hook \u6216 path-scoped rule file \u4E2D\uFF0C\u9084\u662F\u5B83\u662F\u67B6\u69CB\u8AAA\u660E / \u4E00\u822C\u539F\u5247\uFF0C\u61C9\u7559\u5728 CLAUDE.md \u4E2D\uFF1F\u50C5\u7528 JSON \u56DE\u7B54\uFF1A{"verdict":"confirmed"|"rejected"|"uncertain","reason":"<20 \u5B57\u4EE5\u5167>"}'
   }
 };
 function questionFor(category, locale) {