@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,260 +0,0 @@
-import { emitBounded } from "./bounded-telemetry.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 logDeliveredVerdicts(cacheManager, cwd, runtime, delivery) {
-  const verdicts = cacheManager.readCache("test-runner-findings", cwd)?.data?.verdicts;
-  let knownCount = 0;
-  let staleCount = 0;
-  let unknownCount = 0;
-  for (const verdict of 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)
-      staleCount += 1;
-  }
-  if (knownCount === 0 && unknownCount === 0)
-    return;
-  logLatency({
-    type: "phase",
-    phase: "test_runner_verdict_delivery",
-    filePath: cwd,
-    durationMs: 0,
-    metadata: {
-      sessionId: delivery.sessionId,
-      generation: delivery.generation,
-      verdictCount: knownCount,
-      staleCount,
-      unknownCount
-    }
-  });
-}
-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;
-  }
-  logDeliveredVerdicts(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/todo-scanner.js

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