@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/dist/clients/ast-grep-client.js

@@ -0,0 +1,576 @@
+import { createSubsystemLogger } from "./extension-log.js";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { AstGrepRuleManager, checkAstGrepRulesHealth } from "./ast-grep-rule-manager.js";
+import { reportBundledResourceDirHealth } from "./bundled-resource-health.js";
+import { getDegradationLedgerGeneration } from "./degradation-ledger.js";
+import { logLatency } from "./latency-logger.js";
+import { getMutationBridge } from "./mutation-bridge.js";
+import { resolvePackagePath } from "./package-root.js";
+import { truncatedByOutputCap } from "./spawn-output-cap.js";
+import { SgRunner } from "./sg-runner.js";
+function reportAstGrepRulesHealth(bundledRuleDir) {
+  const health = checkAstGrepRulesHealth(bundledRuleDir);
+  logLatency({
+    type: "phase",
+    phase: "ast_grep_rules_resolved",
+    filePath: bundledRuleDir,
+    durationMs: 0,
+    metadata: {
+      status: health.status,
+      entryCount: health.status === "healthy" ? health.entryCount : 0
+    }
+  });
+  reportBundledResourceDirHealth("ast-grep-rules-dir-missing", bundledRuleDir, health, "ast-grep rule descriptions");
+}
+function recordAstGrepApply(matches) {
+  const bridge = getMutationBridge();
+  if (!bridge || matches.length === 0)
+    return;
+  const rangesByFile = new Map;
+  for (const match of matches) {
+    const start = (match.range?.start?.line ?? 0) + 1;
+    const end = Math.max(start, (match.range?.end?.line ?? 0) + 1);
+    const existing = rangesByFile.get(match.file);
+    if (existing)
+      existing.push([start, end]);
+    else
+      rangesByFile.set(match.file, [[start, end]]);
+  }
+  for (const [filePath, editRanges] of rangesByFile) {
+    bridge.recordMutation({
+      filePath,
+      kind: "edit",
+      editRanges,
+      consumer: "ast_grep_replace"
+    });
+  }
+}
+function extractDebugAst(raw) {
+  const lines = raw.split(/\r?\n/);
+  const start = lines.findIndex((line) => /^Debug (?:A|C)ST:/.test(line.trim()));
+  if (start < 0)
+    return;
+  const out = [];
+  for (const line of lines.slice(start + 1)) {
+    if (!line.trim())
+      break;
+    out.push(line);
+  }
+  return out.length > 0 ? out.join(`
+`) : undefined;
+}
+function lineStartOffsets(source) {
+  const offsets = [0];
+  for (let index = 0;index < source.length; index++) {
+    if (source.charCodeAt(index) === 10)
+      offsets.push(index + 1);
+  }
+  return offsets;
+}
+function snippetForRange(source, offsets, startLine0, startCol0, endLine0, endCol0) {
+  const start = (offsets[startLine0] ?? 0) + startCol0;
+  const end = (offsets[endLine0] ?? source.length) + endCol0;
+  const text = source.slice(start, end).replace(/\s+/g, " ").trim();
+  return text.length > 80 ? `${text.slice(0, 77)}...` : text;
+}
+const MAX_VALIDATE_PATTERN_CHARS = 20000;
+const MAX_VALIDATE_RULE_CHARS = 200000;
+const VALIDATION_SNIPPETS = {
+  bash: { ext: "sh", source: `echo dm_lens_validate
+` },
+  c: { ext: "c", source: `int main(void) { return 0; }
+` },
+  cpp: { ext: "cpp", source: `int main() { return 0; }
+` },
+  csharp: { ext: "cs", source: `class C { static void Main() {} }
+` },
+  css: { ext: "css", source: `.dm-lens { color: black; }
+` },
+  go: { ext: "go", source: `package main
+func main() {}
+` },
+  html: { ext: "html", source: `<main>dm-lens</main>
+` },
+  java: { ext: "java", source: `class Main { void run() {} }
+` },
+  javascript: { ext: "js", source: `const piLensValidate = 1;
+` },
+  json: { ext: "json", source: `{"piLensValidate":true}
+` },
+  kotlin: { ext: "kt", source: `fun main() {}
+` },
+  lua: { ext: "lua", source: `local dm_lens_validate = 1
+` },
+  php: { ext: "php", source: `<?php $piLensValidate = 1;
+` },
+  python: { ext: "py", source: `dm_lens_validate = 1
+` },
+  ruby: { ext: "rb", source: `dm_lens_validate = 1
+` },
+  rust: { ext: "rs", source: `fn main() {}
+` },
+  tsx: { ext: "tsx", source: `export function App() { return <div />; }
+` },
+  typescript: { ext: "ts", source: `const piLensValidate = 1;
+` },
+  yaml: { ext: "yaml", source: `piLensValidate: true
+` }
+};
+function validationSnippetFor(language) {
+  const key = language.toLowerCase().replace(/^"|"$/g, "");
+  return VALIDATION_SNIPPETS[key] ?? {
+    ext: key.replace(/[^a-z0-9_-]/gi, "") || "txt",
+    source: `dm_lens_validate
+`
+  };
+}
+function validateInputShape(value, maxChars, label) {
+  if (value.includes("\x00"))
+    return `${label} contains NUL bytes`;
+  if (value.length > maxChars) {
+    return `${label} is too large (${value.length} chars, max ${maxChars})`;
+  }
+  return;
+}
+function stderrHasError(stderr) {
+  return stderr.split(/\r?\n/).some((line) => /^\s*(error|Error):/.test(line));
+}
+function formatDebugAst(tree, source) {
+  const offsets = lineStartOffsets(source);
+  return tree.split(/\r\n|\n/).map((line) => {
+    const match = /^([ \t]*)([^ \t(][^(]*)? \((\d+),(\d+)\)-\((\d+),(\d+)\)$/.exec(line);
+    if (!match)
+      return line;
+    const [, indent = "", label = "", startLine, startCol, endLine, endCol] = match;
+    const sl = Number(startLine);
+    const sc = Number(startCol);
+    const el = Number(endLine);
+    const ec = Number(endCol);
+    const snippet = snippetForRange(source, offsets, sl, sc, el, ec);
+    return `${indent}${label} [${sl + 1},${sc + 1}] - [${el + 1},${ec + 1}] ${JSON.stringify(snippet)}`;
+  }).join(`
+`);
+}
+
+export class AstGrepClient {
+  ruleDir;
+  log;
+  ruleManager;
+  runner;
+  usingBundledRuleDirFallback;
+  rulesHealthReportedGeneration;
+  constructor(ruleDir, verbose = false) {
+    const projectRuleDir = path.join(process.cwd(), "rules");
+    const hasProjectRuleDir = fs.existsSync(projectRuleDir);
+    this.usingBundledRuleDirFallback = !ruleDir && !hasProjectRuleDir;
+    this.ruleDir = ruleDir || (hasProjectRuleDir ? projectRuleDir : resolvePackagePath(import.meta.url, "rules"));
+    this.log = verbose ? createSubsystemLogger("ast-grep") : () => {};
+    this.ensureRulesHealthReported();
+    this.ruleManager = new AstGrepRuleManager(this.ruleDir, this.log);
+    this.runner = new SgRunner(verbose);
+  }
+  ensureRulesHealthReported() {
+    const generation = getDegradationLedgerGeneration();
+    if (this.rulesHealthReportedGeneration === generation)
+      return;
+    this.rulesHealthReportedGeneration = generation;
+    if (this.usingBundledRuleDirFallback) {
+      reportAstGrepRulesHealth(this.ruleDir);
+    }
+  }
+  ensureAvailable() {
+    this.ensureRulesHealthReported();
+    return this.runner.ensureAvailable();
+  }
+  async replaceWithRule(ruleYaml, paths, apply) {
+    const allMatches = [];
+    for (const scanPath of paths) {
+      if (apply) {
+        const preCheck = await this.tempScanDetailed(scanPath, ruleYaml);
+        if (preCheck.failure || preCheck.error) {
+          return {
+            matches: allMatches,
+            totalMatches: allMatches.length,
+            applied: false,
+            error: preCheck.error ?? "ast-grep preview failed"
+          };
+        }
+        if (preCheck.matches.length === 0) {
+          return {
+            matches: [],
+            totalMatches: 0,
+            applied: false,
+            stalePreview: true
+          };
+        }
+      }
+      const result = await this.runner.tempScanWithFixAsync(scanPath, "agent-rule", ruleYaml, apply);
+      if (result.error) {
+        return {
+          matches: allMatches,
+          totalMatches: allMatches.length,
+          applied: false,
+          error: result.error
+        };
+      }
+      allMatches.push(...result.matches);
+    }
+    return {
+      matches: allMatches,
+      totalMatches: allMatches.length,
+      applied: apply
+    };
+  }
+  async tempScanDetailed(dir, ruleYaml, options = {}) {
+    const detailed = this.runner.tempScanDetailedAsync;
+    if (detailed) {
+      return detailed.call(this.runner, dir, "agent-rule", ruleYaml, 30000, options);
+    }
+    const matches = await this.runner.tempScanAsync(dir, "agent-rule", ruleYaml, 30000, options);
+    return { matches, status: 0 };
+  }
+  async searchWithRule(ruleYaml, paths, options = {}) {
+    const allMatches = [];
+    for (const scanPath of paths) {
+      try {
+        const results = await this.tempScanDetailed(scanPath, ruleYaml, options);
+        if (results.failure || results.error) {
+          return {
+            matches: allMatches,
+            totalMatches: allMatches.length,
+            error: results.error || `ast-grep scan failed (${results.failure ?? "unknown failure"})`
+          };
+        }
+        allMatches.push(...results.matches);
+      } catch (err) {
+        return {
+          matches: allMatches,
+          totalMatches: allMatches.length,
+          error: String(err)
+        };
+      }
+    }
+    return { matches: allMatches, totalMatches: allMatches.length };
+  }
+  async dumpAst(source, lang, options = {}) {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "dm-lens-ast-dump-"));
+    const tmpFile = path.join(tmpDir, `snippet.${lang.replace(/[^a-z0-9_-]/gi, "") || "txt"}`);
+    try {
+      fs.writeFileSync(tmpFile, source, "utf-8");
+      const mode = options.includeAnonymous ? "cst" : "ast";
+      const result = await this.runner.execRaw([
+        "run",
+        "--lang",
+        lang,
+        "-p",
+        source,
+        `--debug-query=${mode}`,
+        tmpFile
+      ]);
+      const raw = result.stderr || result.stdout;
+      const tree = extractDebugAst(raw);
+      if (tree)
+        return { output: formatDebugAst(tree, source) };
+      return {
+        error: result.error || result.stderr.trim() || result.stdout.trim() || `ast-grep did not return a debug AST for language ${lang}`
+      };
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  }
+  async validatePattern(pattern, lang, options) {
+    const shapeError = validateInputShape(pattern, MAX_VALIDATE_PATTERN_CHARS, "pattern");
+    if (shapeError)
+      return { valid: false, error: shapeError };
+    const snippet = validationSnippetFor(lang);
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "dm-lens-sg-validate-"));
+    const tmpFile = path.join(tmpDir, `snippet.${snippet.ext}`);
+    try {
+      fs.writeFileSync(tmpFile, snippet.source, "utf-8");
+      const args = ["run", "-p", pattern, "--lang", lang, "--json=compact"];
+      if (options?.selector)
+        args.push("--selector", options.selector);
+      if (options?.strictness)
+        args.push("--strictness", options.strictness);
+      args.push(tmpFile);
+      const result = await this.runner.execRaw(args, 1e4, options);
+      const stderr = result.stderr.trim();
+      const stdout = result.stdout.trim();
+      if (truncatedByOutputCap(result)) {
+        return {
+          valid: false,
+          error: "ast-grep validation output was truncated"
+        };
+      }
+      if (result.error)
+        return { valid: false, error: result.error };
+      if (result.status !== 0 && !(result.status === 1 && !stderr)) {
+        return {
+          valid: false,
+          error: stderr || `ast-grep validation failed with exit code ${result.status}`
+        };
+      }
+      if (stderrHasError(stderr))
+        return { valid: false, error: stderr };
+      const warning = stderr || stdout || undefined;
+      return {
+        valid: true,
+        ...warning ? { warning } : {}
+      };
+    } finally {
+      try {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      } catch {}
+    }
+  }
+  async validateRule(ruleYaml, options = {}) {
+    const shapeError = validateInputShape(ruleYaml, MAX_VALIDATE_RULE_CHARS, "rule");
+    if (shapeError)
+      return { valid: false, error: shapeError };
+    const language = /^\s*language:\s*([^\s#]+)/im.exec(ruleYaml)?.[1] ?? "typescript";
+    const snippet = validationSnippetFor(language);
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "dm-lens-sg-rule-"));
+    try {
+      fs.writeFileSync(path.join(tmpDir, `snippet.${snippet.ext}`), snippet.source, "utf-8");
+      const result = await this.tempScanDetailed(tmpDir, ruleYaml, options);
+      if (result.failure || result.error) {
+        return {
+          valid: false,
+          error: result.error || `ast-grep rule validation failed (${result.failure ?? "unknown failure"})`
+        };
+      }
+      return { valid: true };
+    } catch (err) {
+      return { valid: false, error: String(err) };
+    } finally {
+      try {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      } catch {}
+    }
+  }
+  async outline(paths, options = {}) {
+    if (paths.length === 0)
+      return { error: "no paths provided" };
+    const args = ["outline", "--json=compact", "--color", "never"];
+    if (options.lang)
+      args.push("--lang", options.lang);
+    if (options.items)
+      args.push("--items", options.items);
+    if (options.view)
+      args.push("--view", options.view);
+    if (options.types?.length)
+      args.push("--type", options.types.join(","));
+    if (options.match)
+      args.push("--match", options.match);
+    if (options.pubMembers)
+      args.push("--pub-members");
+    for (const glob of options.globs ?? [])
+      args.push("--globs", glob);
+    args.push(...paths);
+    const result = await this.runner.execRaw(args);
+    const raw = (result.stdout ?? "").trim();
+    if (!raw) {
+      return {
+        error: result.error || result.stderr?.trim() || "ast-grep outline returned no output"
+      };
+    }
+    try {
+      return { output: JSON.parse(raw) };
+    } catch (err) {
+      return {
+        error: `failed to parse ast-grep outline JSON: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+  async search(pattern, lang, paths, options) {
+    const args = ["run", "-p", pattern, "--lang", lang, "--json=compact"];
+    if (options?.selector) {
+      args.push("--selector", options.selector);
+    }
+    if (options?.context !== undefined) {
+      args.push("--context", String(options.context));
+    }
+    if (options?.strictness) {
+      args.push("--strictness", options.strictness);
+    }
+    args.push(...paths);
+    const result = await this.runner.exec(args, options);
+    return {
+      matches: result.matches,
+      totalMatches: result.totalMatches,
+      truncated: result.truncated,
+      error: result.error
+    };
+  }
+  async replace(pattern, rewrite, lang, paths, apply = false, options) {
+    const baseArgs = ["run", "-p", pattern, "-r", rewrite, "--lang", lang];
+    if (options?.strictness) {
+      baseArgs.push("--strictness", options.strictness);
+    }
+    if (!apply) {
+      const result = await this.runner.exec([
+        ...baseArgs,
+        "--json=compact",
+        ...paths
+      ]);
+      return {
+        matches: result.matches,
+        totalMatches: result.totalMatches,
+        truncated: result.truncated,
+        applied: false,
+        error: result.error
+      };
+    }
+    const preCheck = await this.runner.exec([
+      ...baseArgs,
+      "--json=compact",
+      ...paths
+    ]);
+    if (preCheck.error) {
+      return {
+        matches: [],
+        totalMatches: 0,
+        truncated: false,
+        applied: false,
+        error: preCheck.error
+      };
+    }
+    if (preCheck.matches.length === 0) {
+      return {
+        matches: [],
+        totalMatches: 0,
+        truncated: false,
+        applied: false,
+        stalePreview: true
+      };
+    }
+    const applyResult = await this.runner.exec([
+      ...baseArgs,
+      "--update-all",
+      ...paths
+    ]);
+    if (applyResult.error) {
+      return {
+        matches: [],
+        totalMatches: 0,
+        truncated: false,
+        applied: false,
+        error: applyResult.error
+      };
+    }
+    recordAstGrepApply(preCheck.matches);
+    return {
+      matches: preCheck.matches,
+      totalMatches: preCheck.totalMatches,
+      truncated: preCheck.truncated,
+      applied: true,
+      error: undefined
+    };
+  }
+  async runTempScanAsync(dir, ruleId, ruleYaml, timeout = 30000) {
+    if (!await this.ensureAvailable())
+      return [];
+    return this.runner.tempScanAsync(dir, ruleId, ruleYaml, timeout);
+  }
+  async findSimilarFunctions(dir, lang = "typescript") {
+    const ruleYaml = `id: find-functions
+language: ${lang}
+rule:
+  kind: function_declaration
+severity: info
+message: found
+`;
+    const matches = await this.runTempScanAsync(dir, "find-functions", ruleYaml);
+    if (matches.length === 0)
+      return [];
+    return this.groupSimilarFunctions(matches);
+  }
+  groupSimilarFunctions(matches) {
+    const grouped = new Map;
+    for (const item of matches) {
+      const name = this.extractFunctionName(item.text);
+      if (!name)
+        continue;
+      const signature = this.normalizeFunction(item.text);
+      const line = (item.range?.start?.line || item.labels?.[0]?.range?.start?.line || 0) + 1;
+      const group = grouped.get(signature) ?? [];
+      group.push({ name, file: item.file, line });
+      grouped.set(signature, group);
+    }
+    return Array.from(grouped.entries()).filter(([, functions]) => functions.length > 1).map(([pattern, functions]) => ({ pattern, functions }));
+  }
+  extractFunctionName(text) {
+    return text.match(/function\s+(\w+)/)?.[1] ?? null;
+  }
+  normalizeFunction(text) {
+    const normalizedText = text.replace(/function\s+\w+/, "function FN").replace(/\bconst\b|\blet\b|\bvar\b/g, "VAR").replace(/["'].*?["']/g, "STR").replace(/`[^`]*`/g, "TMPL").replace(/\b\d+\b/g, "NUM").replace(/\btrue\b|\bfalse\b/g, "BOOL").replace(/\/\/.*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
+    const bodyMatch = normalizedText.match(/\{(.*)\}/);
+    const body = bodyMatch ? bodyMatch[1].trim() : normalizedText;
+    return body.slice(0, 200);
+  }
+  async scanExports(dir, lang = "typescript") {
+    const exports = new Map;
+    const ruleYaml = `id: find-functions
+language: ${lang}
+rule:
+  kind: function_declaration
+severity: info
+message: found
+`;
+    const matches = await this.runTempScanAsync(dir, "find-functions", ruleYaml, 15000);
+    this.log(`scanExports output length: ${matches.length}`);
+    for (const item of matches) {
+      const text = item.text || "";
+      const nameMatch = text.match(/function\s+(\w+)/);
+      if (nameMatch?.[1]) {
+        this.log(`scanExports found: ${nameMatch[1]} in ${item.file}`);
+        exports.set(nameMatch[1], item.file);
+      }
+    }
+    return exports;
+  }
+  formatMatches(matches, isDryRun = false, showModeIndicator = false, maxItems = 50) {
+    return this.runner.formatMatches(matches, isDryRun, maxItems, showModeIndicator);
+  }
+  formatDiagnostics(diags) {
+    if (diags.length === 0)
+      return "";
+    const errors = diags.filter((d) => d.severity === "error");
+    const warnings = diags.filter((d) => d.severity === "warning");
+    const infos = diags.filter((d) => d.severity === "info");
+    const hints = diags.filter((d) => d.severity === "hint");
+    let output = `[ast-grep] ${diags.length} structural issue(s)`;
+    if (errors.length)
+      output += ` — ${errors.length} error(s)`;
+    if (warnings.length)
+      output += ` — ${warnings.length} warning(s)`;
+    if (infos.length)
+      output += ` — ${infos.length} info(s)`;
+    if (hints.length)
+      output += ` — ${hints.length} hint(s)`;
+    output += `:
+`;
+    for (const d of diags.slice(0, 10)) {
+      const loc = d.line === d.endLine ? `L${d.line}` : `L${d.line}-${d.endLine}`;
+      const ruleInfo = d.ruleDescription ? `${d.rule}: ${d.ruleDescription.message}` : d.rule;
+      const fix = d.fix || d.ruleDescription?.note ? " [fixable]" : "";
+      output += `  ${ruleInfo} (${loc})${fix}
+`;
+      if (d.ruleDescription?.note) {
+        const shortNote = d.ruleDescription.note.split(/\r?\n/)[0];
+        output += `    → ${shortNote}
+`;
+      }
+    }
+    if (diags.length > 10) {
+      output += `  ... and ${diags.length - 10} more
+`;
+    }
+    return output;
+  }
+  getRuleDescription(ruleId) {
+    return this.ruleManager.loadRuleDescriptions().get(ruleId);
+  }
+}

package/extensions/dm-lens/dist/clients/ast-grep-rule-manager.js

@@ -0,0 +1,114 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export function candidateAstGrepRulesPaths(ruleDir) {
+  return [
+    path.join(ruleDir, "ast-grep-rules", "rules"),
+    path.join(ruleDir, "rules"),
+    ruleDir
+  ];
+}
+export function checkAstGrepRulesHealth(ruleDir) {
+  const possiblePaths = candidateAstGrepRulesPaths(ruleDir);
+  let rulesPath;
+  for (const candidate of possiblePaths) {
+    if (fs.existsSync(candidate)) {
+      rulesPath = candidate;
+      break;
+    }
+  }
+  if (!rulesPath) {
+    try {
+      fs.readdirSync(ruleDir);
+    } catch (error) {
+      const fsErrorCode = error?.code;
+      if (fsErrorCode && fsErrorCode !== "ENOENT") {
+        return { status: "unreadable", fsErrorCode };
+      }
+    }
+    return { status: "absent" };
+  }
+  let entries;
+  try {
+    entries = fs.readdirSync(rulesPath).filter((f) => f.endsWith(".yml"));
+  } catch (error) {
+    const fsErrorCode = error?.code ?? "UNKNOWN";
+    return { status: "unreadable", fsErrorCode };
+  }
+  return entries.length > 0 ? { status: "healthy", entryCount: entries.length } : { status: "empty" };
+}
+
+export class AstGrepRuleManager {
+  ruleDir;
+  log;
+  ruleDescriptions = null;
+  constructor(ruleDir, log) {
+    this.ruleDir = ruleDir;
+    this.log = log;
+  }
+  loadRuleDescriptions() {
+    if (this.ruleDescriptions !== null)
+      return this.ruleDescriptions;
+    const descriptions = new Map;
+    const possiblePaths = candidateAstGrepRulesPaths(this.ruleDir);
+    const rulesPath = possiblePaths.find((p) => fs.existsSync(p));
+    if (!rulesPath) {
+      this.log(`Rule descriptions: no rules directory found in ${possiblePaths.join(", ")}`);
+      this.ruleDescriptions = descriptions;
+      return descriptions;
+    }
+    try {
+      const files = fs.readdirSync(rulesPath).filter((f) => f.endsWith(".yml"));
+      this.log(`Loaded ${files.length} rule descriptions from ${rulesPath}`);
+      for (const file of files) {
+        const filePath = path.join(rulesPath, file);
+        const content = fs.readFileSync(filePath, "utf-8");
+        const rule = this.parseRuleYaml(content);
+        if (rule) {
+          descriptions.set(rule.id, rule);
+        }
+      }
+    } catch (err) {
+      this.log(`Failed to load rule descriptions: ${err.message}`);
+    }
+    this.ruleDescriptions = descriptions;
+    return descriptions;
+  }
+  parseRuleYaml(content) {
+    const result = {};
+    const idMatch = content.match(/^id:\s*(.+)$/m);
+    if (idMatch)
+      result.id = idMatch[1].trim();
+    const msgMatch = content.match(/^message:\s*"([^"]+)"/m) || content.match(/^message:\s*'([^']+)'/m) || content.match(/^message:\s*(.+)$/m);
+    if (msgMatch)
+      result.message = (msgMatch[3] || msgMatch[2] || msgMatch[1]).trim();
+    const noteMatch = content.match(/^note:\s*\|([\s\S]*?)(?=^\w|\n\n|\nrule:)/m);
+    if (noteMatch) {
+      result.note = noteMatch[1].split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).join(" ");
+    }
+    const sevMatch = content.match(/^severity:\s*(.+)$/m);
+    if (sevMatch)
+      result.severity = this.mapSeverity(sevMatch[1].trim());
+    const gradeMatch = content.match(/Grade\s+(\d+\.\d+)/i);
+    if (gradeMatch)
+      result.grade = parseFloat(gradeMatch[1]);
+    const fixMatch = content.match(/^fix:\s*\|?([\s\S]*?)(?=^\w|^rule:|Z)/m);
+    if (fixMatch) {
+      result.fix = fixMatch[1].split(/\r?\n/).map((line) => line.replace(/^\s*\|?\s*/, "")).filter((line) => line.length > 0).join(`
+`);
+    }
+    if (result.id && result.message) {
+      return result;
+    }
+    return null;
+  }
+  mapSeverity(severity) {
+    const lower = severity.toLowerCase();
+    if (lower === "error")
+      return "error";
+    if (lower === "warning")
+      return "warning";
+    if (lower === "info")
+      return "info";
+    return "hint";
+  }
+}