@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/dist/clients/runtime-config.js

@@ -0,0 +1,39 @@
+import { toPositiveFinite } from "./env-utils.js";
+import { loadDmLensGlobalConfig } from "./lens-config.js";
+let _runnerTimeoutFloorCache;
+export function getRunnerTimeoutFloorMs() {
+  if (_runnerTimeoutFloorCache !== undefined)
+    return _runnerTimeoutFloorCache;
+  const config = loadDmLensGlobalConfig();
+  const configFloor = toPositiveFinite(config?.dispatch?.runnerTimeoutFloorMs);
+  const envFloor = toPositiveFinite(process.env.DM_LENS_RUNNER_TIMEOUT_FLOOR_MS);
+  _runnerTimeoutFloorCache = Math.max(configFloor, envFloor, 0);
+  return _runnerTimeoutFloorCache;
+}
+export function _resetRunnerTimeoutFloorCacheForTests() {
+  _runnerTimeoutFloorCache = undefined;
+}
+export const RUNTIME_CONFIG = {
+  pipeline: {
+    lspMaxFileBytes: 2 * 1024 * 1024,
+    lspMaxFileLines: 5000,
+    cascadeMaxFiles: 5,
+    cascadeMaxDiagnosticsPerFile: 20,
+    lspSpawnBudgetMs: 5000
+  },
+  dispatch: {
+    runnerTimeoutMs: 30000
+  },
+  crashNotice: {
+    alwaysShowFirstN: 2,
+    showEveryNth: 5
+  },
+  reviewGraph: {
+    maxFiles: 1000,
+    maxFileBytes: 1 * 1024 * 1024
+  },
+  turnEnd: {
+    maxLines: 20,
+    maxChars: 1000
+  }
+};

package/extensions/dm-lens/dist/clients/runtime-context.js

@@ -0,0 +1,155 @@
+import { provenanceStamp, validateAdvisoryProvenance } from "./advisory-provenance.js";
+import { logLatency } from "./latency-logger.js";
+import { translateGuidanceToolNames } from "./tool-config.js";
+export const AUTOMATION_FRAMING = "[dm-lens automated check — not a user request] ";
+const MAX_LOGGED_REASONS = 8;
+function boundedReasons(reasons) {
+  if (reasons.length <= MAX_LOGGED_REASONS)
+    return reasons;
+  return [
+    ...reasons.slice(0, MAX_LOGGED_REASONS),
+    `+${reasons.length - MAX_LOGGED_REASONS} more`
+  ];
+}
+function logProvenanceDecision(validation, provenance, advisoryKind, cwd) {
+  logLatency({
+    type: "phase",
+    phase: "advisory_provenance_decision",
+    filePath: cwd,
+    durationMs: 0,
+    metadata: {
+      decision: validation.status === "current" ? "current" : "historical",
+      reasons: boundedReasons(validation.reasons),
+      changedPathCount: validation.changedPathCount,
+      provenanceStamp: provenanceStamp(provenance),
+      advisoryKind
+    }
+  });
+}
+function historicalPrefix(provenance) {
+  return `Historical finding; workspace changed since capture; re-run to confirm. (${provenanceStamp(provenance)})`;
+}
+function historicalTestContent(content, provenance) {
+  return content.startsWith("[from a prior turn") ? content : `${historicalPrefix(provenance)}
+
+${content}`;
+}
+function turnEndMessage(content, current, provenance) {
+  return {
+    role: "user",
+    content: current ? `${AUTOMATION_FRAMING}Address \uD83D\uDD34 blockers before continuing; ℹ️ advisories are informational only.
+
+${content}` : `${AUTOMATION_FRAMING}${historicalPrefix(provenance)}
+
+${content}`
+  };
+}
+export function peekTurnEndFindings(cacheManager, cwd, runtime, logDelivery = false) {
+  const findings = cacheManager.readCache("turn-end-findings", cwd);
+  if (!findings?.data?.content || findings.data.consumed === true)
+    return;
+  const validation = validateAdvisoryProvenance(findings.data, cwd, runtime);
+  if (logDelivery)
+    logProvenanceDecision(validation, findings.data.provenance, "turn-end", cwd);
+  if (validation.allFilesDeleted)
+    return;
+  return {
+    messages: [
+      turnEndMessage(findings.data.content, validation.status === "current", findings.data.provenance)
+    ]
+  };
+}
+export function consumeTurnEndFindings(cacheManager, cwd, runtime) {
+  const findings = cacheManager.readCache("turn-end-findings", cwd);
+  if (!findings?.data?.content || findings.data.consumed === true)
+    return;
+  const validation = validateAdvisoryProvenance(findings.data, cwd, runtime);
+  logProvenanceDecision(validation, findings.data.provenance, "turn-end", cwd);
+  if (findings.data.hasBlockers === true && typeof findings.data.sessionId === "string") {
+    cacheManager.writeCache("turn-end-findings", { ...findings.data, consumed: true }, cwd);
+  } else {
+    cacheManager.clearCache("turn-end-findings", cwd);
+  }
+  if (validation.allFilesDeleted)
+    return;
+  return {
+    messages: [
+      turnEndMessage(findings.data.content, validation.status === "current", findings.data.provenance)
+    ]
+  };
+}
+export function peekTestFindings(cacheManager, cwd, runtime, logDelivery = false) {
+  const findings = cacheManager.readCache("test-runner-findings", cwd);
+  if (!findings?.data?.content)
+    return;
+  const validation = validateAdvisoryProvenance(findings.data, cwd, runtime);
+  if (logDelivery)
+    logProvenanceDecision(validation, findings.data.provenance, "test-findings", cwd);
+  if (validation.allFilesDeleted)
+    return;
+  const current = validation.status === "current";
+  return {
+    messages: [
+      {
+        role: "user",
+        content: current ? `${AUTOMATION_FRAMING}${testFindingsCurrentPrefix(findings.data.runnerErrorOnly)}
+
+${findings.data.content}` : `${AUTOMATION_FRAMING}${historicalTestContent(findings.data.content, findings.data.provenance)}`
+      }
+    ]
+  };
+}
+function testFindingsCurrentPrefix(runnerErrorOnly) {
+  return runnerErrorOnly ? "Test runner could not complete last turn (advisory — not a failure introduced this turn):" : "Test failures detected last turn — fix before continuing:";
+}
+function retireTestFindings(cacheManager, cwd) {
+  const prior = cacheManager.readCache("test-runner-findings", cwd)?.data;
+  cacheManager.writeCache("test-runner-findings", {
+    content: "",
+    testRunGeneration: prior?.testRunGeneration,
+    deferredTargets: prior?.deferredTargets,
+    retiredTargets: prior?.retiredTargets
+  }, cwd);
+}
+export function consumeTestFindings(cacheManager, cwd, runtime) {
+  const record = cacheManager.readCache("test-runner-findings", cwd);
+  if (!record?.data?.content)
+    return;
+  const findings = peekTestFindings(cacheManager, cwd, runtime, true);
+  if (!findings)
+    return;
+  retireTestFindings(cacheManager, cwd);
+  return findings;
+}
+export function acknowledgeTurnEndFindings(cacheManager, cwd) {
+  const findings = cacheManager.readCache("turn-end-findings", cwd);
+  if (!findings?.data?.content || findings.data.consumed === true)
+    return;
+  if (findings.data.hasBlockers === true && typeof findings.data.sessionId === "string") {
+    cacheManager.writeCache("turn-end-findings", { ...findings.data, consumed: true }, cwd);
+  } else {
+    cacheManager.clearCache("turn-end-findings", cwd);
+  }
+}
+export function acknowledgeTestFindings(cacheManager, cwd) {
+  const findings = cacheManager.readCache("test-runner-findings", cwd);
+  if (!findings?.data?.content)
+    return;
+  retireTestFindings(cacheManager, cwd);
+}
+export function consumeSessionStartGuidance(cacheManager, cwd, host = "pi") {
+  const guidance = cacheManager.readCache("session-start-guidance", cwd);
+  if (!guidance?.data?.content)
+    return;
+  cacheManager.writeCache("session-start-guidance", { content: "" }, cwd);
+  return {
+    messages: [
+      {
+        role: "user",
+        content: `[dm-lens automated context — not a user request]
+
+${translateGuidanceToolNames(guidance.data.content, host)}`
+      }
+    ]
+  };
+}