@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-lens/dist/clients/host-edit-normalize.js

@@ -0,0 +1,87 @@
+export const HOST_EDIT_DIFF_SDK_FLOOR = "0.85.1";
+export const HOST_SMART_SINGLE_QUOTES = [8216, 8217, 8218, 8219];
+export const HOST_SMART_DOUBLE_QUOTES = [8220, 8221, 8222, 8223];
+export const HOST_UNICODE_DASHES = [
+  8208,
+  8209,
+  8210,
+  8211,
+  8212,
+  8213,
+  8722
+];
+export const HOST_SPECIAL_SPACES = [
+  160,
+  8194,
+  8195,
+  8196,
+  8197,
+  8198,
+  8199,
+  8200,
+  8201,
+  8202,
+  8239,
+  8287,
+  12288
+];
+export const HOST_BOM_CODE_POINT = 65279;
+const charClass = (codePoints) => new RegExp(`[${String.fromCharCode(...codePoints)}]`, "g");
+const SMART_SINGLE_QUOTES_RE = charClass(HOST_SMART_SINGLE_QUOTES);
+const SMART_DOUBLE_QUOTES_RE = charClass(HOST_SMART_DOUBLE_QUOTES);
+const UNICODE_DASHES_RE = charClass(HOST_UNICODE_DASHES);
+const SPECIAL_SPACES_RE = charClass(HOST_SPECIAL_SPACES);
+const BOM = String.fromCharCode(HOST_BOM_CODE_POINT);
+export function detectLineEnding(content) {
+  const crlfIdx = content.indexOf(`\r
+`);
+  const lfIdx = content.indexOf(`
+`);
+  if (lfIdx === -1)
+    return `
+`;
+  if (crlfIdx === -1)
+    return `
+`;
+  return crlfIdx < lfIdx ? `\r
+` : `
+`;
+}
+export function normalizeToLF(text) {
+  return text.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+}
+export function restoreLineEndings(text, ending) {
+  return ending === `\r
+` ? text.replace(/\n/g, `\r
+`) : text;
+}
+export function normalizeForFuzzyMatch(text) {
+  return text.normalize("NFKC").split(`
+`).map((line) => line.trimEnd()).join(`
+`).replace(SMART_SINGLE_QUOTES_RE, "'").replace(SMART_DOUBLE_QUOTES_RE, '"').replace(UNICODE_DASHES_RE, "-").replace(SPECIAL_SPACES_RE, " ");
+}
+export function stripBom(content) {
+  return content.startsWith(BOM) ? { bom: BOM, text: content.slice(1) } : { bom: "", text: content };
+}
+export function normalizeForGuardMatch(text) {
+  return normalizeForFuzzyMatch(normalizeToLF(stripBom(text).text));
+}
+export function hostWouldApplyOldText(content, oldText) {
+  const c = normalizeToLF(stripBom(content).text);
+  const o = normalizeToLF(stripBom(oldText).text);
+  if (o.length === 0) {
+    return { wouldApply: false, occurrences: 0, usedFuzzyMatch: false };
+  }
+  const exactFound = c.indexOf(o) !== -1;
+  const fuzzyContent = normalizeForFuzzyMatch(c);
+  const fuzzyOldText = normalizeForFuzzyMatch(o);
+  const fuzzyFound = fuzzyContent.indexOf(fuzzyOldText) !== -1;
+  const occurrences = fuzzyOldText.length === 0 ? 0 : fuzzyContent.split(fuzzyOldText).length - 1;
+  return {
+    wouldApply: (exactFound || fuzzyFound) && occurrences === 1,
+    occurrences,
+    usedFuzzyMatch: !exactFound && fuzzyFound
+  };
+}

package/extensions/dm-lens/dist/clients/host-ports.js

@@ -0,0 +1,35 @@
+export function createDefaultHostPorts(overrides = {}) {
+  const unknownMode = () => "unknown";
+  const defaults = {
+    notify: { user: () => {} },
+    trust: { isProjectTrusted: () => "unknown" },
+    mode: {
+      current: unknownMode,
+      supportsTuiWidget: () => true,
+      suppressesUserNotify: () => false
+    },
+    log: { extension: () => {}, debug: () => {}, sink: () => () => {} },
+    emit: { bus: () => {} },
+    status: { set: () => {} },
+    spawn: { abortSignal: () => {
+      return;
+    }, isAllowed: () => true },
+    render: { invalidate: () => {} },
+    session: { id: () => {
+      return;
+    } },
+    workspace: { cwd: () => {
+      return;
+    }, projectRoot: () => {
+      return;
+    } },
+    flags: { get: () => {
+      return;
+    } },
+    tools: { has: async () => false, getActive: () => [], setActive: () => {} }
+  };
+  return Object.fromEntries(Object.entries(defaults).map(([group, value]) => [
+    group,
+    { ...value, ...overrides[group] }
+  ]));
+}

package/extensions/dm-lens/dist/clients/indent-retarget.js

@@ -0,0 +1,102 @@
+import { blockCommentInteriorMask, templateLiteralInteriorMask } from "./dispatch/indent-detect.js";
+function computeInteriorMasks(oldLines, fileContext) {
+  if (fileContext) {
+    const fileLines = fileContext.content.replace(/\r\n/g, `
+`).split(`
+`);
+    const start = fileContext.startLine - 1;
+    const end = start + oldLines.length;
+    if (start >= 0 && end <= fileLines.length) {
+      return {
+        commentInterior: blockCommentInteriorMask(fileLines).slice(start, end),
+        templateInterior: templateLiteralInteriorMask(fileLines).slice(start, end)
+      };
+    }
+  }
+  return {
+    commentInterior: blockCommentInteriorMask(oldLines),
+    templateInterior: templateLiteralInteriorMask(oldLines)
+  };
+}
+export function retargetReplacementIndentation(newText, oldText, correctedOldText, fileContext) {
+  const newline = newText.includes(`\r
+`) ? `\r
+` : `
+`;
+  const oldLines = oldText.replace(/\r\n/g, `
+`).split(`
+`);
+  const correctedLines = correctedOldText.replace(/\r\n/g, `
+`).split(`
+`);
+  if (oldLines.length !== correctedLines.length)
+    return;
+  const { commentInterior, templateInterior } = computeInteriorMasks(oldLines, fileContext);
+  const indentMap = new Map;
+  const structuralIndents = new Set;
+  const ambiguousIndents = new Set;
+  for (const [i, oldLine] of oldLines.entries()) {
+    const correctedLine = correctedLines[i] ?? "";
+    const oldIndent = oldLine.match(/^[\t ]*/)?.[0] ?? "";
+    const correctedIndent = correctedLine.match(/^[\t ]*/)?.[0] ?? "";
+    if (oldIndent === correctedIndent)
+      continue;
+    const previous = indentMap.get(oldIndent);
+    if (previous !== undefined && previous !== correctedIndent) {
+      indentMap.delete(oldIndent);
+      structuralIndents.delete(oldIndent);
+      ambiguousIndents.add(oldIndent);
+      continue;
+    }
+    if (!ambiguousIndents.has(oldIndent)) {
+      indentMap.set(oldIndent, correctedIndent);
+      if (!commentInterior[i] && !templateInterior[i]) {
+        structuralIndents.add(oldIndent);
+      }
+    }
+  }
+  if (indentMap.size === 0)
+    return;
+  let baseFrom = "";
+  let baseTo = "";
+  for (const [from, to] of indentMap) {
+    if (from.length > 0 && structuralIndents.has(from) && (baseFrom === "" || from.length < baseFrom.length)) {
+      baseFrom = from;
+      baseTo = to;
+    }
+  }
+  function resolveIndent(indent) {
+    if (indent === "")
+      return "";
+    const direct = indentMap.get(indent);
+    if (direct !== undefined)
+      return direct;
+    if (baseFrom.length > 0 && indent.length % baseFrom.length === 0 && baseFrom.repeat(indent.length / baseFrom.length) === indent) {
+      return baseTo.repeat(indent.length / baseFrom.length);
+    }
+    return;
+  }
+  let changed = false;
+  const newLines = newText.replace(/\r\n/g, `
+`).split(`
+`);
+  const retargetedLines = [];
+  for (const line of newLines) {
+    const indent = line.match(/^[\t ]*/)?.[0] ?? "";
+    if (indent === line) {
+      retargetedLines.push(line);
+      continue;
+    }
+    const resolved = resolveIndent(indent);
+    if (resolved === undefined) {
+      return;
+    }
+    if (resolved !== indent) {
+      changed = true;
+      retargetedLines.push(resolved + line.slice(indent.length));
+    } else {
+      retargetedLines.push(line);
+    }
+  }
+  return changed ? retargetedLines.join(newline) : undefined;
+}

package/extensions/dm-lens/dist/clients/inline-blocker-dispositions.js

@@ -0,0 +1,103 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { hasAnyDispositionMarks } from "./diagnostic-dispositions.js";
+import { applyFindingPolicy, inlineBlockerIdentities, loadProjectRulePolicyMap } from "./dispatch/finding-policy.js";
+import { toRunnerDisplayPath } from "./dispatch/runner-context.js";
+import { formatDiagnostics } from "./dispatch/utils/format-utils.js";
+function readCurrentContent(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+export function applyInlineBlockerPolicy(record, cwd) {
+  const diagnostics = record.diagnostics;
+  if (!diagnostics || diagnostics.length === 0) {
+    if (hasAnyDispositionMarks(cwd)) {
+      recordDegradationOnce({
+        kind: "inline-blocker-unstructured",
+        subject: `inline-blocker:${toRunnerDisplayPath(cwd, record.filePath)}`,
+        reason: "record carries no structured diagnostics; disposition marks cannot be applied to its rendered summary"
+      });
+    }
+    return {
+      body: record.summary,
+      candidates: 0,
+      kept: 0,
+      suppressed: 0,
+      unstructured: true
+    };
+  }
+  const byFile = new Map;
+  for (const diagnostic of diagnostics) {
+    const owner = path.resolve(cwd, diagnostic.filePath);
+    const group = byFile.get(owner);
+    if (group)
+      group.push(diagnostic);
+    else
+      byFile.set(owner, [diagnostic]);
+  }
+  const policyMap = loadProjectRulePolicyMap(cwd);
+  const dropped = new Set;
+  for (const [filePath, group] of byFile) {
+    const { kept } = applyFindingPolicy(group, {
+      cwd,
+      filePath,
+      content: readCurrentContent(filePath),
+      policyMap,
+      identities: inlineBlockerIdentities
+    });
+    const survivors = new Set(kept);
+    for (const diagnostic of group) {
+      if (!survivors.has(diagnostic))
+        dropped.add(diagnostic);
+    }
+  }
+  const kept = dropped.size === 0 ? [...diagnostics] : diagnostics.filter((diagnostic) => !dropped.has(diagnostic));
+  return {
+    body: kept.length === 0 ? undefined : formatDiagnostics(kept, "blocking").trim(),
+    candidates: diagnostics.length,
+    kept: kept.length,
+    suppressed: dropped.size,
+    unstructured: false
+  };
+}
+const IDENTITY_CAP = 10;
+export function summarizeInlineBlockerPolicy(entries) {
+  const files = [];
+  const tools = new Set;
+  let stale = 0;
+  let candidates = 0;
+  let kept = 0;
+  let suppressed = 0;
+  let unstructured = 0;
+  for (const entry of entries) {
+    for (const tool of entry.sources ?? [])
+      tools.add(tool);
+    if (entry.stale)
+      stale += 1;
+    const outcome = entry.outcome;
+    if (outcome === undefined)
+      continue;
+    candidates += outcome.candidates;
+    kept += outcome.kept;
+    suppressed += outcome.suppressed;
+    if (outcome.unstructured)
+      unstructured += 1;
+    if (outcome.suppressed > 0 && files.length < IDENTITY_CAP) {
+      files.push(entry.displayPath);
+    }
+  }
+  return {
+    records: entries.length,
+    stale,
+    candidates,
+    kept,
+    dispositionSuppressed: suppressed,
+    unstructured,
+    files,
+    tools: [...tools].slice(0, IDENTITY_CAP)
+  };
+}

package/extensions/dm-lens/dist/clients/inline-blocker-fields.js

@@ -0,0 +1,8 @@
+import { normalizeEphemeralMapKey } from "./path-utils.js";
+export function inlineBlockerSources(blockers) {
+  return [...new Set(blockers.map((d) => d.tool?.trim() || "unknown"))];
+}
+export function inlineBlockerLines(blockers, filePath) {
+  const own = normalizeEphemeralMapKey(filePath);
+  return blockers.filter((d) => normalizeEphemeralMapKey(d.filePath) === own).map((d) => d.line).filter((line) => typeof line === "number");
+}

package/extensions/dm-lens/dist/clients/install-diagnostics.js

@@ -0,0 +1,135 @@
+import { createRequire } from "node:module";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { findCoreGrammarDir, resolveWebTreeSitterPackageDir } from "../scripts/lib/web-tree-sitter-dir.mjs";
+const require = createRequire(import.meta.url);
+const ISSUES_URL = "https://github.com/DuckMind/extensions/issues";
+const CRITICAL_DEPS = [
+  "typescript",
+  "minimatch",
+  "typebox",
+  "js-yaml",
+  "vscode-jsonrpc",
+  "web-tree-sitter",
+  "@ast-grep/napi"
+];
+function safe(fn, fallback) {
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+}
+export function grammarsInstalled(deps) {
+  return findCoreGrammarDir({
+    packageRoot: deps.packageRoot(),
+    webTreeSitterDir: resolveWebTreeSitterPackageDir(deps)
+  }) !== undefined;
+}
+export function installDiagnosticNotes(input) {
+  const notes = [];
+  if (input.depsUnresolved) {
+    notes.push("One or more runtime dependencies did not resolve. This is the #285/#335 failure mode — a package-manager layout (pnpm symlink store / nested install) the runtime's resolver can't traverse, an outdated runtime, or a runtime compiled into a single binary (`bun build --compile`, the way pi ships), where a bare package specifier cannot resolve whatever the layout is (#3409).");
+  }
+  if (!input.astGrepCli || !input.grammars) {
+    notes.push("ast-grep CLI and/or tree-sitter grammars are missing — pnpm/bun skip lifecycle scripts by default, so the postinstall that fetches them did not run.");
+  }
+  return notes;
+}
+export function collectInstallDiagnostics() {
+  const notes = [];
+  const here = safe(() => path.dirname(fileURLToPath(import.meta.url)), "");
+  const pkgDir = safe(() => path.resolve(here, ".."), here);
+  let root = pkgDir;
+  for (let i = 0;i < 6; i++) {
+    if (safe(() => fs.existsSync(path.join(root, "package.json")), false))
+      break;
+    const up = path.dirname(root);
+    if (up === root)
+      break;
+    root = up;
+  }
+  const piLensVersion = safe(() => {
+    const pj = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+    return String(pj.version ?? "unknown");
+  }, "unknown");
+  const bunVersion = globalThis.Bun?.version;
+  const runtime = bunVersion ? `bun ${bunVersion}` : `node ${process.versions.node}`;
+  const platform = `${process.platform}-${process.arch}`;
+  const pkgRealDir = safe(() => fs.realpathSync(root), root);
+  const behindSymlink = pkgRealDir !== root;
+  let packageManager = "unknown";
+  if (pkgRealDir.includes(`${path.sep}.pnpm${path.sep}`) || behindSymlink) {
+    packageManager = "pnpm-symlinked";
+  } else if (safe(() => fs.existsSync(path.join(root, "node_modules", "typescript")), false)) {
+    packageManager = "nested";
+  } else {
+    packageManager = "npm-hoisted";
+  }
+  const deps = CRITICAL_DEPS.map((name) => {
+    try {
+      return { name, resolved: true, resolvedPath: require.resolve(name) };
+    } catch (err) {
+      return {
+        name,
+        resolved: false,
+        error: `${err?.code ?? ""} ${err?.message ?? String(err)}`.trim()
+      };
+    }
+  });
+  const astGrepCli = safe(() => {
+    const cliPkg = require.resolve("@ast-grep/cli/package.json");
+    const dir = path.dirname(cliPkg);
+    return ["ast-grep", "ast-grep.exe", "sg", "sg.exe"].some((b) => fs.existsSync(path.join(dir, b)));
+  }, false);
+  const grammars = safe(() => grammarsInstalled({
+    resolve: (specifier) => require.resolve(specifier),
+    packageRoot: () => root,
+    cwd: () => process.cwd()
+  }), false);
+  notes.push(...installDiagnosticNotes({
+    depsUnresolved: deps.some((d) => !d.resolved),
+    astGrepCli,
+    grammars
+  }));
+  return {
+    piLensVersion,
+    runtime,
+    platform,
+    packageManager,
+    pkgDir: root,
+    pkgRealDir,
+    behindSymlink,
+    deps,
+    astGrepCli,
+    grammars,
+    notes
+  };
+}
+export function formatInstallDiagnostics(diag = collectInstallDiagnostics(), cause) {
+  const lines = [];
+  lines.push("──────── dm-lens install diagnostics ────────");
+  if (cause) {
+    const msg = cause?.message ?? String(cause);
+    lines.push(`LOAD ERROR: ${msg}`);
+  }
+  lines.push(`dm-lens:   ${diag.piLensVersion}`);
+  lines.push(`runtime:   ${diag.runtime}`);
+  lines.push(`platform:  ${diag.platform}`);
+  lines.push(`install:   ${diag.packageManager}${diag.behindSymlink ? " (behind symlink)" : ""}`);
+  lines.push(`pkg dir:   ${diag.pkgDir}`);
+  if (diag.behindSymlink)
+    lines.push(`real dir:  ${diag.pkgRealDir}`);
+  lines.push("deps:");
+  for (const d of diag.deps) {
+    lines.push(`  ${d.resolved ? "ok  " : "FAIL"} ${d.name}${d.error ? ` — ${d.error}` : ""}`);
+  }
+  lines.push(`assets:    ast-grep-cli=${diag.astGrepCli ? "ok" : "MISSING"} grammars=${diag.grammars ? "ok" : "MISSING"}`);
+  for (const n of diag.notes)
+    lines.push(`note: ${n}`);
+  lines.push(`Please paste this into a report at ${ISSUES_URL}`);
+  lines.push("─────────────────────────────────────────────");
+  return lines.join(`
+`);
+}