@duckmind/dm-linux-x64 0.66.0 → 0.66.2

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

@@ -1,291 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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);
-}