@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-lens/dist/clients/io-bridge.js

@@ -0,0 +1,357 @@
+import { judgeConfirmedDelete } from "./confirmed-delete.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { IO_BRIDGE_SYMBOL, IO_BRIDGE_VERSION } from "./io-bridge-contract.js";
+import { isValidRange, recordMutationOutcome } from "./mutation-bridge.js";
+import { captureReadContentBinding, deliveredLineEvidence } from "./read-guard.js";
+import { rebindableProcessBridgeDeps, registerProcessBridge } from "./process-bridge.js";
+
+export { IO_BRIDGE_SYMBOL, IO_BRIDGE_VERSION };
+export { getIOBridge } from "./io-bridge-contract.js";
+const DEFAULT_ACTIVATION = Symbol("dm-lens:io-bridge-activation");
+export function registerIOBridge(deps, activation = DEFAULT_ACTIVATION) {
+  const currentDeps = rebindableProcessBridgeDeps("io-bridge-deps", 1, activation, deps);
+  registerProcessBridge(IO_BRIDGE_SYMBOL, () => ({
+    version: IO_BRIDGE_VERSION,
+    record(entry) {
+      const liveDeps = currentDeps();
+      if (!liveDeps) {
+        deps.onUnavailable?.();
+        return {
+          read: { accepted: false, reason: "unavailable" },
+          mutate: { accepted: false, reason: "unavailable" }
+        };
+      }
+      return recordIOEntry(entry, liveDeps);
+    }
+  }));
+}
+function isRecordObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasFacet(raw, key) {
+  return raw[key] !== undefined;
+}
+function readConsumer(raw) {
+  const caller = raw["consumer"];
+  return typeof caller === "string" && caller !== "" ? caller : "unknown";
+}
+function readRangesProblem(ranges) {
+  if (!Array.isArray(ranges))
+    return "ranges must be an array";
+  if (!ranges.every(isValidRange)) {
+    return "ranges must be 1-indexed [start, end] with start <= end";
+  }
+  return;
+}
+function readEvidenceProblem(evidence) {
+  if (evidence === undefined || evidence === "caller" || evidence === "disk") {
+    return;
+  }
+  return 'evidence must be "caller" or "disk"';
+}
+function readContentProblem(content, declared) {
+  if (content === undefined)
+    return;
+  if (typeof content !== "string")
+    return "content must be a string";
+  const singleRange = declared.length === 1;
+  const explicitEmpty = declared.length === 0 && content === "";
+  if (!singleRange && !explicitEmpty) {
+    return "content is valid only with a single range";
+  }
+  return;
+}
+function readSourceProblem(source) {
+  if (source === undefined || typeof source === "string")
+    return;
+  return "source must be a string";
+}
+function readLineHashesProblem(lineHashes, declared) {
+  if (lineHashes === undefined)
+    return;
+  if (!isRecordObject(lineHashes) || Array.isArray(lineHashes)) {
+    return "lineHashes must be an object keyed by line number";
+  }
+  for (const [key, value] of Object.entries(lineHashes)) {
+    const line = Number(key);
+    if (!Number.isInteger(line) || line < 1 || typeof value !== "string") {
+      return `lineHashes[${key}] must map an integer line to a string hash`;
+    }
+    if (!declared.some(([start, end]) => line >= start && line <= end)) {
+      return `lineHashes key ${key} falls outside every declared range`;
+    }
+  }
+  return;
+}
+function readFacetProblem(read) {
+  if (!isRecordObject(read))
+    return "read facet must be an object";
+  const ranges = read["ranges"];
+  const rangesProblem = readRangesProblem(ranges);
+  if (rangesProblem !== undefined)
+    return rangesProblem;
+  const declared = ranges;
+  return readEvidenceProblem(read["evidence"]) ?? readContentProblem(read["content"], declared) ?? readSourceProblem(read["source"]) ?? readLineHashesProblem(read["lineHashes"], declared);
+}
+function drop(facet, caller, reason, detail) {
+  if (facet === "read") {
+    recordDegradationOnce({
+      kind: "io-bridge-read-dropped",
+      subject: `${caller}:${reason}`,
+      reason: detail
+    });
+  } else {
+    recordDegradationOnce({
+      kind: "io-bridge-mutate-dropped",
+      subject: `${caller}:${reason}`,
+      reason: detail
+    });
+  }
+  return { accepted: false, reason };
+}
+function selectLineHashes(read, start, end) {
+  const within = (hashes) => {
+    const picked = {};
+    for (const [key, value] of Object.entries(hashes)) {
+      const line = Number(key);
+      if (line >= start && line <= end)
+        picked[line] = value;
+    }
+    return picked;
+  };
+  if (read.lineHashes !== undefined)
+    return within(read.lineHashes);
+  if (read.content !== undefined) {
+    const derived = deliveredLineEvidence(read.content, start).lineHashes;
+    return derived === undefined ? undefined : within(derived);
+  }
+  return;
+}
+function recordOneRange(guard, args) {
+  guard.recordRead({
+    filePath: args.filePath,
+    requestedOffset: args.requestedOffset,
+    requestedLimit: args.requestedLimit,
+    effectiveOffset: args.effectiveOffset,
+    effectiveLimit: args.effectiveLimit,
+    expandedByLsp: false,
+    turnIndex: args.turnIndex,
+    writeIndex: args.writeIndex,
+    timestamp: Date.now(),
+    source: args.source,
+    ...args.lineHashes !== undefined && { lineHashes: args.lineHashes },
+    ...args.contentBinding !== undefined && {
+      contentBinding: args.contentBinding
+    }
+  }, {
+    captureLineHashes: args.captureLineHashes,
+    stampFileTime: args.wholeFile === true
+  });
+}
+function recordZeroLineRead(ctx) {
+  let size;
+  try {
+    size = ctx.deps.nodeFs.statSync(ctx.filePath).size;
+  } catch (err) {
+    return `${err}`;
+  }
+  if (size !== 0) {
+    return `zero-line read of a non-empty file (${size} bytes)`;
+  }
+  recordOneRange(ctx.guard, {
+    filePath: ctx.filePath,
+    requestedOffset: 1,
+    requestedLimit: 0,
+    effectiveOffset: 1,
+    effectiveLimit: Number.MAX_SAFE_INTEGER,
+    source: ctx.source,
+    turnIndex: ctx.turnIndex,
+    writeIndex: ctx.writeIndex,
+    captureLineHashes: false,
+    wholeFile: true
+  });
+  return;
+}
+function recordRange(ctx, start, end) {
+  const limit = end === Number.MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : end - start + 1;
+  const base = {
+    filePath: ctx.filePath,
+    requestedOffset: start,
+    requestedLimit: limit,
+    effectiveOffset: start,
+    effectiveLimit: limit,
+    source: ctx.source,
+    turnIndex: ctx.turnIndex,
+    writeIndex: ctx.writeIndex,
+    captureLineHashes: ctx.read.evidence === "disk"
+  };
+  if (ctx.read.evidence === "disk") {
+    if (!ctx.deps.nodeFs.existsSync(ctx.filePath)) {
+      return `disk read of an absent file: ${ctx.filePath}`;
+    }
+    const binding = captureReadContentBinding(ctx.filePath, start, limit);
+    recordOneRange(ctx.guard, {
+      ...base,
+      ...binding !== undefined && { contentBinding: binding },
+      wholeFile: binding?.fullFile === true && start === 1 && end >= binding.limit
+    });
+    return;
+  }
+  const hashes = selectLineHashes(ctx.read, start, end);
+  recordOneRange(ctx.guard, {
+    ...base,
+    ...hashes !== undefined && { lineHashes: hashes }
+  });
+  return;
+}
+function recordReadFacet(raw, caller, deps) {
+  const problem = readFacetProblem(raw["read"]);
+  if (problem !== undefined)
+    return drop("read", caller, "malformed", problem);
+  const read = raw["read"];
+  const filePath = raw["filePath"];
+  if (typeof filePath !== "string" || filePath === "") {
+    return drop("read", caller, "malformed", "filePath must be a non-empty string");
+  }
+  if (deps.getFlag("no-read-guard", "read")) {
+    return drop("read", caller, "no-read-guard", filePath);
+  }
+  if (!deps.isRecordable(filePath)) {
+    return drop("read", caller, "out-of-scope", filePath);
+  }
+  const ctx = {
+    read,
+    deps,
+    filePath,
+    source: read.source ?? `io-bridge:${caller}`,
+    guard: deps.getReadGuard(),
+    turnIndex: deps.getTurnIndex(),
+    writeIndex: deps.peekWriteIndex()
+  };
+  if (read.ranges.length === 0) {
+    const detail = recordZeroLineRead(ctx);
+    return detail === undefined ? { accepted: true } : drop("read", caller, "bookkeeping-error", detail);
+  }
+  for (const [start, end] of read.ranges) {
+    try {
+      const detail = recordRange(ctx, start, end);
+      if (detail !== undefined) {
+        return drop("read", caller, "bookkeeping-error", detail);
+      }
+    } catch (err) {
+      return drop("read", caller, "bookkeeping-error", `${err}`);
+    }
+  }
+  return { accepted: true };
+}
+function recordDeleteFacet(filePath, caller, deps) {
+  if (deps.getFlag("no-read-guard", "mutation")) {
+    return drop("mutate", caller, "no-read-guard", filePath);
+  }
+  const guard = deps.getReadGuard();
+  const verdict = judgeConfirmedDelete(filePath, {
+    isExternalOrVendorFile: (p) => deps.isExternalOrVendorFile(p),
+    isPathIgnoredByProject: (p) => deps.isPathIgnoredByProject(p),
+    hasKnownPath: (p) => guard.hasKnownPath(p),
+    existsSync: (p) => deps.nodeFs.existsSync(p)
+  });
+  if (verdict === "out-of-scope" || verdict === "ignored") {
+    return drop("mutate", caller, verdict, filePath);
+  }
+  if (verdict === "untracked" && !deps.nodeFs.existsSync(filePath)) {
+    return { accepted: true };
+  }
+  if (verdict !== "confirmed") {
+    return drop("mutate", caller, "bookkeeping-error", `delete confirmed for a file still on disk: ${filePath}`);
+  }
+  guard.forgetPath(filePath);
+  if (!deps.getFlag("no-lsp", "mutation")) {
+    try {
+      Promise.resolve(deps.notifyExternalFileChange(filePath, 3)).catch((err) => {
+        deps.dbg?.(`io_bridge: external-delete notify failed for ${filePath}: ${err}`);
+      });
+    } catch (err) {
+      deps.dbg?.(`io_bridge: external-delete notify threw for ${filePath}: ${err}`);
+    }
+  }
+  return { accepted: true };
+}
+const MUTATE_PASSTHROUGH_KEYS = [
+  "touchedLines",
+  "deferAutofix",
+  "importsChanged",
+  "provenance",
+  "readGuardBranchEpoch",
+  "lineage"
+];
+function recordMutateFacet(raw, caller, deps) {
+  const mutate = raw["mutate"];
+  if (!isRecordObject(mutate)) {
+    return drop("mutate", caller, "malformed", "mutate facet must be an object");
+  }
+  const kind = mutate["kind"];
+  const filePath = raw["filePath"];
+  if (typeof filePath !== "string" || filePath === "") {
+    return drop("mutate", caller, "malformed", "filePath must be a non-empty string");
+  }
+  if (kind === "delete")
+    return recordDeleteFacet(filePath, caller, deps);
+  const entry = { filePath, kind };
+  if (caller !== "unknown")
+    entry["consumer"] = caller;
+  if (kind === "edit" && mutate["ranges"] !== undefined) {
+    entry["editRanges"] = mutate["ranges"];
+  }
+  for (const key of MUTATE_PASSTHROUGH_KEYS) {
+    if (mutate[key] !== undefined)
+      entry[key] = mutate[key];
+  }
+  const outcome = recordMutationOutcome(entry, deps, {
+    rejectStaleLineage: true
+  });
+  if (!outcome.accepted) {
+    return drop("mutate", caller, outcome.reason ?? "bookkeeping-error", outcome.detail ?? filePath);
+  }
+  return { accepted: true };
+}
+function safeFacet(caller, facet, run) {
+  try {
+    return run();
+  } catch (err) {
+    return drop(facet, caller, "bookkeeping-error", `${err}`);
+  }
+}
+export function recordIOEntry(raw, deps) {
+  if (!isRecordObject(raw)) {
+    const detail = "entry must be an object";
+    return {
+      read: drop("read", "unknown", "malformed", detail),
+      mutate: drop("mutate", "unknown", "malformed", detail)
+    };
+  }
+  const caller = readConsumer(raw);
+  const hasRead = hasFacet(raw, "read");
+  const hasMutate = hasFacet(raw, "mutate");
+  if (!hasRead && !hasMutate) {
+    const detail = "entry carries no read or mutate facet";
+    return {
+      read: drop("read", caller, "malformed", detail),
+      mutate: drop("mutate", caller, "malformed", detail)
+    };
+  }
+  if (hasMutate && hasRead && isRecordObject(raw["mutate"]) && raw["mutate"]["kind"] === "delete") {
+    const detail = "delete cannot be combined with read";
+    return {
+      read: drop("read", caller, "malformed", detail),
+      mutate: drop("mutate", caller, "malformed", detail)
+    };
+  }
+  const result = {};
+  if (hasMutate) {
+    result.mutate = safeFacet(caller, "mutate", () => recordMutateFacet(raw, caller, deps));
+  }
+  if (hasRead) {
+    result.read = safeFacet(caller, "read", () => recordReadFacet(raw, caller, deps));
+  }
+  return result;
+}

package/extensions/dm-lens/dist/clients/jscpd-client.js

@@ -0,0 +1,300 @@
+import { formatToolFailure } from "./dispatch/runners/utils/tool-failure.js";
+import { createSubsystemLogger } from "./extension-log.js";
+import { incrementDegradationCount } from "./degradation-ledger.js";
+import * as fs from "node:fs";
+import { mkdtempSync } from "node:fs";
+import * as path from "node:path";
+import { getExcludedDirGlobs, getProjectIgnoreGlobs, getProjectIgnoreMatcher } from "./file-utils.js";
+import { findNodeToolBinary } from "./package-manager.js";
+import { isAtOrAboveHomeDir, isFullyQualified, toPosix } from "./path-utils.js";
+import { getJscpdMaxEntriesDerived } from "./project-scale.js";
+import { createAvailabilityChecker, findManagedNodeToolBinary, resolveAvailableOrInstall } from "./dispatch/runners/utils/runner-helpers.js";
+import { nestedWorktreeOffsets } from "./scratch-tree-policy.js";
+import { safeSpawnAsync } from "./safe-spawn.js";
+import { scannerReportParentDir } from "./scanner-temp-root.js";
+import { getIsolatedNpxSpawnOptions } from "./tool-probe.js";
+import { shouldRecurseIntoDir, walkTreeStackSync } from "./source-walker.js";
+const EMPTY_RESULT = {
+  success: false,
+  clones: [],
+  duplicatedLines: 0,
+  totalLines: 0,
+  percentage: 0
+};
+const SCAN_TIMEOUT_MS = 30000;
+const JSCPD_CONFIG_FILENAMES = [".jscpd.json", "jscpd.json"];
+function readProjectJscpdConfig(cwd) {
+  const fromObject = (config) => {
+    const list = config?.ignore;
+    if (list === undefined)
+      return { ignoreList: [] };
+    return Array.isArray(list) && list.every((e) => typeof e === "string") ? { ignoreList: list } : { ignoreList: null };
+  };
+  for (const name of JSCPD_CONFIG_FILENAMES) {
+    const file = path.join(cwd, name);
+    if (!fs.existsSync(file))
+      continue;
+    try {
+      return fromObject(JSON.parse(fs.readFileSync(file, "utf-8")));
+    } catch {
+      return { ignoreList: null };
+    }
+  }
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf-8"));
+    if (pkg && typeof pkg === "object" && pkg.jscpd !== undefined) {
+      return fromObject(pkg.jscpd);
+    }
+  } catch {}
+  return null;
+}
+function worktreeIgnoreGlobs(cwd) {
+  const globs = [];
+  for (const offset of nestedWorktreeOffsets(cwd)) {
+    const inside = toPosix(offset);
+    const unsafe = inside.includes(",") ? "comma-in-path" : /[*?[\]{}()!\\]/.test(inside) ? "glob-char-in-path" : null;
+    if (unsafe) {
+      incrementDegradationCount({
+        kind: "scan-worktree-exclusion-skipped",
+        subject: "jscpd",
+        reason: `${unsafe}: ${inside} not ignored under ${cwd}`
+      });
+      continue;
+    }
+    globs.push(`${inside}/**`);
+  }
+  return globs;
+}
+const jscpdAvailability = createAvailabilityChecker("jscpd", "", ["--version"], {
+  probeTimeout: 1500,
+  fastPath: () => findManagedNodeToolBinary("jscpd")
+});
+
+export class JscpdClient {
+  jscpdManagedPath = null;
+  inFlight = new Map;
+  log;
+  constructor(verbose = false) {
+    this.log = verbose ? createSubsystemLogger("jscpd") : () => {};
+  }
+  async shutdown() {
+    await Promise.allSettled(this.inFlight.values());
+  }
+  hasSourceFilesRecursive(rootDir) {
+    const ignoreMatcher = getProjectIgnoreMatcher(rootDir);
+    const state = { visited: 0 };
+    const MAX_ENTRIES = getJscpdMaxEntriesDerived(rootDir);
+    return walkTreeStackSync(rootDir, (entry, fullPath) => {
+      state.visited += 1;
+      if (entry.isSymbolicLink())
+        return "skip";
+      if (entry.isDirectory()) {
+        return shouldRecurseIntoDir(entry, fullPath, {
+          ignoreMatcher,
+          followSymlinks: true
+        }) ? "recurse" : "skip";
+      }
+      if (!entry.isFile())
+        return "skip";
+      if (/\.(ts|tsx|js|jsx|mjs|cjs|py|pyi|java|go|rs|rb|php|swift|kt|kts|dart|lua|scala|c|h|cpp|cc|cxx|hpp|hxx|cs|m|mm)$/.test(entry.name)) {
+        if (entry.name.endsWith(".d.ts"))
+          return "skip";
+        if (ignoreMatcher.isIgnored(fullPath, false))
+          return "skip";
+        return "stop";
+      }
+      return "skip";
+    }, { shouldStop: () => state.visited >= MAX_ENTRIES });
+  }
+  async ensureAvailable() {
+    const resolved = await resolveAvailableOrInstall(jscpdAvailability, "jscpd", process.cwd());
+    if (!resolved)
+      return false;
+    if (isFullyQualified(resolved))
+      this.jscpdManagedPath = resolved;
+    return true;
+  }
+  getAvailabilityVerdict() {
+    const verdict = jscpdAvailability.getVerdict(process.cwd());
+    return {
+      outcome: verdict.outcome,
+      cause: verdict.cause,
+      retryAtMs: verdict.retryAtMs
+    };
+  }
+  async scan(cwd, minLines = 5, minTokens = 50, isTsProject = false, options = {}) {
+    const targetDir = path.resolve(cwd);
+    if (isAtOrAboveHomeDir(targetDir, options.homeDir)) {
+      this.log(`Refusing scan of unsafe root at/above home: ${targetDir}`);
+      return { ...EMPTY_RESULT };
+    }
+    if (!fs.existsSync(targetDir)) {
+      return { ...EMPTY_RESULT };
+    }
+    if (!this.hasSourceFilesRecursive(targetDir)) {
+      return { ...EMPTY_RESULT, success: true };
+    }
+    if (!await this.ensureAvailable()) {
+      return { ...EMPTY_RESULT };
+    }
+    const key = `${targetDir}:${minLines}:${minTokens}:${isTsProject}`;
+    const existing = this.inFlight.get(key);
+    if (existing) {
+      this.log(`Scan already in flight for ${targetDir}; sharing result`);
+      return existing;
+    }
+    const promise = this.runScan(targetDir, minLines, minTokens, isTsProject).finally(() => {
+      if (this.inFlight.get(key) === promise)
+        this.inFlight.delete(key);
+    });
+    this.inFlight.set(key, promise);
+    return promise;
+  }
+  async runScan(cwd, minLines, minTokens, isTsProject) {
+    const scannedAt = new Date().toISOString();
+    const outDir = mkdtempSync(path.join(scannerReportParentDir(), "dm-lens-jscpd-"));
+    try {
+      const baseIgnores = [
+        ...getExcludedDirGlobs(),
+        ...getProjectIgnoreGlobs(cwd),
+        "**/*.md",
+        "**/*.txt",
+        "**/*.json",
+        "**/*.yaml",
+        "**/*.yml",
+        "**/*.toml",
+        "**/*.lock",
+        "**/*.test.*",
+        "**/*.spec.*",
+        "**/*.poc.test.*",
+        "**/__tests__/**",
+        "**/tests/**"
+      ];
+      if (isTsProject) {
+        baseIgnores.push("**/*.js", "**/*.jsx");
+      }
+      const bin = await findNodeToolBinary("jscpd", cwd);
+      const { cmd, prefix } = bin ? { cmd: bin, prefix: [] } : this.jscpdManagedPath ? { cmd: this.jscpdManagedPath, prefix: [] } : { cmd: "npx", prefix: ["jscpd"] };
+      const config = readProjectJscpdConfig(cwd);
+      const worktreeGlobs = worktreeIgnoreGlobs(cwd);
+      let patterns;
+      if (config === null) {
+        patterns = [...baseIgnores, ...worktreeGlobs];
+      } else if (worktreeGlobs.length > 0) {
+        if (config.ignoreList === null) {
+          incrementDegradationCount({
+            kind: "scan-worktree-exclusion-skipped",
+            subject: "jscpd",
+            reason: `config-ignore-unreadable: ${worktreeGlobs.length} linked worktree(s) under ${cwd} not ignored`
+          });
+        } else {
+          patterns = [...config.ignoreList, ...worktreeGlobs];
+        }
+      }
+      const result = await safeSpawnAsync(cmd, [
+        ...prefix,
+        ".",
+        ...config === null ? [
+          "--min-lines",
+          String(minLines),
+          "--min-tokens",
+          String(minTokens)
+        ] : [],
+        "--reporters",
+        "json",
+        "--output",
+        outDir,
+        ...patterns === undefined ? [] : ["--ignore", patterns.join(",")]
+      ], {
+        timeout: SCAN_TIMEOUT_MS,
+        cwd,
+        ...cmd === "npx" ? getIsolatedNpxSpawnOptions() : {}
+      });
+      if (result.error) {
+        this.log(`Scan error: ${result.error.message}`);
+        return { ...EMPTY_RESULT };
+      }
+      const reportPath = path.join(outDir, "jscpd-report.json");
+      if (!fs.existsSync(reportPath)) {
+        if (result.status !== 0) {
+          const reason = formatToolFailure({
+            tool: "jscpd",
+            status: result.status,
+            signal: result.signal,
+            stderr: result.stderr,
+            reportMissing: true,
+            fields: { command: cmd }
+          });
+          this.log(reason);
+          incrementDegradationCount({
+            kind: "runner-empty-result",
+            subject: "jscpd",
+            reason
+          });
+          return { ...EMPTY_RESULT };
+        }
+        return { ...EMPTY_RESULT, success: true };
+      }
+      return { ...this.parseReport(reportPath), scannedAt };
+    } catch (err) {
+      this.log(`Scan error: ${err.message}`);
+      return { ...EMPTY_RESULT };
+    } finally {
+      try {
+        fs.rmSync(outDir, { recursive: true, force: true });
+      } catch (err) {}
+    }
+  }
+  formatResult(result, maxClones = 8) {
+    if (!result.success || result.clones.length === 0)
+      return "";
+    const pct = result.percentage.toFixed(1);
+    let output = `[jscpd] ${result.clones.length} duplicate block(s) — ${pct}% of codebase (${result.duplicatedLines}/${result.totalLines} lines):
+`;
+    for (const clone of result.clones.slice(0, maxClones)) {
+      const a = `${path.basename(clone.fileA)}:${clone.startA}`;
+      const b = `${path.basename(clone.fileB)}:${clone.startB}`;
+      output += `  ${clone.lines} lines — ${a} ↔ ${b}
+`;
+    }
+    if (result.clones.length > maxClones) {
+      output += `  ... and ${result.clones.length - maxClones} more
+`;
+    }
+    return output;
+  }
+  parseReport(reportPath) {
+    try {
+      const data = JSON.parse(fs.readFileSync(reportPath, "utf-8"));
+      const total = data.statistics?.total ?? {};
+      const duplicatedLines = total.duplicatedLines ?? 0;
+      const totalLines = total.lines ?? 0;
+      const percentage = total.percentage ?? (totalLines > 0 ? duplicatedLines / totalLines * 100 : 0);
+      const rawClones = data.duplicates ?? [];
+      const clones = rawClones.map((c) => ({
+        fileA: c.firstFile?.name ?? "",
+        startA: c.firstFile?.start ?? 0,
+        fileB: c.secondFile?.name ?? "",
+        startB: c.secondFile?.start ?? 0,
+        lines: c.lines ?? 0,
+        tokens: c.tokens ?? 0
+      }));
+      return {
+        success: true,
+        analyzed: true,
+        clones,
+        duplicatedLines,
+        totalLines,
+        percentage
+      };
+    } catch (err) {
+      return {
+        success: false,
+        clones: [],
+        duplicatedLines: 0,
+        totalLines: 0,
+        percentage: 0
+      };
+    }
+  }
+}

package/extensions/dm-lens/dist/clients/json-cache-read.js

@@ -0,0 +1,25 @@
+import * as fs from "node:fs";
+import { promises as fsPromises } from "node:fs";
+export function readJsonCache(path, validate, onError) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(path, "utf-8"));
+    return validate(parsed);
+  } catch (err) {
+    try {
+      onError?.(err);
+    } catch {}
+    return;
+  }
+}
+export async function readJsonCacheAsync(path, validate, onError) {
+  try {
+    const raw = await fsPromises.readFile(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    return validate(parsed);
+  } catch (err) {
+    try {
+      onError?.(err);
+    } catch {}
+    return;
+  }
+}