atris 3.62.0 → 3.64.0

package/scripts/det/xsearch-bench.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+'use strict';
+
+// Bench what users get from `atris x-search`, end to end.
+// Usage: node scripts/det/xsearch-bench.js [--quick|--free] [--case <name>]
+//   default: every case, 2 paid searches (10 credits)
+//   --quick: topic plus the free cases (5 credits)
+//   --free:  free cases only (0 credits)
+// Prints one line per case and a final "bench: X/Y passed in Ns"; exits 1 if
+// any case fails. Rows (with a `case` field) go to $XSEARCH_OUT_DIR/xsearch.jsonl,
+// default ~/.atris/benchmarks, outside any git repo. A failed paid case also
+// keeps its full output there, since it cost credits to get.
+// bin/atris.js is resolved next to this file, so an installed copy benches itself.
+
+const { spawn } = require('node:child_process');
+const fs = require('node:fs');
+const http = require('node:http');
+const os = require('node:os');
+const path = require('node:path');
+const { checkXPosts } = require('../../lib/x-post-check');
+
+const ATRIS = path.join(__dirname, '..', '..', 'bin', 'atris.js');
+const FIXTURE = path.join(__dirname, 'data', 'xsearch-answer.json');
+const PAID_TIMEOUT_MS = 180000;
+const STRANGER_TIMEOUT_MS = 60000;
+const CHECKED_MIN = 0.6;
+
+const CASES = [
+  { name: 'topic', kind: 'paid', args: ['x-search', 'AI agent startups launch', '--limit', '5', '--days', '2'], minPosts: 3, quick: true },
+  { name: 'person', kind: 'paid', args: ['x-search', 'person', '--name', 'Garry Tan', '--handle', 'garrytan'], minPosts: 1 },
+  { name: 'stranger-logged-out', kind: 'stranger', args: ['x-search', 'AI agent startups launch', '--limit', '5', '--days', '2'], quick: true, free: true },
+  { name: 'offline-check', kind: 'offline', quick: true, free: true },
+];
+
+function parseArgs(argv) {
+  const opts = { quick: false, free: false, only: null };
+  for (let i = 0; i < argv.length; i += 1) {
+    if (argv[i] === '--quick') opts.quick = true;
+    else if (argv[i] === '--free') opts.free = true;
+    else if (argv[i] === '--case') opts.only = argv[++i] || '';
+    else if (argv[i].startsWith('--case=')) opts.only = argv[i].slice('--case='.length);
+    else throw new Error(`unknown option: ${argv[i]}`);
+  }
+  return opts;
+}
+
+function selectCases(opts, cases = CASES) {
+  if (opts.only !== null) {
+    const found = cases.filter((c) => c.name === opts.only);
+    if (!found.length) {
+      throw new Error(`unknown case: ${opts.only} (cases: ${cases.map((c) => c.name).join(', ')})`);
+    }
+    return found;
+  }
+  if (opts.free) return cases.filter((c) => c.free);
+  return opts.quick ? cases.filter((c) => c.quick) : cases.slice();
+}
+
+// x-search prints "posts: N checked, N unverified, N unknown" at the end.
+function parseTally(stdout) {
+  const match = String(stdout || '').match(/posts: (\d+) checked, (\d+) unverified, (\d+) unknown/);
+  if (!match) return null;
+  return { checked: Number(match[1]), unverified: Number(match[2]), unknown: Number(match[3]) };
+}
+
+// Pure pass/fail rules. Each takes a finished run and returns { pass, note }.
+// Posts = checked citations plus unverified quotes. Unknown (X could not be
+// reached) counts neither way.
+function postCount(tally) {
+  return tally ? tally.checked + tally.unverified : 0;
+}
+
+function judgePaid({ status, tally, minPosts }) {
+  const posts = postCount(tally);
+  const share = posts ? tally.checked / posts : 0;
+  if (status !== 0) return { pass: false, posts, note: 'search failed' };
+  if (!tally) return { pass: false, posts, note: 'no posts found to check' };
+  if (posts < minPosts) return { pass: false, posts, note: `only ${posts} posts, wanted ${minPosts}` };
+  if (share < CHECKED_MIN) return { pass: false, posts, note: `only ${Math.round(share * 100)}% checked` };
+  return { pass: true, posts, note: `${Math.round(share * 100)}% checked` };
+}
+
+function judgeStranger({ status, text, hits }) {
+  const told = /not signed in|atris login/i.test(String(text || ''));
+  const pass = told && typeof status === 'number' && status !== 0 && hits === 0;
+  let note = 'says to log in, nothing charged';
+  if (!told) note = 'did not say to log in';
+  else if (hits) note = `reached the server ${hits} time(s)`;
+  else if (status === 0) note = 'exited 0 without logging in';
+  return { pass, note };
+}
+
+function fixtureFetch(embeds, downId = null) {
+  return async (id) => {
+    if (id === downId) return { id, ok: false, error: 'timeout' };
+    if (!(id in embeds)) return { id, ok: false, error: 'not in fixture' };
+    const post = embeds[id];
+    return post ? { id, ok: true, post: { id, handle: post.handle, text: post.text, createdAt: null } } : { id, ok: true, post: null };
+  };
+}
+
+// Run the checker on the saved answer twice: once with X answering every
+// lookup, once with one lookup timing out. No network.
+async function runOfflineCheck(fixture = JSON.parse(fs.readFileSync(FIXTURE, 'utf8'))) {
+  const up = await checkXPosts({ content: fixture.content, citations: fixture.citations, fetchPost: fixtureFetch(fixture.embeds) });
+  const down = await checkXPosts({
+    content: fixture.content,
+    citations: fixture.citations,
+    fetchPost: fixtureFetch(fixture.embeds, fixture.expect.one_down.down_id),
+  });
+  const want = fixture.expect;
+  const upOk = Boolean(up)
+    && up.tally.checked === want.all_up.checked
+    && up.tally.unverified === want.all_up.unverified
+    && up.tally.unknown === want.all_up.unknown
+    && up.otherSources.length === want.all_up.other_sources;
+  const downOk = Boolean(down)
+    && down.tally.checked === want.one_down.checked
+    && down.tally.unverified === want.one_down.unverified
+    && down.tally.unknown === want.one_down.unknown;
+  return {
+    pass: upOk && downOk,
+    tally: up ? up.tally : null,
+    note: !upOk ? 'wrong result with X answering' : !downOk ? 'wrong result with X down' : 'checked, unverified, and unknown all land right',
+  };
+}
+
+// Count every request so the stranger case can prove it never reached the server.
+function startCountingServer() {
+  return new Promise((resolve, reject) => {
+    const state = { hits: 0 };
+    const server = http.createServer((req, res) => {
+      state.hits += 1;
+      res.writeHead(401, { 'content-type': 'application/json' });
+      res.end('{"detail":"bench server"}');
+    });
+    server.on('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      state.url = `http://127.0.0.1:${server.address().port}`;
+      state.close = () => new Promise((done) => server.close(() => done()));
+      resolve(state);
+    });
+  });
+}
+
+function runAtris(args, { env, cwd, timeoutMs }) {
+  return new Promise((resolve) => {
+    const started = Date.now();
+    const child = spawn(process.execPath, [ATRIS, ...args], { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (d) => { stdout += d; });
+    child.stderr.on('data', (d) => { stderr += d; });
+    const timer = setTimeout(() => child.kill('SIGKILL'), timeoutMs);
+    child.on('close', (status) => {
+      clearTimeout(timer);
+      resolve({ status, stdout, stderr, seconds: Number(((Date.now() - started) / 1000).toFixed(1)) });
+    });
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      resolve({ status: null, stdout, stderr: `${stderr}${err.message}`, seconds: Number(((Date.now() - started) / 1000).toFixed(1)) });
+    });
+  });
+}
+
+// Run x-search as a stranger would: a bare HOME with no login, and the backend
+// pointed at a local server that counts requests.
+async function runStranger(args) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'xsearch-stranger-'));
+  const server = await startCountingServer();
+  try {
+    const run = await runAtris(args, {
+      cwd: tmp,
+      env: {
+        HOME: tmp,
+        PATH: `${path.dirname(process.execPath)}:/usr/bin:/bin`,
+        TMPDIR: tmp,
+        ATRIS_API_URL: `${server.url}/api`,
+        ATRIS_BACKEND_URL: server.url,
+        ATRIS_APP_URL: server.url,
+        CI: '1',
+      },
+      timeoutMs: STRANGER_TIMEOUT_MS,
+    });
+    return { ...run, hits: server.hits };
+  } finally {
+    await server.close();
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+function lastLines(text, n = 3) {
+  return String(text || '').trim().split('\n').filter(Boolean).slice(-n).map((line) => `  ${line}`).join('\n');
+}
+
+function tallyText(t) {
+  return t ? `posts=${postCount(t)} checked=${t.checked} unverified=${t.unverified} unknown=${t.unknown}` : 'posts=0';
+}
+
+// Keep what a failed paid search printed, so the miss can be read later
+// without paying for another search.
+function saveFailedOutput(dir, name, ts, text) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, `xsearch-${name}-${ts.replace(/[:.]/g, '-')}.txt`);
+    fs.writeFileSync(file, text);
+    return file;
+  } catch {
+    return null;
+  }
+}
+
+async function runCase(c, outDir) {
+  const ts = new Date().toISOString();
+  if (c.kind === 'offline') {
+    const started = Date.now();
+    const verdict = await runOfflineCheck();
+    const seconds = Number(((Date.now() - started) / 1000).toFixed(1));
+    const t = verdict.tally;
+    return {
+      pass: verdict.pass,
+      line: `${c.name} ${verdict.pass ? 'pass' : 'fail'} ${seconds}s (${verdict.note}) ${tallyText(t)}`,
+      row: {
+        ts, case: c.name, seconds, pass: verdict.pass, exit: null,
+        posts: postCount(t),
+        checked: t ? t.checked : 0, unverified: t ? t.unverified : 0, unknown: t ? t.unknown : 0,
+      },
+    };
+  }
+
+  if (c.kind === 'stranger') {
+    const run = await runStranger(c.args);
+    const verdict = judgeStranger({ status: run.status, text: `${run.stdout}\n${run.stderr}`, hits: run.hits });
+    return {
+      pass: verdict.pass,
+      line: `${c.name} ${verdict.pass ? 'pass' : 'fail'} ${run.seconds}s exit=${run.status === null ? 'none' : run.status} (${verdict.note})`,
+      detail: verdict.pass ? '' : lastLines(`${run.stdout}\n${run.stderr}`),
+      row: { ts, case: c.name, seconds: run.seconds, pass: verdict.pass, exit: run.status, posts: 0, checked: 0, unverified: 0, unknown: 0, hits: run.hits },
+    };
+  }
+
+  const run = await runAtris(c.args, { cwd: os.tmpdir(), env: process.env, timeoutMs: PAID_TIMEOUT_MS });
+  const tally = parseTally(run.stdout);
+  const verdict = judgePaid({ status: run.status, tally, minPosts: c.minPosts });
+  const saved = verdict.pass ? null : saveFailedOutput(outDir, c.name, ts, `${run.stdout}\n${run.stderr}`);
+  return {
+    pass: verdict.pass,
+    line: `${c.name} ${verdict.pass ? 'pass' : 'fail'} ${run.seconds}s exit=${run.status === null ? 'none' : run.status} (${verdict.note}) ${tallyText(tally)}`,
+    detail: verdict.pass ? '' : [lastLines(`${run.stdout}\n${run.stderr}`), saved ? `  full output: ${saved}` : null].filter(Boolean).join('\n'),
+    row: {
+      ts, case: c.name, seconds: run.seconds, pass: verdict.pass, exit: run.status,
+      posts: verdict.posts,
+      checked: tally ? tally.checked : 0, unverified: tally ? tally.unverified : 0, unknown: tally ? tally.unknown : 0,
+      ...(saved ? { output: saved } : {}),
+    },
+  };
+}
+
+function summary(results, seconds) {
+  const passed = results.filter((r) => r.pass).length;
+  return `bench: ${passed}/${results.length} passed in ${seconds}s`;
+}
+
+function appendRow(dir, row) {
+  fs.mkdirSync(dir, { recursive: true });
+  fs.appendFileSync(path.join(dir, 'xsearch.jsonl'), `${JSON.stringify(row)}\n`);
+}
+
+async function main() {
+  let cases;
+  try {
+    cases = selectCases(parseArgs(process.argv.slice(2)));
+  } catch (err) {
+    console.error(err.message);
+    console.error('usage: xsearch-bench [--quick|--free] [--case <name>]');
+    process.exit(2);
+  }
+  const outDir = process.env.XSEARCH_OUT_DIR || path.join(os.homedir(), '.atris', 'benchmarks');
+  const started = Date.now();
+  const results = [];
+  for (const c of cases) {
+    const result = await runCase(c, outDir);
+    results.push(result);
+    console.log(result.line);
+    if (result.detail) console.log(result.detail);
+    appendRow(outDir, result.row);
+  }
+  console.log(summary(results, Math.round((Date.now() - started) / 1000)));
+  process.exit(results.some((r) => !r.pass) ? 1 : 0);
+}
+
+if (require.main === module) main();
+
+module.exports = {
+  CASES,
+  FIXTURE,
+  parseArgs,
+  selectCases,
+  parseTally,
+  postCount,
+  judgePaid,
+  judgeStranger,
+  fixtureFetch,
+  runOfflineCheck,
+  saveFailedOutput,
+  summary,
+};

package/scripts/det/ytnotes

@@ -4,7 +4,9 @@
 # No captions: if mlx_whisper is installed (uv tool install mlx-whisper, Apple
 # silicon), the audio is transcribed on this machine instead. Otherwise the
 # script prints the paid command. ATRIS_YTNOTES_LOCAL_TRANSCRIBE=0 turns it off.
-# Engines: auto (default: Gemini Flash through agy, Haiku if that fails),
+# Engines: auto (default: the team's notes writer from the roster, then the
+# fastest installed writer that answers: Gemini Flash through agy, then Haiku,
+# Codex, Cursor),
 # gemini, haiku, atris-fast, grok, codex, cursor. ATRIS_YTNOTES_ENGINE sets the default.
 # Outputs: $WORK/yt_${ID}.clean.txt (transcript), $WORK/yt_${ID}.md (notes).
 set -euo pipefail
@@ -39,6 +41,30 @@ cd "$WORK"
 # #t= timestamp is stripped so leftover yt_<id> files still match. When VTT is
 # gone, leftover yt_<id>.clean.txt from a prior notes run is still a keep.
 # Another video's leftover clean.txt is not invent-keep.
+if ! command -v yt-dlp >/dev/null 2>&1; then
+  echo "This computer is missing yt-dlp, the free tool that reads YouTube captions." >&2
+  echo "Install it, then run the same command again:" >&2
+  echo "  Mac: brew install yt-dlp    Any computer: pipx install yt-dlp" >&2
+  exit 2
+fi
+
+# YouTube blocks old yt-dlp copies, and the failure looks like "no captions".
+# Warn when the version date (YYYY.MM.DD, maybe .N) is too old; keep going.
+# A version that does not parse stays silent.
+YTDLP_VERSION=$(yt-dlp --version 2>/dev/null) || true
+YTDLP_AGE=$(perl -MTime::Local -e '
+  my ($v, $max) = @ARGV;
+  exit 0 unless $max =~ /\A\d+\z/;
+  my ($y, $m, $d) = $v =~ /\A\s*(\d{4})\.(\d{1,2})\.(\d{1,2})(?:\.\d+)?\s*\z/ or exit 0;
+  my $t = eval { timelocal(0, 0, 12, $d, $m - 1, $y) };
+  exit 0 unless defined $t;
+  my $age = int((time - $t) / 86400);
+  print $age if $age > $max;
+' "$YTDLP_VERSION" "${ATRIS_YTNOTES_YTDLP_MAX_AGE_DAYS:-60}" 2>/dev/null) || true
+if [ -n "$YTDLP_AGE" ]; then
+  echo "Your yt-dlp is $YTDLP_AGE days old, and YouTube often blocks old copies. Update it: brew upgrade yt-dlp (Mac) or pipx upgrade yt-dlp" >&2
+fi
+
 existing=""
 for name in yt_*.en-orig.vtt yt_*.en.vtt yt_*.en-US.vtt yt_*.en-GB.vtt; do
   [ -e "$name" ] || continue
@@ -262,7 +288,7 @@ $TRANSCRIPT"
 run_with_timeout() {
   local seconds="$1"
   shift
-  perl -e '$seconds = shift @ARGV; alarm $seconds; exec @ARGV' "$seconds" "$@"
+  perl -e '$seconds = shift @ARGV; alarm $seconds; exec @ARGV or do { print STDERR "$ARGV[0]: not installed\n"; exit 127 }' "$seconds" "$@"
 }
 
 run_atris_fast() {
@@ -347,27 +373,97 @@ run_grok() {
 }
 
 run_haiku() {
-  run_with_timeout 240 claude -p "$PROMPT" --model claude-haiku-4-5
+  run_with_timeout 240 claude -p "$PROMPT" --model "${1:-claude-haiku-4-5}"
 }
 
 # Gemini Flash through the Antigravity CLI (agy). On an 85-minute transcript it
 # writes notes in about 8s; Haiku takes 30-40s. The old gemini CLI is retired.
+# Low effort is the floor for notes: high effort is slower and not sharper here.
 run_gemini() {
   command -v agy >/dev/null 2>&1 || { echo "agy is not installed" >&2; return 127; }
-  run_with_timeout 120 agy -p "$PROMPT" --model "${ATRIS_YTNOTES_GEMINI_MODEL:-gemini-3.8-flash}" \
-    --effort low --print-timeout 110s </dev/null
+  run_with_timeout 120 agy -p "$PROMPT" --model "${ATRIS_YTNOTES_GEMINI_MODEL:-${1:-gemini-3.8-flash}}" \
+    --effort "${2:-low}" --print-timeout 110s </dev/null
+}
+
+# Fastest installed writer that answers: Gemini, Haiku, Codex, Cursor.
+# Entries are cmd|model|effort|label; an empty model or effort means the default.
+# Buffered so a failed or empty answer never reaches the notes file.
+AUTO_WRITERS="agy|||Gemini claude|||Haiku codex|||Codex cursor-agent|||Cursor"
+
+# The team's "notes" writer, from `atris engine resolve notes --json`, run from
+# the caller's project with this same package. It only reorders: any failure,
+# a slow answer (2s), or a writer that is not installed falls back to the order
+# above. ATRIS_YTNOTES_ROSTER=0 skips it.
+resolve_roster_writers() {
+  [ "${ATRIS_YTNOTES_ROSTER:-1}" = "0" ] && return 0
+  local json=""
+  if [ -n "${ATRIS_YTNOTES_RESOLVE_CMD:-}" ]; then
+    json=$(cd "$CALLER_CWD" && run_with_timeout 2 sh -c "$ATRIS_YTNOTES_RESOLVE_CMD" 2>/dev/null) || return 0
+  else
+    [ -f "$SCRIPT_DIR/../../bin/atris.js" ] || return 0
+    json=$(cd "$CALLER_CWD" && ATRIS_AUTO_UPDATE=off run_with_timeout 2 node "$SCRIPT_DIR/../../bin/atris.js" engine resolve notes --json 2>/dev/null) || return 0
+  fi
+  printf '%s' "$json" | node -e '
+    const s = require("fs").readFileSync(0, "utf8");
+    const d = JSON.parse(s.slice(s.indexOf("{"), s.lastIndexOf("}") + 1));
+    const cmds = { agy: "agy", gemini: "agy", haiku: "claude", claude: "claude", codex: "codex", cursor: "cursor-agent", "cursor-agent": "cursor-agent" };
+    const clean = (v) => (v == null ? "" : String(v).replace(/[^A-Za-z0-9._:\/-]/g, ""));
+    const label = (cmd, model) => ({ agy: "Gemini", codex: "Codex", "cursor-agent": "Cursor" }[cmd]
+      || (/haiku/i.test(model || "haiku") ? "Haiku" : "Claude"));
+    const out = [];
+    for (const w of [d, ...(Array.isArray(d.backup) ? d.backup : [])]) {
+      const cmd = cmds[String((w && w.engine) || "").toLowerCase()];
+      if (!cmd) continue;
+      const model = clean(w.model);
+      out.push([cmd, model, clean(w.effort), label(cmd, model)].join("|"));
+    }
+    process.stdout.write(out.join(" "));
+  ' 2>/dev/null || true
+}
+
+# Roster writers first, then the rest of the built-in order, one entry per cmd.
+writer_list() {
+  local entry cmd seen=" " list=""
+  for entry in $(resolve_roster_writers) $AUTO_WRITERS; do
+    cmd="${entry%%|*}"
+    case "$seen" in *" $cmd "*) continue ;; esac
+    seen="$seen$cmd "
+    list="$list $entry"
+  done
+  printf '%s' "$list"
+}
+
+run_writer() {
+  local model="${2:-}"
+  case "$1" in
+    agy) run_gemini "$model" "${3:-}" ;;
+    claude) run_haiku "$model" ;;
+    codex) run_with_timeout 240 codex exec ${model:+-m "$model"} --sandbox read-only --skip-git-repo-check "$PROMPT" </dev/null ;;
+    cursor-agent) run_with_timeout 240 cursor-agent --trust ${model:+--model "$model"} -p "$PROMPT" ;;
+  esac
 }
 
-# Fastest writer that answers: Gemini, then Haiku. Buffered so a failed or
-# empty Gemini answer never reaches the notes file.
 run_auto() {
-  local out=""
-  if out=$(run_gemini 2>"$WORK/yt_${ID}.engine.err") && printf '%s' "$out" | grep -q '[[:alnum:]]'; then
-    printf '%s\n' "$out"
-    return 0
+  local entry cmd model effort label out tried=""
+  for entry in $(writer_list); do
+    IFS='|' read -r cmd model effort label <<< "$entry"
+    command -v "$cmd" >/dev/null 2>&1 || continue
+    if [ -n "$tried" ]; then
+      echo "$tried did not answer; writing the notes with $label instead." >&2
+    fi
+    if out=$(run_writer "$cmd" "$model" "$effort" 2>>"$WORK/yt_${ID}.engine.err") && printf '%s' "$out" | grep -q '[[:alnum:]]'; then
+      printf '%s\n' "$out"
+      echo "notes by $label" >&2
+      return 0
+    fi
+    tried="$label"
+  done
+  if [ -n "$tried" ]; then
+    echo "$tried did not answer, and no other AI writer is installed." >&2
+  else
+    echo "No AI writer is installed on this computer. Install one of: Claude Code (claude), Antigravity (agy), Codex (codex), Cursor (cursor-agent)." >&2
   fi
-  echo "Gemini did not answer; writing the notes with Haiku instead." >&2
-  run_haiku
+  return 3
 }
 
 {
@@ -385,10 +481,20 @@ run_auto() {
       run_gemini
       ;;
     grok)   run_grok ;;
-    codex)  run_with_timeout 240 codex exec --sandbox read-only --skip-git-repo-check "$PROMPT" </dev/null ;;
-    cursor) run_with_timeout 240 cursor-agent --trust -p "$PROMPT" ;;
+    codex)  run_writer codex ;;
+    cursor) run_writer cursor-agent ;;
     *) echo "unknown engine: $ENGINE (auto|gemini|haiku|atris-fast|grok|codex|cursor)" >&2; exit 1 ;;
   esac
-} | perl -0pe 's/\A.*?(?=# )//s' | tee "yt_${ID}.md"
+} | perl -0pe 's/\A.*?(?=# )//s' > "yt_${ID}.md" || true
+
+if ! grep -q '[[:alnum:]]' "yt_${ID}.md"; then
+  rm -f "yt_${ID}.md"
+  echo "No notes were written. The transcript is saved at $WORK/yt_${ID}.clean.txt" >&2
+  echo "Paid notes, 5 credits, refunded if it fails: atris youtube process \"$URL\"" >&2
+  exit 3
+fi
+# auto names its writer above; a pinned engine is named here.
+[ "$ENGINE" = "auto" ] || echo "notes by $ENGINE" >&2
+cat "yt_${ID}.md"
 
 node "$SCRIPT_DIR/ytquote-repair.js" "yt_${ID}.md" "yt_${ID}.clean.txt"