@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,576 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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";
-  }
-}