@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/dist/clients/test-runner-delivery.js

@@ -0,0 +1,293 @@
+import { emitBounded } from "./bounded-telemetry.js";
+import { boundDeferredTargets, mergeDeferredTargets, TEST_RUNNER_MAX_PERSISTED_TARGETS } from "./deferred-test-targets.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { logLatency } from "./latency-logger.js";
+import { consumeTestFindings, peekTestFindings } from "./runtime-context.js";
+const MAX_PENDING_DELIVERIES = 32;
+const pending = new Map;
+function staleVerdictNotice(stale) {
+  return stale.map((entry) => `verdict for an older version of ${entry.sourceFile} (${entry.gap} edit${entry.gap === 1 ? "" : "s"} ago); ${entry.runner ? "re-running" : "re-run manually"}`).join(`
+`);
+}
+function settleDeliveredVerdicts(cacheManager, cwd, runtime, delivery) {
+  const data = cacheManager.readCache("test-runner-findings", cwd)?.data;
+  let knownCount = 0;
+  let unknownCount = 0;
+  const stale = [];
+  for (const verdict of data?.verdicts ?? []) {
+    const evidence = verdict.fileSeq ?? {
+      state: "unknown",
+      reason: "legacy-cache-record"
+    };
+    if (evidence.state === "unknown") {
+      unknownCount += 1;
+      recordDegradationOnce({
+        kind: "test-runner-delivery",
+        subject: `${delivery.sessionId}:${verdict.sourceFile}`,
+        reason: `missing file sequence evidence (${evidence.reason})`
+      });
+      continue;
+    }
+    knownCount += 1;
+    const currentFileSeq = runtime.getFileSeq(verdict.sourceFile);
+    if (currentFileSeq <= evidence.value)
+      continue;
+    stale.push({
+      file: verdict.file,
+      sourceFile: verdict.sourceFile,
+      runner: verdict.runner,
+      gap: currentFileSeq - evidence.value
+    });
+  }
+  if (knownCount === 0 && unknownCount === 0)
+    return;
+  const rerunEntries = [];
+  for (const entry of stale) {
+    if (!entry.runner)
+      continue;
+    rerunEntries.push({
+      testFile: entry.file,
+      sourceFile: entry.sourceFile,
+      runner: entry.runner,
+      attempts: 0,
+      sessionId: delivery.sessionId
+    });
+  }
+  if (data && stale.length > 0) {
+    cacheManager.writeCache("test-runner-findings", {
+      ...data,
+      content: `${staleVerdictNotice(stale)}
+${data.content}`,
+      deferredTargets: boundDeferredTargets(mergeDeferredTargets(data.deferredTargets ?? [], rerunEntries), TEST_RUNNER_MAX_PERSISTED_TARGETS, (entry) => entry.sessionId === delivery.sessionId)
+    }, cwd);
+  }
+  logLatency({
+    type: "phase",
+    phase: "test_runner_verdict_delivery",
+    filePath: cwd,
+    durationMs: 0,
+    metadata: {
+      sessionId: delivery.sessionId,
+      generation: delivery.generation,
+      verdictCount: knownCount,
+      staleCount: stale.length,
+      unknownCount,
+      staleGaps: stale.map((entry) => entry.gap).slice(0, 32),
+      rerunQueued: rerunEntries.length
+    }
+  });
+}
+function key(cwd, sessionId, ownerId) {
+  return `${ownerId ?? "direct"}\x00${cwd}\x00${sessionId}`;
+}
+function record(identity, outcome, delivery, metadata = {}) {
+  emitBounded("test_runner_delivery", identity, {
+    filePath: delivery.cwd,
+    durationMs: 0,
+    metadata: {
+      outcome,
+      sessionId: delivery.sessionId,
+      generation: delivery.generation,
+      targetCount: delivery.targetCount,
+      deliveryBoundary: "agent_settled",
+      ownership: "pi",
+      droppedDetailCount: 0,
+      ...metadata
+    }
+  }, {
+    capPerTurn: { limit: 8, turnIndex: delivery.generation },
+    ledgerKind: outcome === "delivery-failed" ? "test-runner-delivery" : undefined,
+    reason: `test runner delivery ${outcome}`
+  });
+}
+function prunePending() {
+  while (pending.size > MAX_PENDING_DELIVERIES) {
+    const oldest = pending.keys().next();
+    if (oldest.done)
+      return;
+    pending.delete(oldest.value);
+  }
+}
+export function stageTestRunnerDelivery(args) {
+  const deliveryKey = key(args.cwd, args.sessionId, args.owner?.ownerId);
+  const prior = pending.get(deliveryKey);
+  if (prior && prior.generation > args.generation) {
+    const superseded = {
+      cwd: args.cwd,
+      sessionId: args.sessionId,
+      ownerId: args.owner?.ownerId,
+      generation: args.generation,
+      targetCount: args.targetCount,
+      createdAt: Date.now(),
+      eligible: false,
+      owner: args.owner
+    };
+    record(deliveryKey, "superseded", superseded, {
+      currentGeneration: prior.generation
+    });
+    return;
+  }
+  if (!args.hasFindings) {
+    if (prior) {
+      pending.delete(deliveryKey);
+      record(deliveryKey, "superseded", {
+        ...prior,
+        targetCount: args.targetCount,
+        generation: args.generation
+      });
+    }
+    return;
+  }
+  const delivery = {
+    cwd: args.cwd,
+    sessionId: args.sessionId,
+    ownerId: args.owner?.ownerId,
+    generation: args.generation,
+    targetCount: args.targetCount,
+    createdAt: Date.now(),
+    eligible: false,
+    owner: args.owner
+  };
+  pending.set(deliveryKey, delivery);
+  prunePending();
+  record(deliveryKey, "staged", delivery);
+}
+export function deliverTestRunnerFindings(args) {
+  const cwd = args.ctx.cwd ?? process.cwd();
+  const deliveryKey = key(cwd, args.sessionId, args.ownerId);
+  const delivery = pending.get(deliveryKey);
+  if (!delivery)
+    return;
+  const currentGeneration = args.cacheManager.readCache("test-runner-findings", cwd)?.data?.testRunGeneration;
+  if (currentGeneration !== undefined && currentGeneration > delivery.generation) {
+    pending.delete(deliveryKey);
+    record(deliveryKey, "superseded", delivery, { currentGeneration });
+    return;
+  }
+  if (typeof args.ctx.isIdle !== "function") {
+    pending.delete(deliveryKey);
+    return;
+  }
+  try {
+    if (!args.ctx.isIdle()) {
+      record(deliveryKey, "carried", delivery);
+      return;
+    }
+  } catch (error) {
+    record(deliveryKey, "delivery-failed", delivery, {
+      error: String(error).slice(0, 500)
+    });
+    return;
+  }
+  if (!peekTestFindings(args.cacheManager, cwd, args.runtime, true)) {
+    pending.delete(deliveryKey);
+    record(deliveryKey, "superseded", delivery);
+    return;
+  }
+  try {
+    if (!args.ctx.isIdle()) {
+      record(deliveryKey, "carried", delivery);
+      return;
+    }
+  } catch (error) {
+    record(deliveryKey, "delivery-failed", delivery, {
+      error: String(error).slice(0, 500)
+    });
+    return;
+  }
+  delivery.eligible = true;
+  const current = args.cacheManager.readCache("test-runner-findings", cwd)?.data;
+  if (!current?.content || current.testRunGeneration !== delivery.generation) {
+    pending.delete(deliveryKey);
+    return;
+  }
+  args.cacheManager.writeCache("test-runner-findings", {
+    ...current,
+    deliveryEligible: {
+      sessionId: delivery.sessionId,
+      generation: delivery.generation,
+      eligibleAt: Date.now()
+    }
+  }, cwd);
+  record(deliveryKey, "eligible", delivery, {
+    ageMs: Math.max(0, Date.now() - delivery.createdAt)
+  });
+}
+export function deliverStagedTestRunnerFindings(args) {
+  if (!args?.cwd || !args.ownerId)
+    return;
+  const delivery = args.sessionId ? pending.get(key(args.cwd, args.sessionId, args.ownerId)) : [...pending.values()].reverse().find((candidate) => candidate.cwd === args.cwd && candidate.ownerId === args.ownerId);
+  if (!delivery?.owner)
+    return;
+  deliverTestRunnerFindings({
+    ctx: delivery.owner.getCtx(),
+    cacheManager: delivery.owner.cacheManager,
+    runtime: delivery.owner.runtime,
+    sessionId: delivery.sessionId,
+    ownerId: delivery.ownerId
+  });
+}
+export function consumeStagedTestRunnerFindings(args) {
+  const deliveryKey = key(args.cwd, args.sessionId, args.ownerId);
+  let delivery = pending.get(deliveryKey);
+  const persisted = args.cacheManager.readCache("test-runner-findings", args.cwd)?.data;
+  const eligible = persisted?.deliveryEligible;
+  if (!delivery && persisted?.content && eligible) {
+    const sameSession = eligible.sessionId === args.sessionId;
+    if (!sameSession) {
+      const foreignDelivery = {
+        cwd: args.cwd,
+        sessionId: eligible.sessionId,
+        generation: eligible.generation,
+        targetCount: 0,
+        createdAt: eligible.eligibleAt,
+        eligible: true,
+        rehydrated: true
+      };
+      record(deliveryKey, "foreign-session", foreignDelivery, {
+        currentSessionId: args.sessionId,
+        currentOwnerId: args.ownerId,
+        reason: "session-mismatch"
+      });
+      return;
+    }
+    delivery = {
+      cwd: args.cwd,
+      sessionId: args.sessionId,
+      ownerId: args.ownerId,
+      generation: eligible.generation,
+      targetCount: 0,
+      createdAt: eligible.eligibleAt,
+      eligible: true,
+      rehydrated: true
+    };
+    pending.set(deliveryKey, delivery);
+  }
+  if (!delivery?.eligible)
+    return;
+  const currentGeneration = persisted?.testRunGeneration;
+  if (currentGeneration !== delivery.generation) {
+    pending.delete(deliveryKey);
+    record(deliveryKey, "superseded", delivery, { currentGeneration });
+    return;
+  }
+  settleDeliveredVerdicts(args.cacheManager, args.cwd, args.runtime, delivery);
+  const findings = consumeTestFindings(args.cacheManager, args.cwd, args.runtime);
+  if (!findings) {
+    pending.delete(deliveryKey);
+    record(deliveryKey, "superseded", delivery);
+    return;
+  }
+  pending.delete(deliveryKey);
+  record(deliveryKey, "delivered", delivery, {
+    ageMs: Math.max(0, Date.now() - delivery.createdAt),
+    rehydrated: delivery.rehydrated === true
+  });
+  return findings;
+}
+export function _resetTestRunnerDeliveryForTests() {
+  pending.clear();
+}
+export function resetTestRunnerDelivery() {
+  pending.clear();
+}

package/extensions/dm-lens/dist/clients/test-target-roots.js

@@ -0,0 +1,17 @@
+import { dirname } from "node:path";
+import { resolveGitCheckout, resolveLinkedWorktreeOwner } from "./review-graph/git-identity.js";
+export function createTurnEndTestRoots(sessionCwd) {
+  const session = resolveGitCheckout(sessionCwd);
+  const ownerByDir = new Map;
+  return (absoluteFile) => {
+    if (session === null)
+      return sessionCwd;
+    const dir = dirname(absoluteFile);
+    let owner = ownerByDir.get(dir);
+    if (owner === undefined) {
+      owner = resolveLinkedWorktreeOwner(session, absoluteFile);
+      ownerByDir.set(dir, owner);
+    }
+    return owner === null ? sessionCwd : owner.spelledRoot;
+  };
+}

package/extensions/dm-lens/dist/clients/todo-scanner.js

@@ -0,0 +1,164 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { collectSourceFiles } from "./source-filter.js";
+const MAX_SCAN_FILE_BYTES = 512 * 1024;
+const MARKDOWN_FILE_RE = /\.(?:md|mdx|markdown)$/i;
+
+export class TodoScanner {
+  pattern = /\b(TODO|FIXME|HACK|XXX|BUG)\b\s*[(:]?\s*(.+)/g;
+  isInComment(line, matchIndex, markdown = false) {
+    if (markdown) {
+      const beforeMatch = line.slice(0, matchIndex);
+      const open = beforeMatch.lastIndexOf("<!--");
+      return open !== -1 && beforeMatch.lastIndexOf("-->") < open;
+    }
+    const trimmed = line.trimStart();
+    if (/^\/\/|^\/\*|^\*|^#/.test(trimmed))
+      return true;
+    const beforeMatch = line.slice(0, matchIndex);
+    const lineCommentPos = beforeMatch.lastIndexOf("//");
+    if (lineCommentPos !== -1) {
+      const beforeComment = beforeMatch.slice(0, lineCommentPos);
+      const singleQuotes = (beforeComment.match(/'/g) || []).length;
+      const doubleQuotes = (beforeComment.match(/"/g) || []).length;
+      const backticks = (beforeComment.match(/`/g) || []).length;
+      if (singleQuotes % 2 === 0 && doubleQuotes % 2 === 0 && backticks % 2 === 0) {
+        return true;
+      }
+    }
+    const blockOpen = beforeMatch.lastIndexOf("/*");
+    const blockClose = beforeMatch.lastIndexOf("*/");
+    if (blockOpen !== -1 && blockClose < blockOpen)
+      return true;
+    const hashPos = beforeMatch.lastIndexOf("#");
+    if (hashPos !== -1) {
+      const beforeHash = beforeMatch.slice(0, hashPos);
+      const singleQuotes = (beforeHash.match(/'/g) || []).length;
+      const doubleQuotes = (beforeHash.match(/"/g) || []).length;
+      if (singleQuotes % 2 === 0 && doubleQuotes % 2 === 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  scanFile(filePath) {
+    const absolutePath = path.resolve(filePath);
+    try {
+      const stat = fs.statSync(absolutePath);
+      if (!stat.isFile() || stat.size > MAX_SCAN_FILE_BYTES)
+        return [];
+    } catch {
+      return [];
+    }
+    let content;
+    try {
+      content = fs.readFileSync(absolutePath, "utf-8");
+    } catch {
+      return [];
+    }
+    const markdown = MARKDOWN_FILE_RE.test(absolutePath);
+    const lines = content.split(`
+`);
+    const items = [];
+    for (let i = 0;i < lines.length; i++) {
+      const line = lines[i];
+      const matches = line.matchAll(this.pattern);
+      for (const match of matches) {
+        if (!this.isInComment(line, match.index ?? 0, markdown))
+          continue;
+        const type = match[1];
+        const message = (match[2] || "").trim().replace(/\s*\*\/\s*$/, "");
+        items.push({
+          type,
+          message: message.slice(0, 200),
+          file: path.relative(process.cwd(), absolutePath),
+          line: i + 1,
+          column: match.index || 0
+        });
+      }
+    }
+    return items;
+  }
+  scanFiles(filePaths) {
+    const items = [];
+    for (const filePath of filePaths) {
+      if (filePath.endsWith("todo-scanner.js") || filePath.endsWith("todo-scanner.js"))
+        continue;
+      if (/\.(test|spec)\.[jt]sx?$/.test(filePath))
+        continue;
+      items.push(...this.scanFile(filePath));
+    }
+    return this.groupResults(items);
+  }
+  scanDirectory(dirPath) {
+    const sourceFiles = collectSourceFiles(dirPath);
+    return this.scanFiles(sourceFiles);
+  }
+  groupResults(items) {
+    const byType = new Map;
+    for (const item of items) {
+      const existing = byType.get(item.type) || [];
+      existing.push(item);
+      byType.set(item.type, existing);
+    }
+    const byFile = new Map;
+    for (const item of items) {
+      const existing = byFile.get(item.file) || [];
+      existing.push(item);
+      byFile.set(item.file, existing);
+    }
+    return { items, byType, byFile };
+  }
+  formatResult(result, maxItems = 30) {
+    if (result.items.length === 0)
+      return "";
+    let output = `[TODOs] ${result.items.length} annotation(s) found`;
+    const typeCounts = [];
+    for (const [type, items] of result.byType) {
+      typeCounts.push(`${items.length} ${type}`);
+    }
+    if (typeCounts.length > 0) {
+      output += ` (${typeCounts.join(", ")})`;
+    }
+    output += `:
+`;
+    const priorityOrder = [
+      "FIXME",
+      "HACK",
+      "BUG",
+      "TODO",
+      "XXX"
+    ];
+    const sorted = [...result.items].sort((a, b) => {
+      const aIdx = priorityOrder.indexOf(a.type);
+      const bIdx = priorityOrder.indexOf(b.type);
+      return (aIdx === -1 ? 99 : aIdx) - (bIdx === -1 ? 99 : bIdx);
+    });
+    for (const item of sorted.slice(0, maxItems)) {
+      const icon = this.getIcon(item.type);
+      output += `  ${icon} ${item.file}:${item.line} — ${item.type}: ${item.message}
+`;
+    }
+    if (result.items.length > maxItems) {
+      output += `  ... and ${result.items.length - maxItems} more
+`;
+    }
+    return output;
+  }
+  getIcon(type) {
+    switch (type) {
+      case "FIXME":
+        return "\uD83D\uDD34";
+      case "HACK":
+        return "\uD83D\uDFE0";
+      case "BUG":
+        return "\uD83D\uDC1B";
+      case "TODO":
+        return "\uD83D\uDCDD";
+      case "XXX":
+        return "❌";
+      default:
+        return "•";
+    }
+  }
+}