mixdog 0.9.173 → 0.9.175

package/scripts/lib/changed-tests.mjs

@@ -0,0 +1,104 @@
+// `--changed`: the test files whose relative references reach a file that
+// differs from HEAD (tracked edits and untracked files). The graph is read from
+// source text — `import … from`, `export … from`, `import()`, `require()` and
+// `new URL(…, import.meta.url)` with a './' or '../' path — so an asset a module
+// finds another way (a path joined at run time, a skill's markdown) is not an
+// edge; those changed files are reported back as unreached so the caller can
+// add a path filter for them.
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, posix, relative } from 'node:path';
+
+// A module names what it loads by a relative path in four ways: a static or
+// re-exporting import, a dynamic import(), require(), and a file URL resolved
+// against import.meta.url (a spawned worker, a fixture script, a PowerShell source).
+const RELATIVE_IMPORT =
+  /(?:\bimport\s*(?:[^'"()]*?\bfrom\s*)?|\bexport\s+[^'"()]*?\bfrom\s*|\bimport\s*\(\s*|\brequire\s*\(\s*|\bnew\s+URL\s*\(\s*)['"](\.{1,2}\/[^'"]+)['"]/g;
+const SUFFIXES = ['', '.mjs', '.js', '.ts', '.tsx', '.mts', '.cjs', '/index.mjs', '/index.js', '/index.ts'];
+const SOURCE = /\.(?:mjs|cjs|js|ts|tsx|mts)$/;
+
+const toPosix = (path) => path.replaceAll('\\', '/');
+
+function gitLines(args, cwd) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8' })
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+/** Paths relative to cwd that differ from HEAD, plus untracked ones. */
+export function changedFiles(cwd = process.cwd()) {
+  const tracked = gitLines(['diff', '--name-only', '--relative', 'HEAD'], cwd);
+  const untracked = gitLines(['ls-files', '--others', '--exclude-standard'], cwd);
+  return [...new Set([...tracked, ...untracked].map(toPosix))].sort();
+}
+
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// The module a relative specifier names, relative to cwd, or '' when no file
+// answers it (a generated or missing module is simply not an edge).
+function resolveImport(cwd, fromFile, specifier) {
+  const base = join(cwd, dirname(fromFile), specifier);
+  for (const suffix of SUFFIXES) {
+    const candidate = `${base}${suffix}`;
+    if (isFile(candidate)) return toPosix(relative(cwd, candidate));
+  }
+  return '';
+}
+
+export function createImportGraph(cwd = process.cwd()) {
+  const edges = new Map();
+  return (file) => {
+    if (edges.has(file)) return edges.get(file);
+    let text = '';
+    if (SOURCE.test(file) && existsSync(join(cwd, file))) text = readFileSync(join(cwd, file), 'utf8');
+    const targets = new Set();
+    for (const match of text.matchAll(RELATIVE_IMPORT)) {
+      const target = resolveImport(cwd, file, match[1]);
+      if (target) targets.add(posix.normalize(target));
+    }
+    const list = [...targets];
+    edges.set(file, list);
+    return list;
+  };
+}
+
+/**
+ * The test files that reach a changed file through static imports, and the
+ * changed files no selected or unselected test reaches.
+ */
+export function selectChangedTests(testFiles, changed, cwd = process.cwd(), importsOf = createImportGraph(cwd)) {
+  const changedSet = new Set(changed.map(toPosix));
+  // Every module the tests import, with who imports it: reachability then runs
+  // backwards from the changed files, which stays exact through import cycles.
+  const seen = new Set();
+  const importers = new Map();
+  const stack = testFiles.map(toPosix);
+  while (stack.length) {
+    const file = stack.pop();
+    if (seen.has(file)) continue;
+    seen.add(file);
+    for (const target of importsOf(file)) {
+      if (!importers.has(target)) importers.set(target, []);
+      importers.get(target).push(file);
+      if (!seen.has(target)) stack.push(target);
+    }
+  }
+  const affected = new Set();
+  const queue = [...changedSet].filter((file) => seen.has(file));
+  while (queue.length) {
+    const file = queue.pop();
+    if (affected.has(file)) continue;
+    affected.add(file);
+    queue.push(...(importers.get(file) || []));
+  }
+  const selected = testFiles.filter((file) => affected.has(toPosix(file)));
+  const unreached = [...changedSet].filter((file) => !seen.has(file) && existsSync(join(cwd, file)));
+  return { selected, unreached };
+}

package/scripts/lib/cli-args.mjs

@@ -0,0 +1,43 @@
+// Argv reading shared by the scripts/ CLIs (bench, diag and smoke runners).
+// `--name value` and `--name=value` are equivalent; a missing option yields
+// the caller's fallback. `argv` is a seam for tests only — callers keep
+// reading the live process arguments.
+export function argValue(name, fallback = null, argv = process.argv) {
+  const index = argv.indexOf(name);
+  if (index >= 0 && index + 1 < argv.length) return argv[index + 1];
+  const prefix = `${name}=`;
+  const hit = argv.find((arg) => arg.startsWith(prefix));
+  return hit ? hit.slice(prefix.length) : fallback;
+}
+
+export function hasFlag(name, argv = process.argv) {
+  return argv.includes(name);
+}
+
+// The non-flag entries of `argv` (user arguments only, e.g.
+// process.argv.slice(2)). A bare `--name` consumes the next entry as its
+// value unless it is in `booleanFlags`; `--name=value` consumes nothing.
+export function positionalArgs(argv, booleanFlags) {
+  return argv.filter((arg, index) => {
+    if (arg.startsWith('--')) return false;
+    const prev = index > 0 ? argv[index - 1] : '';
+    return !(prev.startsWith('--') && !prev.includes('=') && !booleanFlags.has(prev));
+  });
+}
+
+// A numeric option that keeps a deliberate 0 (or negative): only a missing,
+// blank or non-numeric value takes the fallback.
+export function numArg(name, fallback, argv = process.argv) {
+  const raw = argValue(name, null, argv);
+  if (raw == null || raw.trim() === '') return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+// A positive-integer option: a missing, non-numeric or non-positive value
+// keeps the fallback, so a typo degrades to the documented default instead of
+// silently running with NaN.
+export function intArg(name, fallback, argv = process.argv) {
+  const parsed = Number.parseInt(argValue(name, String(fallback), argv), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}

package/scripts/lib/cli-args.test.mjs

@@ -0,0 +1,64 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { argValue, hasFlag, intArg, numArg, positionalArgs } from './cli-args.mjs';
+
+test('argValue reads both the separated and the joined option form', () => {
+  const argv = ['node', 'bench.mjs', '--model', 'opus', '--round=3', '--trailing'];
+  assert.equal(argValue('--model', null, argv), 'opus');
+  assert.equal(argValue('--round', null, argv), '3');
+  assert.equal(argValue('--missing', null, argv), null);
+  assert.equal(argValue('--missing', 'fallback', argv), 'fallback');
+  // An explicit `undefined` fallback takes the parameter default, so a
+  // missing option always reads as null rather than undefined.
+  assert.equal(argValue('--missing', undefined, argv), null);
+});
+
+test('argValue falls back when the separated form has no value left', () => {
+  assert.equal(argValue('--save', 'default', ['node', 'bench.mjs', '--save']), 'default');
+  // An empty joined value is a value, not a missing option.
+  assert.equal(argValue('--save', 'default', ['node', 'bench.mjs', '--save=']), '');
+  // The next argument is taken verbatim, even when it looks like a flag.
+  assert.equal(argValue('--save', null, ['node', 'bench.mjs', '--save', '--json']), '--json');
+});
+
+test('hasFlag reports presence only', () => {
+  const argv = ['node', 'bench.mjs', '--json', '--limit=5'];
+  assert.equal(hasFlag('--json', argv), true);
+  assert.equal(hasFlag('--limit', argv), false);
+  assert.equal(hasFlag('--quiet', argv), false);
+});
+
+test('intArg accepts positive integers and keeps the fallback otherwise', () => {
+  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit', '5']), 5);
+  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit=12']), 12);
+  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs']), 30);
+  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit', 'abc']), 30);
+  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit', '0']), 30);
+  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit', '-4']), 30);
+  // parseInt stops at the first non-digit, as the CLIs have always accepted.
+  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit', '7x']), 7);
+});
+
+test('numArg keeps a deliberate 0 and falls back only on missing or non-numeric values', () => {
+  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget', '0']), 0);
+  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget=0']), 0);
+  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget', '2500']), 2500);
+  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget', '0.5']), 0.5);
+  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs']), 16000);
+  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget=']), 16000);
+  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget', 'lots']), 16000);
+  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget']), 16000);
+});
+
+test('positionalArgs never lets a boolean flag or a joined value swallow a positional', () => {
+  const booleans = new Set(['--render']);
+  assert.deepEqual(positionalArgs(['--render', 'deck.js', 'deck.pptx', '--mode', 'auto'], booleans), [
+    'deck.js',
+    'deck.pptx',
+  ]);
+  assert.deepEqual(positionalArgs(['--mode=auto', 'deck.js', 'deck.pptx'], booleans), ['deck.js', 'deck.pptx']);
+  assert.deepEqual(positionalArgs(['deck.js', '--out', 'result.json', 'deck.pptx', '--render'], booleans), [
+    'deck.js',
+    'deck.pptx',
+  ]);
+});

package/scripts/lib/coverage.mjs

@@ -141,10 +141,8 @@ export async function foldCoverage(reports, { root = process.cwd() } = {}) {
     const entries = [...collected.get(path).values()].sort(
       (left, right) => left.startOffset - right.startOffset || left.endOffset - right.endOffset
     );
-    let source;
-    try {
-      source = (await readFile(join(rootPath, path), 'utf8')).replace(/^\uFEFF/, '');
-    } catch {
+    const source = await currentSource(rootPath, path);
+    if (source === null) {
       excluded.set(path, 'source-unreadable');
       continue;
     }

package/scripts/lib/embedding-model-bench-core.mjs

@@ -344,10 +344,3 @@ export function aggregateScoredRows(rows) {
   }
   return { overall: aggregate(rows), byLanguage };
 }
-
-export function percentile(values, ratio) {
-  if (!Array.isArray(values) || values.length === 0) return 0;
-  const sorted = [...values].sort((left, right) => left - right);
-  const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * ratio) - 1));
-  return sorted[index];
-}

package/scripts/lib/run-node-tests.mjs

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
-import { appendFile, mkdtemp, readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
+import { appendFile, mkdtemp, readdir, readFile, rm, stat } from 'node:fs/promises';
+import { availableParallelism, tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { FAILURE_RECORDS_ENV } from './test-failure-records.mjs';
 import { classifyRerunOutcomes, formatFailureSummary } from './test-failure-summary.mjs';
@@ -16,6 +16,29 @@ export const ARG_BUDGET = process.platform === 'win32' ? 30_000 : 1_000_000;
 // An argument costs its own characters plus the separator and its quotes.
 const argCost = (arg) => arg.length + 3;
 
+// Full logs are kept for reading after the run; older ones are stale.
+const TEST_LOG_PREFIX = 'mixdog-test-output-';
+const TEST_LOG_RETENTION_MS = 3 * 24 * 60 * 60 * 1000;
+
+async function pruneStaleTestLogs(root) {
+  let names = [];
+  try {
+    names = await readdir(root);
+  } catch {
+    return;
+  }
+  const cutoff = Date.now() - TEST_LOG_RETENTION_MS;
+  for (const name of names) {
+    if (!name.startsWith(TEST_LOG_PREFIX)) continue;
+    const path = join(root, name);
+    try {
+      if ((await stat(path)).mtimeMs < cutoff) await rm(path, { recursive: true, force: true });
+    } catch {
+      /* another run may own or be removing it */
+    }
+  }
+}
+
 // Batches keep the file order Node was given; a single path larger than the
 // budget still gets its own batch rather than being dropped. An empty list
 // stays one batch: Node's own discovery is what an argument-less run means.
@@ -35,6 +58,27 @@ export function chunkFileArgs(fileArgs, budget) {
   return chunks;
 }
 
+const positiveInt = (value) => {
+  const n = Number(value);
+  return Number.isInteger(n) && n > 0 ? n : null;
+};
+
+// `node --test` defaults to availableParallelism()-1 file processes. When the
+// run is one of several concurrent shell commands (the Mixdog shell tool
+// exports the admission cap as MIXDOG_SHELL_CONCURRENCY_CAP), that multiplies
+// across peers, so each run takes its share of the cores. Precedence: an
+// explicit --test-concurrency flag, then MIXDOG_TEST_CONCURRENCY, then the
+// share; with none of them Node's default stands and standalone runs are
+// unchanged. Returns the flag to add, or null.
+export function testConcurrencyArg(nodeArgs, env = process.env, parallelism = availableParallelism()) {
+  if (nodeArgs.some((arg) => arg === '--test-concurrency' || arg.startsWith('--test-concurrency='))) return null;
+  const explicit = positiveInt(env.MIXDOG_TEST_CONCURRENCY);
+  if (explicit) return `--test-concurrency=${explicit}`;
+  const cap = positiveInt(env.MIXDOG_SHELL_CONCURRENCY_CAP);
+  if (!cap) return null;
+  return `--test-concurrency=${Math.max(2, Math.floor(parallelism / cap))}`;
+}
+
 function spawnBatch(args, env) {
   return new Promise((resolve) => {
     const child = spawn(process.execPath, args, { stdio: 'inherit', env });
@@ -75,13 +119,20 @@ export async function runNodeTests(
   fileArgs,
   { argBudget = ARG_BUDGET, coverage = false, rerunFailed = 0 } = {}
 ) {
-  const logPath = join(await mkdtemp(join(tmpdir(), 'mixdog-test-output-')), 'full.log');
+  await pruneStaleTestLogs(tmpdir());
+  const logPath = join(await mkdtemp(join(tmpdir(), TEST_LOG_PREFIX)), 'full.log');
   console.error(`Full test log: ${logPath}`);
   // Failure records live outside the log directory: the log directory holds
   // exactly one merged log, and these records are an internal artifact.
   const failureDir = await mkdtemp(join(tmpdir(), 'mixdog-test-failures-'));
+  // Test processes get a private temp root that is removed after the run, so
+  // every fixture directory a test forgets to delete goes with it instead of
+  // piling up in the system temp directory.
+  const scratchDir = await mkdtemp(join(tmpdir(), 'mixdog-test-scratch-'));
+  const concurrencyArg = testConcurrencyArg(nodeArgs);
   const runArgs = [
     ...nodeArgs,
+    ...(concurrencyArg ? [concurrencyArg] : []),
     `--test-reporter=${SUMMARY_REPORTER}`,
     '--test-reporter-destination=stdout',
     '--test-reporter=spec',
@@ -97,6 +148,9 @@ export async function runNodeTests(
   // already budgeted, and a third reporter would warn about listeners.
   const childEnv = (recordsPath) => ({
     ...process.env,
+    TEMP: scratchDir,
+    TMP: scratchDir,
+    TMPDIR: scratchDir,
     [FAILURE_RECORDS_ENV]: recordsPath,
     ...(coverageDir ? { NODE_V8_COVERAGE: coverageDir } : {}),
   });
@@ -142,6 +196,8 @@ export async function runNodeTests(
   process.exitCode = status;
 
   await rm(failureDir, { recursive: true, force: true });
+  // A process a test left running may still hold a file; what it holds stays.
+  await rm(scratchDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }).catch(() => {});
   if (coverageDir) {
     const { reportCoverage } = await import('./coverage.mjs');
     await reportCoverage(coverageDir);

package/scripts/lib/session-bench-fmt.mjs

@@ -0,0 +1,65 @@
+// Formatting helpers shared by the session-bench analysis and render layers.
+export function fmtMs(ms) {
+  const n = Number(ms);
+  if (!Number.isFinite(n)) return '-';
+  if (n >= 1000) return `${(n / 1000).toFixed(n >= 10_000 ? 0 : 1)}s`;
+  return `${Math.round(n)}ms`;
+}
+
+export function fmtSec(ms) {
+  const n = Number(ms);
+  if (!Number.isFinite(n)) return '-';
+  return `${(n / 1000).toFixed(n >= 10_000 ? 0 : 1)}s`;
+}
+
+export function fmtTok(n) {
+  const v = Number(n);
+  if (!Number.isFinite(v)) return '-';
+  if (v >= 1_000_000) return `${(v / 1_000_000).toFixed(2)}M`;
+  if (v >= 1000) return `${(v / 1000).toFixed(1)}k`;
+  return String(Math.round(v));
+}
+
+export function fmtPct(n) {
+  const v = Number(n);
+  return Number.isFinite(v) ? `${Math.round(v)}%` : '-';
+}
+
+export function fmtTime(ts) {
+  const n = Number(ts);
+  if (!Number.isFinite(n) || n <= 0) return '-';
+  return new Date(n)
+    .toISOString()
+    .replace('T', ' ')
+    .replace(/\.\d+Z$/, 'Z');
+}
+
+export function compactText(value, max = 140) {
+  const s = String(value || '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return s.length > max ? `${s.slice(0, Math.max(0, max - 1))}…` : s;
+}
+
+export function shortId(id) {
+  const s = String(id || '');
+  if (s.length <= 18) return s;
+  return `${s.slice(0, 10)}…${s.slice(-6)}`;
+}
+
+export function padTable(rows) {
+  if (!rows.length) return [];
+  const widths = [];
+  for (const row of rows) {
+    row.forEach((cell, i) => {
+      widths[i] = Math.max(widths[i] || 0, String(cell ?? '').length);
+    });
+  }
+  return rows.map((row) => row.map((cell, i) => String(cell ?? '').padEnd(widths[i])).join('  '));
+}
+
+export function fmtKindCounts(counts, limit = 3) {
+  const shown = (counts || []).slice(0, limit).map((x) => `${x.kind}×${x.count}`);
+  const hidden = Math.max(0, (counts || []).length - shown.length);
+  return `${shown.join(', ')}${hidden ? ` +${hidden}` : ''}` || '-';
+}