@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

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

@@ -0,0 +1,587 @@
+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 { getUserRuleRoot } from "./custom-rule-locations.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 { normalizeFilePath } from "./path-utils.js";
+import { resolvePackagePath } from "./package-root.js";
+import { getAstGrepRuleFingerprint } from "./sgconfig.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, lineage, toolCallId) {
+  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: normalizeFilePath(path.resolve(process.cwd(), filePath)),
+      kind: "edit",
+      editRanges,
+      consumer: "ast_grep_replace",
+      provenance: "observed",
+      ...lineage && { lineage },
+      ...toolCallId !== undefined && { toolCallId }
+    });
+  }
+}
+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;
+}
+export function extractRuleLanguage(ruleYaml) {
+  return /^[^\S\n\r\u2028\u2029]*language:\s*([^\s#]+)/im.exec(ruleYaml)?.[1];
+}
+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(ruleDir ? this.ruleDir : [projectRuleDir, getUserRuleRoot(), this.ruleDir], this.log, () => getAstGrepRuleFingerprint(process.cwd()));
+    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, options) {
+    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);
+    }
+    if (apply)
+      recordAstGrepApply(allMatches, options?.lineage, options?.toolCallId);
+    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 = extractRuleLanguage(ruleYaml) ?? "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, options?.lineage, options?.toolCallId);
+    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);
+  }
+}