@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-lens/dist/clients/performance-report.js

@@ -0,0 +1,291 @@
+import * as fs from "node:fs";
+import * as readline from "node:readline";
+import { flushLatencyLog, getLatencyLogPath } from "./latency-logger.js";
+import { getMaxLogSizeMB } from "./log-cleanup.js";
+const DEFAULT_PERF_TOP_N = 5;
+const MAX_PERF_TOP_N = 50;
+export const MAX_PERF_PHASE_SAMPLES = 20000;
+export const PARSE_YIELD_EVERY = 500;
+export function resolveLogByteBudget() {
+  return getMaxLogSizeMB() * 1024 * 1024;
+}
+function boundedPositiveInteger(value, maximum, fallback = maximum) {
+  return Number.isFinite(value) && value > 0 ? Math.min(maximum, Math.max(1, Math.floor(value))) : fallback;
+}
+function percentile(sorted, quantile) {
+  const position = (sorted.length - 1) * quantile;
+  const lower = Math.floor(position);
+  const upper = Math.ceil(position);
+  return lower === upper ? sorted[lower] : sorted[lower] + (sorted[upper] - sorted[lower]) * (position - lower);
+}
+function roundedMs(value) {
+  return Math.round(value * 10) / 10;
+}
+function isEntryObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isPhaseRecord(value) {
+  if (!isEntryObject(value))
+    return false;
+  return value.type === "phase" && typeof value.phase === "string" && value.phase.trim().length > 0 && typeof value.durationMs === "number" && Number.isFinite(value.durationMs) && value.durationMs >= 0 && (value.toolName === undefined || typeof value.toolName === "string") && (value.ts === undefined || typeof value.ts === "string") && (value.startedAt === undefined || typeof value.startedAt === "string") && (value.pid === undefined || typeof value.pid === "number" && Number.isFinite(value.pid));
+}
+function isPhaseSample(value) {
+  return isPhaseRecord(value) && value.durationMs > 0;
+}
+function phaseKey(entry) {
+  const phase = entry.phase?.trim() ?? "";
+  const toolName = entry.toolName?.trim();
+  return toolName ? `${toolName}/${phase}` : phase;
+}
+function isCurrentSessionSample(entry, processId, sessionStartedAt) {
+  if (entry.pid !== processId || typeof entry.ts !== "string")
+    return false;
+  const finishedAt = Date.parse(entry.ts);
+  if (!Number.isFinite(finishedAt) || finishedAt < sessionStartedAt)
+    return false;
+  if (entry.startedAt === undefined)
+    return true;
+  const startedAt = Date.parse(entry.startedAt);
+  return Number.isFinite(startedAt) && startedAt >= sessionStartedAt;
+}
+function createPhaseBuffer(limit) {
+  return { values: [], nextIndex: 0, total: 0, limit };
+}
+function retainEntry(buffer, entry) {
+  buffer.total += 1;
+  if (buffer.values.length < buffer.limit) {
+    buffer.values.push(entry);
+    return;
+  }
+  buffer.values[buffer.nextIndex] = entry;
+  buffer.nextIndex = (buffer.nextIndex + 1) % buffer.limit;
+}
+function orderedEntries(buffer) {
+  return buffer.total > buffer.values.length ? [
+    ...buffer.values.slice(buffer.nextIndex),
+    ...buffer.values.slice(0, buffer.nextIndex)
+  ] : buffer.values;
+}
+export function summarizePhaseLatency(entries, topN = DEFAULT_PERF_TOP_N) {
+  const durationsByPhase = new Map;
+  let oldestTimestamp;
+  let newestTimestamp;
+  let sampleCount = 0;
+  for (const entry of entries) {
+    if (!isPhaseSample(entry))
+      continue;
+    const phase = phaseKey(entry);
+    const durations = durationsByPhase.get(phase) ?? [];
+    durations.push(entry.durationMs);
+    durationsByPhase.set(phase, durations);
+    sampleCount += 1;
+    if (typeof entry.ts === "string") {
+      const ms = Date.parse(entry.ts);
+      if (Number.isFinite(ms)) {
+        if (!oldestTimestamp || ms < oldestTimestamp.ms) {
+          oldestTimestamp = { ms, iso: entry.ts };
+        }
+        if (!newestTimestamp || ms > newestTimestamp.ms) {
+          newestTimestamp = { ms, iso: entry.ts };
+        }
+      }
+    }
+  }
+  const summaries = Array.from(durationsByPhase, ([phase, durations]) => {
+    const sorted = [...durations].sort((a, b) => a - b);
+    const p50RawMs = percentile(sorted, 0.5);
+    const p99RawMs = percentile(sorted, 0.99);
+    return {
+      phase,
+      samples: sorted.length,
+      p50Ms: roundedMs(p50RawMs),
+      p99Ms: roundedMs(p99RawMs),
+      p50RawMs,
+      p99RawMs
+    };
+  });
+  const limit = boundedPositiveInteger(topN, MAX_PERF_TOP_N, DEFAULT_PERF_TOP_N);
+  const tieBreak = (a, b) => b.samples - a.samples || a.phase.localeCompare(b.phase);
+  const toPublic = ({ phase, samples, p50Ms, p99Ms }) => ({
+    phase,
+    samples,
+    p50Ms,
+    p99Ms
+  });
+  const rankBy = (primary, secondary) => [...summaries].sort((a, b) => b[primary] - a[primary] || b[secondary] - a[secondary] || tieBreak(a, b)).slice(0, limit).map(toPublic);
+  return {
+    sampleCount,
+    phaseCount: durationsByPhase.size,
+    oldestTs: oldestTimestamp?.iso,
+    newestTs: newestTimestamp?.iso,
+    slowestByP50: rankBy("p50RawMs", "p99RawMs"),
+    slowestByP99: rankBy("p99RawMs", "p50RawMs")
+  };
+}
+async function readPhaseLogTail(filePath, windowBytes, maxSamples, processId, sessionStartedAt) {
+  const empty = () => ({
+    logEntries: [],
+    sessionEntries: [],
+    windowTruncated: false,
+    logSamplesTruncated: false,
+    sessionSamplesTruncated: false,
+    totalPhaseSamples: 0,
+    totalSessionPhaseSamples: 0,
+    malformedLines: 0,
+    invalidRecords: 0
+  });
+  let handle;
+  try {
+    handle = await fs.promises.open(filePath, "r");
+    const stat = await handle.stat();
+    if (!stat.isFile()) {
+      const notAFile = new Error(`EISDIR: illegal operation on a directory, read '${filePath}'`);
+      notAFile.code = "EISDIR";
+      throw notAFile;
+    }
+    if (stat.size === 0)
+      return empty();
+    const sampleLimit = boundedPositiveInteger(maxSamples, MAX_PERF_PHASE_SAMPLES);
+    const start = Math.max(0, stat.size - windowBytes);
+    let discardPartialFirstLine = false;
+    if (start > 0) {
+      const previousByte = Buffer.alloc(1);
+      const { bytesRead } = await handle.read(previousByte, 0, 1, start - 1);
+      discardPartialFirstLine = bytesRead === 1 && previousByte[0] !== 10;
+    }
+    const stream = handle.createReadStream({
+      start,
+      end: stat.size - 1,
+      autoClose: false,
+      encoding: "utf8"
+    });
+    const lines = readline.createInterface({
+      input: stream,
+      crlfDelay: 1 / 0
+    });
+    const logBuffer = createPhaseBuffer(sampleLimit);
+    const sessionBuffer = createPhaseBuffer(sampleLimit);
+    let malformedLines = 0;
+    let invalidRecords = 0;
+    let lineCount = 0;
+    for await (const line of lines) {
+      lineCount += 1;
+      if (lineCount % PARSE_YIELD_EVERY === 0) {
+        await new Promise((resolve) => setImmediate(resolve));
+      }
+      if (discardPartialFirstLine) {
+        discardPartialFirstLine = false;
+        continue;
+      }
+      const trimmed = line.trim();
+      if (!trimmed)
+        continue;
+      try {
+        const value = JSON.parse(trimmed);
+        if (isPhaseSample(value)) {
+          retainEntry(logBuffer, value);
+          if (isCurrentSessionSample(value, processId, sessionStartedAt)) {
+            retainEntry(sessionBuffer, value);
+          }
+        } else if (!isPhaseRecord(value) && (!isEntryObject(value) || value.type === "phase")) {
+          invalidRecords += 1;
+        }
+      } catch {
+        malformedLines += 1;
+      }
+    }
+    return {
+      logEntries: orderedEntries(logBuffer),
+      sessionEntries: orderedEntries(sessionBuffer),
+      windowTruncated: start > 0,
+      logSamplesTruncated: logBuffer.total > sampleLimit,
+      sessionSamplesTruncated: sessionBuffer.total > sampleLimit,
+      totalPhaseSamples: logBuffer.total,
+      totalSessionPhaseSamples: sessionBuffer.total,
+      malformedLines,
+      invalidRecords
+    };
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return empty();
+    throw error;
+  } finally {
+    await handle?.close().catch(() => {});
+  }
+}
+export async function collectLatencyPerformance(options) {
+  await flushLatencyLog();
+  const logPath = options.logPath ?? getLatencyLogPath();
+  const processId = options.processId ?? process.pid;
+  const topN = boundedPositiveInteger(options.topN ?? DEFAULT_PERF_TOP_N, MAX_PERF_TOP_N, DEFAULT_PERF_TOP_N);
+  const byteBudget = resolveLogByteBudget();
+  const windowBytes = boundedPositiveInteger(options.maxBytes ?? byteBudget, byteBudget);
+  const tail = await readPhaseLogTail(logPath, windowBytes, options.maxSamples ?? MAX_PERF_PHASE_SAMPLES, processId, options.sessionStartedAt);
+  const { logEntries, sessionEntries, ...counters } = tail;
+  return {
+    logPath,
+    topN,
+    windowBytes,
+    ...counters,
+    session: summarizePhaseLatency(sessionEntries, topN),
+    logWindow: summarizePhaseLatency(logEntries, topN)
+  };
+}
+function formatDuration(ms) {
+  if (ms >= 1000)
+    return `${(ms / 1000).toFixed(2)}s`;
+  if (ms > 0 && ms < 1)
+    return `${ms.toFixed(2)}ms`;
+  return `${Number.isInteger(ms) ? ms : ms.toFixed(1)}ms`;
+}
+function formatByteBudget(bytes) {
+  if (bytes >= 1024 * 1024) {
+    return `${Number((bytes / (1024 * 1024)).toFixed(1))}MB`;
+  }
+  if (bytes >= 1024)
+    return `${Number((bytes / 1024).toFixed(1))}KB`;
+  return `${bytes}B`;
+}
+function formatTimestamp(ts) {
+  const parsed = new Date(ts);
+  return Number.isFinite(parsed.getTime()) ? `${parsed.toISOString().slice(0, 19).replace("T", " ")}Z` : ts;
+}
+function renderRanking(lines, label, phases) {
+  lines.push(`  ${label}:`);
+  for (const phase of phases) {
+    lines.push(`    ${phase.phase}: p50 ${formatDuration(phase.p50Ms)}, p99 ${formatDuration(phase.p99Ms)}, n=${phase.samples}`);
+  }
+}
+function renderScope(lines, label, scope) {
+  const range = scope.oldestTs && scope.newestTs ? `, ${formatTimestamp(scope.oldestTs)} to ${formatTimestamp(scope.newestTs)}` : "";
+  lines.push("", `${label} (${scope.sampleCount} samples across ${scope.phaseCount} phases${range})`);
+  if (scope.slowestByP99.length === 0) {
+    lines.push("  No phase timings yet.");
+    return;
+  }
+  renderRanking(lines, "Highest p50", scope.slowestByP50);
+  renderRanking(lines, "Highest p99", scope.slowestByP99);
+}
+export function renderLatencyPerformanceReport(report) {
+  const lines = [
+    "⏱️ PI-LENS PERFORMANCE",
+    `Top ${report.topN} sustained and tail latency phases.`
+  ];
+  renderScope(lines, "Current process session", report.session);
+  renderScope(lines, "Machine-wide active log window", report.logWindow);
+  lines.push("", `Source: ${report.logPath}`);
+  if (report.windowTruncated) {
+    lines.push(`Both scopes use only the newest ${formatByteBudget(report.windowBytes)} of the active log.`);
+  }
+  if (report.sessionSamplesTruncated) {
+    lines.push(`Session percentiles use the newest ${report.session.sampleCount.toLocaleString("en-US")} of ${report.totalSessionPhaseSamples.toLocaleString("en-US")} phase samples.`);
+  }
+  if (report.logSamplesTruncated) {
+    lines.push(`Machine-wide percentiles use the newest ${report.logWindow.sampleCount.toLocaleString("en-US")} of ${report.totalPhaseSamples.toLocaleString("en-US")} phase samples.`);
+  }
+  if (report.malformedLines > 0 || report.invalidRecords > 0) {
+    lines.push(`Skipped ${report.malformedLines} malformed line(s) and ${report.invalidRecords} invalid record(s).`);
+  }
+  return lines.join(`
+`);
+}

package/extensions/dm-lens/dist/clients/persist-debounce.js

@@ -0,0 +1,37 @@
+export function createDebounceScheduler(args) {
+  const { write, debounceMs } = args;
+  const pending = new Map;
+  const timers = new Map;
+  function flush(key) {
+    const payload = pending.get(key);
+    if (payload === undefined)
+      return;
+    pending.delete(key);
+    const timer = timers.get(key);
+    if (timer) {
+      clearTimeout(timer);
+      timers.delete(key);
+    }
+    write(key, payload);
+  }
+  function flushAll() {
+    for (const key of pending.keys())
+      flush(key);
+  }
+  function schedule(key, payload) {
+    pending.set(key, payload);
+    const debounce = debounceMs();
+    const existing = timers.get(key);
+    if (existing)
+      clearTimeout(existing);
+    if (debounce === 0) {
+      flush(key);
+      return;
+    }
+    const timer = setTimeout(() => flush(key), debounce);
+    if (typeof timer.unref === "function")
+      timer.unref();
+    timers.set(key, timer);
+  }
+  return { schedule, flush, flushAll };
+}

package/extensions/dm-lens/dist/clients/persistent-reverify.js

@@ -0,0 +1,165 @@
+import * as fs from "node:fs";
+import { enrichFileFromLsp } from "./actionable-warnings.js";
+import { bounded } from "./deadline-utils.js";
+import { logLatency } from "./latency-logger.js";
+import { touchCompletedConfirmationPolicy } from "./lsp/diagnostic-binding.js";
+import { findAuxiliaryProfileForSource } from "./dispatch/auxiliary-lsp.js";
+export const MAX_REVERIFY_FILES = 4;
+export const REVERIFY_BUDGET_MS = 3000;
+const TOUCH_SOURCE = "persistent_reverify";
+export function selectPersistentReverifyFiles(report, nowMs = Date.now()) {
+  const candidates = [];
+  let skippedChanged = 0;
+  for (const entry of report.files) {
+    if (entry.origin !== "deferred")
+      continue;
+    if (entry.warnings.some((w) => findAuxiliaryProfileForSource(w.source ?? "") !== undefined)) {
+      continue;
+    }
+    const stamp = entry.generatedAt ? Date.parse(entry.generatedAt) : NaN;
+    if (!Number.isFinite(stamp) || stamp > nowMs)
+      continue;
+    let mtimeMs;
+    try {
+      mtimeMs = fs.statSync(entry.filePath).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (mtimeMs > stamp) {
+      skippedChanged += 1;
+      continue;
+    }
+    if (candidates.length < MAX_REVERIFY_FILES)
+      candidates.push(entry);
+  }
+  return { candidates, skippedChanged };
+}
+export async function runPersistentReverify(args) {
+  const started = Date.now();
+  const deadlineAt = started + (args.budgetMs ?? REVERIFY_BUDGET_MS);
+  const nowMs = args.nowMs ?? started;
+  const { candidates, skippedChanged } = selectPersistentReverifyFiles(args.report, nowMs);
+  const outcomes = [];
+  const replacementFiles = [];
+  let touched = 0;
+  const buildArgs = {
+    cwd: args.cwd,
+    sessionId: args.report.sessionId,
+    turnIndex: 0,
+    files: [],
+    modifiedRangesByFile: new Map,
+    dispatchWarnings: [],
+    includeLspCodeActions: true,
+    deltaOnly: false,
+    ...args.signal !== undefined ? { signal: args.signal } : {},
+    lspBudgetMs: REVERIFY_BUDGET_MS,
+    dbg: () => {}
+  };
+  let processed = 0;
+  for (const entry of candidates) {
+    if (args.signal?.aborted || Date.now() >= deadlineAt)
+      break;
+    processed += 1;
+    let content;
+    try {
+      content = fs.readFileSync(entry.filePath, "utf-8");
+    } catch {
+      outcomes.push({
+        filePath: entry.filePath,
+        displayPath: entry.displayPath,
+        outcome: "unconfirmed",
+        dropped: 0,
+        kept: entry.warnings.length
+      });
+      replacementFiles.push({ ...entry, reVerifyIncomplete: true });
+      continue;
+    }
+    let touchedResult;
+    try {
+      touchedResult = await bounded(args.lspService.touchFile(entry.filePath, content, {
+        diagnostics: "document",
+        collectDiagnostics: true,
+        source: TOUCH_SOURCE,
+        clientScope: "primary"
+      }), {
+        ms: Math.max(250, deadlineAt - Date.now()),
+        signal: args.signal,
+        hook: "turn_end",
+        label: "persistent_reverify_touch"
+      });
+    } catch {
+      touchedResult = undefined;
+    }
+    if (touchedResult === undefined || touchedResult.inconclusive === true || touchedResult.skipReason !== undefined || (touchedResult.diagnosticsUnsupportedServerIds ?? []).length > 0 || !touchCompletedConfirmationPolicy(touchedResult)) {
+      outcomes.push({
+        filePath: entry.filePath,
+        displayPath: entry.displayPath,
+        outcome: "unconfirmed",
+        dropped: 0,
+        kept: entry.warnings.length
+      });
+      replacementFiles.push({ ...entry, reVerifyIncomplete: true });
+      continue;
+    }
+    touched += 1;
+    const freshRecords = await bounded(enrichFileFromLsp(args.cwd, buildArgs, { filePath: entry.filePath, cached: touchedResult.diags }, {
+      lspService: args.lspService,
+      pullTimeoutMs: 2000,
+      deadlineAt,
+      ...args.signal !== undefined ? { signal: args.signal } : {},
+      site: { hook: "turn_end", label: "persistent_reverify" }
+    }), {
+      ms: Math.max(250, deadlineAt - Date.now()),
+      signal: args.signal,
+      hook: "turn_end",
+      label: "persistent_reverify_enrich"
+    }) ?? [];
+    let dropped = 0;
+    let kept = 0;
+    for (const warning of entry.warnings) {
+      const stillThere = freshRecords.some((record) => record.rule === warning.rule && record.message === warning.message);
+      if (stillThere)
+        kept += 1;
+      else
+        dropped += 1;
+    }
+    const outcome = freshRecords.length === 0 ? "clean" : dropped === 0 ? "reconfirmed" : "mixed";
+    outcomes.push({
+      filePath: entry.filePath,
+      displayPath: entry.displayPath,
+      outcome,
+      dropped,
+      kept
+    });
+    replacementFiles.push({
+      ...entry,
+      warnings: freshRecords,
+      reVerified: true,
+      generatedAt: new Date(nowMs).toISOString()
+    });
+  }
+  logLatency({
+    type: "phase",
+    toolName: "turn_end",
+    filePath: args.cwd,
+    phase: "persistent_reverify",
+    durationMs: Date.now() - started,
+    metadata: {
+      candidates: candidates.length,
+      touched,
+      clean: outcomes.filter((o) => o.outcome === "clean").length,
+      reconfirmed: outcomes.filter((o) => o.outcome === "reconfirmed").length,
+      mixed: outcomes.filter((o) => o.outcome === "mixed").length,
+      unconfirmed: outcomes.filter((o) => o.outcome === "unconfirmed").length,
+      skippedChanged,
+      skippedBudget: candidates.length - processed
+    }
+  });
+  return {
+    outcomes,
+    replacementFiles,
+    candidates: candidates.length,
+    touched,
+    skippedChanged
+  };
+}

package/extensions/dm-lens/dist/clients/php-cs-fixer-config.js

@@ -0,0 +1,15 @@
+import { existsSync } from "node:fs";
+import * as path from "node:path";
+import { resolveToolCwd } from "./tool-cwd.js";
+const PHP_CS_FIXER_CONFIG_NAMES = [
+  ".php-cs-fixer.php",
+  ".php-cs-fixer.dist.php"
+];
+export function resolvePhpCsFixerConfig(filePath) {
+  const absolute = path.resolve(filePath);
+  const startDir = resolveToolCwd("formatter", "php-cs-fixer", absolute, {
+    cwd: path.parse(absolute).root,
+    allowHomeMarker: true
+  }).cwd;
+  return PHP_CS_FIXER_CONFIG_NAMES.map((name) => path.join(startDir, name)).find(existsSync);
+}