atris 3.46.1 → 3.48.0

package/scripts/det/ax-lane-eval.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+'use strict';
+
+// Grade the ax auto lane picker against the labeled gold set.
+// Usage: node scripts/det/ax-lane-eval.js [--json] [--min-accuracy <0..1>]
+// Cost-weighted error: routing up-lane work down (quality miss) counts 3x
+// routing down-lane work up (cost miss), because a wrong cheap answer is
+// worse than an overpriced right one.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { pickLane } = require('../../lib/ax-auto-lane');
+
+const LANES = ['fast', 'pro', 'max', 'code-fast'];
+// Depth order for miss direction; code-fast sits beside pro in cost.
+const DEPTH = { fast: 0, 'code-fast': 1, pro: 1, max: 2 };
+const QUALITY_MISS_WEIGHT = 3;
+const COST_MISS_WEIGHT = 1;
+
+function loadGold() {
+  const dataIndex = process.argv.indexOf('--data');
+  const file = dataIndex >= 0
+    ? path.resolve(process.argv[dataIndex + 1])
+    : path.join(__dirname, 'data', 'ax-lane-gold.jsonl');
+  return fs.readFileSync(file, 'utf8')
+    .split(/\r?\n/)
+    .filter((line) => line.trim())
+    .map((line) => JSON.parse(line));
+}
+
+function evaluate() {
+  const gold = loadGold();
+  const confusion = {};
+  for (const a of LANES) {
+    confusion[a] = {};
+    for (const b of LANES) confusion[a][b] = 0;
+  }
+  const misses = [];
+  let correct = 0;
+  let weightedError = 0;
+  let worstWeight = 0;
+  for (const row of gold) {
+    const picked = pickLane(row.message).lane;
+    confusion[row.lane][picked] += 1;
+    if (picked === row.lane) {
+      correct += 1;
+      continue;
+    }
+    const qualityMiss = DEPTH[picked] < DEPTH[row.lane];
+    const weight = qualityMiss ? QUALITY_MISS_WEIGHT : COST_MISS_WEIGHT;
+    weightedError += weight;
+    worstWeight += QUALITY_MISS_WEIGHT;
+    misses.push({
+      message: row.message.slice(0, 70),
+      gold: row.lane,
+      picked,
+      kind: qualityMiss ? 'quality-miss' : 'cost-miss',
+      why: row.why,
+    });
+  }
+  const perLane = LANES.map((lane) => {
+    const truePos = confusion[lane][lane];
+    const goldCount = LANES.reduce((sum, other) => sum + confusion[lane][other], 0);
+    const pickedCount = LANES.reduce((sum, other) => sum + confusion[other][lane], 0);
+    return {
+      lane,
+      gold: goldCount,
+      recall: goldCount ? truePos / goldCount : null,
+      precision: pickedCount ? truePos / pickedCount : null,
+    };
+  });
+  const total = gold.length;
+  return {
+    total,
+    correct,
+    accuracy: correct / total,
+    quality_misses: misses.filter((m) => m.kind === 'quality-miss').length,
+    cost_misses: misses.filter((m) => m.kind === 'cost-miss').length,
+    weighted_error_rate: worstWeight ? weightedError / (total * QUALITY_MISS_WEIGHT) : 0,
+    per_lane: perLane,
+    confusion,
+    misses,
+  };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const json = args.includes('--json');
+  const minIndex = args.indexOf('--min-accuracy');
+  const minAccuracy = minIndex >= 0 ? Number(args[minIndex + 1]) : null;
+  const report = evaluate();
+  if (json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    const pct = (value) => (value === null ? '  n/a' : `${(value * 100).toFixed(0)}%`.padStart(5));
+    console.log(`\nax auto lane eval: ${report.correct}/${report.total} correct (${pct(report.accuracy)})`);
+    console.log(`quality misses: ${report.quality_misses}  cost misses: ${report.cost_misses}  weighted error: ${(report.weighted_error_rate * 100).toFixed(1)}%\n`);
+    console.log('lane        gold  recall  precision');
+    for (const row of report.per_lane) {
+      console.log(`${row.lane.padEnd(11)} ${String(row.gold).padStart(4)}  ${pct(row.recall)}   ${pct(row.precision)}`);
+    }
+    if (report.misses.length) {
+      console.log('\nmisses:');
+      for (const miss of report.misses) {
+        console.log(`  [${miss.kind}] gold=${miss.gold} picked=${miss.picked}  "${miss.message}"`);
+      }
+    }
+    console.log('');
+  }
+  if (minAccuracy !== null && report.accuracy < minAccuracy) {
+    console.error(`accuracy ${(report.accuracy * 100).toFixed(1)}% is below the ${(minAccuracy * 100).toFixed(0)}% floor`);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/det/changelog.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+// det/changelog.js — build a grouped changelog from Conventional-Commits history.
+// Replaces the "summarize what changed since the last release" ask: the sections,
+// order, and bullets come straight from the commit subjects, so the changelog is
+// exact and reproducible, not an LLM paraphrase that drops or invents entries.
+//
+// Usage:
+//   node changelog.js                 # since the last tag (or root) -> markdown
+//   node changelog.js v3.34.0         # since a specific ref
+//   node changelog.js v3.34.0 HEAD    # explicit range
+//   node changelog.js --json          # structured {sections,counts,...}
+//
+// Reads `git log` itself; no stdin needed. The pure core build(commits) is
+// exported and unit-tested.
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+
+// --- pure core (no git, no process) ---------------------------------------
+
+// Conventional-Commits types -> human section heading, in display order.
+const SECTIONS = [
+  ['feat', 'Features'],
+  ['fix', 'Fixes'],
+  ['perf', 'Performance'],
+  ['refactor', 'Refactors'],
+  ['docs', 'Docs'],
+  ['test', 'Tests'],
+  ['build', 'Build'],
+  ['ci', 'CI'],
+  ['chore', 'Chores'],
+  ['other', 'Other'],
+];
+const KNOWN = new Set(SECTIONS.map((s) => s[0]));
+
+// "feat(scope): subject" or "fix: subject" -> { type, scope, subject }.
+// Anything that doesn't match the header grammar lands in the "other" bucket
+// with the whole line as the subject, so nothing is silently dropped.
+function parseSubject(line) {
+  const m = /^(\w+)(?:\(([^)]+)\))?(!)?:\s*(.+)$/.exec(line.trim());
+  if (!m) return { type: 'other', scope: '', breaking: false, subject: line.trim() };
+  const type = KNOWN.has(m[1]) ? m[1] : 'other';
+  return { type, scope: m[2] || '', breaking: Boolean(m[3]), subject: m[4].trim() };
+}
+
+// commits: [{ hash, subject }] -> { sections, counts, breaking, total }
+function build(commits) {
+  if (!Array.isArray(commits)) return { error: 'commits must be an array' };
+  const buckets = {};
+  const breaking = [];
+  for (const c of commits) {
+    const p = parseSubject(c.subject || '');
+    const entry = { hash: c.hash || '', scope: p.scope, subject: p.subject };
+    (buckets[p.type] = buckets[p.type] || []).push(entry);
+    if (p.breaking) breaking.push(entry);
+  }
+  const sections = [];
+  const counts = {};
+  for (const [type, title] of SECTIONS) {
+    const items = buckets[type];
+    if (items && items.length) {
+      sections.push({ type, title, items });
+      counts[type] = items.length;
+    }
+  }
+  return { sections, counts, breaking, total: commits.length };
+}
+
+// one bullet: "- subject (scope) [hash]" with the optional bits omitted cleanly.
+function fmtItem(it) {
+  const scope = it.scope ? ` (${it.scope})` : '';
+  const hash = it.hash ? ` [${it.hash}]` : '';
+  return `- ${it.subject}${scope}${hash}`;
+}
+
+function render(res) {
+  const lines = [];
+  if (res.breaking.length) {
+    lines.push('### ⚠ BREAKING CHANGES');
+    for (const it of res.breaking) lines.push(fmtItem(it));
+    lines.push('');
+  }
+  for (const s of res.sections) {
+    lines.push(`### ${s.title}`);
+    for (const it of s.items) lines.push(fmtItem(it));
+    lines.push('');
+  }
+  if (!lines.length) return 'No changes.';
+  return lines.join('\n').trimEnd();
+}
+
+// --- git plumbing (impure, only in main) ----------------------------------
+
+function lastTag() {
+  try {
+    return execFileSync('git', ['describe', '--tags', '--abbrev=0'], {
+      encoding: 'utf8',
+    }).trim();
+  } catch (e) {
+    return ''; // no tags yet -> changelog from the root commit
+  }
+}
+
+// range like "v3.34.0..HEAD" (or just "HEAD" when there's no start ref).
+function readCommits(range) {
+  const out = execFileSync('git', ['log', '--no-merges', '--pretty=%h%x09%s', range], {
+    encoding: 'utf8',
+  });
+  const commits = [];
+  for (const line of out.split('\n')) {
+    if (!line.trim()) continue;
+    const tab = line.indexOf('\t');
+    commits.push({ hash: line.slice(0, tab), subject: line.slice(tab + 1) });
+  }
+  return commits;
+}
+
+function main() {
+  const args = process.argv.slice(2).filter((a) => a !== '--json');
+  const wantJson = process.argv.includes('--json');
+  const start = args[0] || lastTag();
+  const end = args[1] || 'HEAD';
+  const range = start ? `${start}..${end}` : end;
+  let commits;
+  try {
+    commits = readCommits(range);
+  } catch (e) {
+    process.stderr.write(`git failed: ${e.message}\n`);
+    process.exit(2);
+  }
+  const res = build(commits);
+  if (res.error) {
+    process.stderr.write(res.error + '\n');
+    process.exit(2);
+  }
+  if (wantJson) {
+    process.stdout.write(JSON.stringify({ range, ...res }, null, 2) + '\n');
+  } else {
+    process.stdout.write(render(res) + '\n');
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { build, parseSubject, render, SECTIONS };

package/scripts/det/codex-watchdog.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+'use strict';
+
+const { spawn, spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const DEFAULT_STARTUP_DEADLINE_SECONDS = 90;
+const DEFAULT_MAX_RUNTIME_SECONDS = 3600;
+const USAGE = 'usage: node scripts/det/codex-watchdog.js ' +
+  '[--startup-deadline <sec, default 90>] [--max-runtime <sec, default 3600>] ' +
+  '[--receipt <path>] -- <command...>';
+
+function positiveSeconds(value, flag) {
+  const seconds = Number(value);
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    throw new Error(`${flag} must be a positive number`);
+  }
+  return seconds;
+}
+
+function parseArgs(argv) {
+  let startupDeadlineSeconds = DEFAULT_STARTUP_DEADLINE_SECONDS;
+  let maxRuntimeSeconds = DEFAULT_MAX_RUNTIME_SECONDS;
+  let receiptPath = '';
+  let index = 0;
+
+  while (index < argv.length && argv[index] !== '--') {
+    const flag = argv[index];
+    if (flag !== '--startup-deadline' && flag !== '--max-runtime' && flag !== '--receipt') {
+      throw new Error(`unknown option: ${flag}`);
+    }
+    if (index + 1 >= argv.length || argv[index + 1] === '--') {
+      throw new Error(`${flag} needs a value`);
+    }
+    if (flag === '--startup-deadline') {
+      startupDeadlineSeconds = positiveSeconds(argv[index + 1], flag);
+    } else if (flag === '--max-runtime') {
+      maxRuntimeSeconds = positiveSeconds(argv[index + 1], flag);
+    } else {
+      receiptPath = argv[index + 1];
+    }
+    index += 2;
+  }
+
+  if (argv[index] !== '--' || index + 1 >= argv.length) {
+    throw new Error('missing command after --');
+  }
+
+  return {
+    startupDeadlineSeconds,
+    maxRuntimeSeconds,
+    receiptPath,
+    command: argv[index + 1],
+    commandArgs: argv.slice(index + 2),
+  };
+}
+
+function writeTimeoutReceipt(config, exitCode, startedAt) {
+  if (!config.receiptPath || (exitCode !== 124 && exitCode !== 125)) return;
+  const receiptPath = path.resolve(config.receiptPath);
+  const dir = path.dirname(receiptPath);
+  fs.mkdirSync(dir, { recursive: true });
+  const groupResult = spawnSync('ps', ['-o', 'pgid=', '-p', String(process.pid)], { encoding: 'utf8' });
+  const parsedGroup = groupResult.status === 0 ? Number(String(groupResult.stdout || '').trim()) : null;
+  const receipt = {
+    schema: 'atris.codex_watchdog_receipt.v1',
+    status: 'timed_out',
+    reason: exitCode === 124 ? 'silent_start' : 'max_runtime',
+    exit_code: exitCode,
+    pid: process.pid,
+    pgid: Number.isInteger(parsedGroup) && parsedGroup > 0 ? parsedGroup : null,
+    started_at: startedAt,
+    finished_at: new Date().toISOString(),
+  };
+  const tmpPath = path.join(dir, `.${path.basename(receiptPath)}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`);
+  try {
+    fs.writeFileSync(tmpPath, `${JSON.stringify(receipt, null, 2)}\n`);
+    fs.renameSync(tmpPath, receiptPath);
+  } finally {
+    try { fs.unlinkSync(tmpPath); } catch {}
+  }
+}
+
+function killProcessGroup(child) {
+  if (!child.pid) return;
+  try {
+    process.kill(-child.pid, 'SIGKILL');
+  } catch (error) {
+    if (error.code === 'ESRCH') return;
+    try {
+      child.kill('SIGKILL');
+    } catch {}
+  }
+}
+
+function runAttempt(config, remainingRuntimeMs) {
+  return new Promise((resolve) => {
+    let nullFd;
+    let child;
+    try {
+      nullFd = fs.openSync('/dev/null', 'r');
+      child = spawn(config.command, config.commandArgs, {
+        detached: true,
+        stdio: [nullFd, 'pipe', 'pipe'],
+      });
+    } catch (error) {
+      if (nullFd !== undefined) fs.closeSync(nullFd);
+      resolve({ type: 'spawn-error', error });
+      return;
+    }
+    fs.closeSync(nullFd);
+
+    let sawOutput = false;
+    let stopReason = null;
+    let spawnError = null;
+
+    const markStarted = () => {
+      sawOutput = true;
+    };
+    child.stdout.once('data', markStarted);
+    child.stderr.once('data', markStarted);
+    child.stdout.pipe(process.stdout, { end: false });
+    child.stderr.pipe(process.stderr, { end: false });
+
+    const stop = (reason) => {
+      if (stopReason) return;
+      stopReason = reason;
+      killProcessGroup(child);
+    };
+
+    const startupTimer = setTimeout(() => {
+      if (!sawOutput) stop('silent-start');
+    }, Math.ceil(config.startupDeadlineSeconds * 1000));
+    const runtimeTimer = setTimeout(() => {
+      stop('max-runtime');
+    }, remainingRuntimeMs);
+
+    child.once('error', (error) => {
+      spawnError = error;
+      if (!stopReason) stopReason = 'spawn-error';
+    });
+    child.once('close', (code, signal) => {
+      clearTimeout(startupTimer);
+      clearTimeout(runtimeTimer);
+      if (spawnError) {
+        resolve({ type: 'spawn-error', error: spawnError });
+      } else if (stopReason) {
+        resolve({ type: stopReason });
+      } else {
+        resolve({ type: 'exit', code, signal });
+      }
+    });
+  });
+}
+
+async function run(config) {
+  const startedAt = Date.now();
+  const maxRuntimeMs = Math.ceil(config.maxRuntimeSeconds * 1000);
+
+  for (let attempt = 1; attempt <= 2; attempt += 1) {
+    const remainingRuntimeMs = maxRuntimeMs - (Date.now() - startedAt);
+    if (remainingRuntimeMs <= 0) {
+      process.stderr.write(`watchdog: max runtime of ${config.maxRuntimeSeconds}s exceeded\n`);
+      return 125;
+    }
+
+    const result = await runAttempt(config, remainingRuntimeMs);
+    if (result.type === 'silent-start') {
+      if (attempt === 1) {
+        process.stderr.write(
+          `watchdog: silent start after ${config.startupDeadlineSeconds}s, retrying once\n`
+        );
+        continue;
+      }
+      process.stderr.write('watchdog: silent start twice, giving up\n');
+      return 124;
+    }
+    if (result.type === 'max-runtime') {
+      process.stderr.write(`watchdog: max runtime of ${config.maxRuntimeSeconds}s exceeded\n`);
+      return 125;
+    }
+    if (result.type === 'spawn-error') {
+      process.stderr.write(`watchdog: could not start command: ${result.error.message}\n`);
+      return 127;
+    }
+    if (result.code !== null) return result.code;
+    if (result.signal) {
+      process.kill(process.pid, result.signal);
+      return 1;
+    }
+    return 1;
+  }
+
+  return 124;
+}
+
+async function main() {
+  const startedAt = new Date().toISOString();
+  let config;
+  try {
+    config = parseArgs(process.argv.slice(2));
+  } catch (error) {
+    process.stderr.write(`watchdog: ${error.message}\n${USAGE}\n`);
+    process.exitCode = 2;
+    return;
+  }
+  process.exitCode = await run(config);
+  try {
+    writeTimeoutReceipt(config, process.exitCode, startedAt);
+  } catch (error) {
+    process.stderr.write(`watchdog: could not write timeout receipt: ${error.message}\n`);
+  }
+}
+
+main();

package/scripts/det/commit-msg.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+// det/commit-msg.js — draft a Conventional-Commits message from the STAGED diff.
+// Replaces the "write me a commit message" ask: the type/scope come from the
+// file paths and the body from the diff stats, so it is exact and reproducible,
+// not an LLM guess about intent.
+//
+// Usage:
+//   git add -A && node commit-msg.js          # print the drafted message
+//   node commit-msg.js --json                 # structured {type,scope,subject,body,...}
+//
+// Reads `git diff --cached` itself; no stdin needed. Exit 2 if nothing staged.
+// The pure core draft(files) is exported and unit-tested.
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+
+// --- pure core (no git, no process) ---------------------------------------
+
+const VERB = { A: 'add', M: 'update', D: 'remove', R: 'rename', C: 'copy' };
+
+function isMd(p) {
+  return /\.md$/i.test(p);
+}
+function isTest(p) {
+  return /(^|\/)tests?\//.test(p) || /\.test\.[jt]s$/.test(p);
+}
+function isChore(p) {
+  return (
+    /^(scripts|\.github)\//.test(p) ||
+    /(^|\/)(package(-lock)?\.json|\.eslintrc.*|\.gitignore|\.npmignore)$/.test(p) ||
+    /\.ya?ml$/.test(p)
+  );
+}
+
+// scope = basename of the deepest directory common to every changed file.
+function commonDirScope(paths) {
+  if (paths.length === 0) return '';
+  const dirSegs = paths.map((p) => p.split('/').slice(0, -1));
+  let common = dirSegs[0];
+  for (const segs of dirSegs.slice(1)) {
+    let i = 0;
+    while (i < common.length && i < segs.length && common[i] === segs[i]) i += 1;
+    common = common.slice(0, i);
+  }
+  return common.length ? common[common.length - 1] : '';
+}
+
+function pickType(files) {
+  const paths = files.map((f) => f.path);
+  if (paths.every(isMd)) return 'docs';
+  if (paths.every(isTest)) return 'test';
+  if (paths.every(isChore)) return 'chore';
+  if (files.some((f) => f.status === 'A')) return 'feat';
+  return 'fix';
+}
+
+// The one file that best represents the change: prefer an added file, then the
+// biggest churn, tie-broken by path so the pick is stable across runs.
+function leadFile(files) {
+  return [...files].sort((a, b) => {
+    const addedA = a.status === 'A' ? 1 : 0;
+    const addedB = b.status === 'A' ? 1 : 0;
+    if (addedA !== addedB) return addedB - addedA;
+    const churnA = (a.added || 0) + (a.deleted || 0);
+    const churnB = (b.added || 0) + (b.deleted || 0);
+    if (churnA !== churnB) return churnB - churnA;
+    return a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
+  })[0];
+}
+
+function summarize(files) {
+  const lead = leadFile(files);
+  const verb = VERB[lead.status] || 'update';
+  const name = lead.path.split('/').pop();
+  if (files.length === 1) return `${verb} ${name}`;
+  // name the lead file instead of an anonymous count ("update 3 files"):
+  // that count is the exact slop this script exists to kill.
+  return `${verb} ${name} (+${files.length - 1} more)`;
+}
+
+// files: [{ path, status, added, deleted }] -> { type, scope, summary, subject, body, totals }
+function draft(files) {
+  if (!Array.isArray(files) || files.length === 0) {
+    return { error: 'no staged changes' };
+  }
+  const type = pickType(files);
+  let scope = commonDirScope(files.map((f) => f.path));
+  if (scope === type) scope = ''; // avoid redundant test(test): / docs(docs):
+  const summary = summarize(files);
+  const subject = `${type}${scope ? `(${scope})` : ''}: ${summary}`;
+  const totals = files.reduce(
+    (a, f) => ({ added: a.added + (f.added || 0), deleted: a.deleted + (f.deleted || 0) }),
+    { added: 0, deleted: 0 }
+  );
+  const lines = files.map(
+    (f) => `- ${f.status} ${f.path} (+${f.added || 0}/-${f.deleted || 0})`
+  );
+  const body = `${lines.join('\n')}\n\n${files.length} file${
+    files.length === 1 ? '' : 's'
+  } changed, +${totals.added}/-${totals.deleted}`;
+  return { type, scope, summary, subject, body, totals, files };
+}
+
+// --- git plumbing (impure, only in main) ----------------------------------
+
+// Merge `--numstat` (added/deleted) with `--name-status` (A/M/D) by path.
+function readStaged() {
+  const numstat = execFileSync('git', ['diff', '--cached', '--numstat'], { encoding: 'utf8' });
+  const names = execFileSync('git', ['diff', '--cached', '--name-status'], { encoding: 'utf8' });
+  const stat = {};
+  for (const line of numstat.split('\n')) {
+    if (!line.trim()) continue;
+    const [added, deleted, path] = line.split('\t');
+    stat[path] = { added: added === '-' ? 0 : Number(added), deleted: deleted === '-' ? 0 : Number(deleted) };
+  }
+  const files = [];
+  for (const line of names.split('\n')) {
+    if (!line.trim()) continue;
+    const parts = line.split('\t');
+    const status = parts[0][0]; // R100 -> R
+    const path = parts[parts.length - 1];
+    files.push({ path, status, added: (stat[path] || {}).added || 0, deleted: (stat[path] || {}).deleted || 0 });
+  }
+  return files;
+}
+
+function main() {
+  const wantJson = process.argv.includes('--json');
+  let files;
+  try {
+    files = readStaged();
+  } catch (e) {
+    process.stderr.write(`git failed: ${e.message}\n`);
+    process.exit(2);
+  }
+  const res = draft(files);
+  if (res.error) {
+    process.stderr.write(res.error + '\n');
+    process.exit(2);
+  }
+  if (wantJson) {
+    process.stdout.write(JSON.stringify(res, null, 2) + '\n');
+  } else {
+    process.stdout.write(`${res.subject}\n\n${res.body}\n`);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { draft, commonDirScope, pickType, summarize, leadFile };