atris 3.63.0 → 3.65.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,8 +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: fastest installed writer that answers: Gemini
-# Flash through agy, then Haiku, Codex, Cursor),
+# 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
@@ -372,40 +373,85 @@ 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"
+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 ;;
-    claude) run_haiku ;;
-    codex) run_with_timeout 240 codex exec --sandbox read-only --skip-git-repo-check "$PROMPT" </dev/null ;;
-    cursor-agent) run_with_timeout 240 cursor-agent --trust -p "$PROMPT" ;;
+    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
 }
 
 run_auto() {
-  local entry cmd label out tried=""
-  for entry in $AUTO_WRITERS; do
-    cmd="${entry%%:*}"
-    label="${entry#*:}"
+  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" 2>>"$WORK/yt_${ID}.engine.err") && printf '%s' "$out" | grep -q '[[:alnum:]]'; then
+    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

package/scripts/det/ytrail-bench.js

@@ -12,6 +12,7 @@ const { spawnSync } = require('node:child_process');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
+const { stateHome } = require('../../lib/state-home');
 const { evaluate, appendRow } = require('./ytrail-eval');
 
 const YTNOTES = path.join(__dirname, 'ytnotes');
@@ -186,7 +187,7 @@ function main() {
     console.error('usage: ytrail-bench [--quick] [--case <name>]');
     process.exit(2);
   }
-  const outDir = process.env.YTRAIL_OUT_DIR || path.join(os.homedir(), '.atris', 'benchmarks');
+  const outDir = process.env.YTRAIL_OUT_DIR || path.join(stateHome(), '.atris', 'benchmarks');
   const started = Date.now();
   const results = [];
   for (const c of cases) {

package/utils/auth.js

@@ -1,5 +1,6 @@
 const os = require('os');
 const path = require('path');
+const { stateHome } = require('../lib/state-home');
 const fs = require('fs');
 const { exec } = require('child_process');
 const readline = require('readline');
@@ -171,8 +172,7 @@ function restrictToOwner(filePath) {
 }
 
 function getAtrisDir() {
-  const homeDir = os.homedir();
-  return mkPrivateDir(path.join(homeDir, '.atris'));
+  return mkPrivateDir(path.join(stateHome(), '.atris'));
 }
 
 function getCredentialsPath() {
@@ -182,7 +182,7 @@ function getCredentialsPath() {
 function getPlacedAgentTokenPath() {
   const override = process.env.ATRIS_AGENT_TOKEN_FILE;
   if (override && override.trim()) return override.trim();
-  return path.join(os.homedir(), '.atris', 'agent-token.json');
+  return path.join(stateHome(), '.atris', 'agent-token.json');
 }
 
 function expiryTimeMs(value) {

package/utils/update-check.js

@@ -1,13 +1,13 @@
 const https = require('https');
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
+const { stateHome } = require('../lib/state-home');
 const { spawn, spawnSync } = require('child_process');
 
 const PACKAGE_NAME = 'atris';
 const NPM_SELF_UPDATE_COMMAND = `npm install -g ${PACKAGE_NAME}@latest`;
 const CHECK_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
-const ATRIS_DIR = path.join(os.homedir(), '.atris');
+const ATRIS_DIR = path.join(stateHome(), '.atris');
 const CACHE_FILE = path.join(ATRIS_DIR, '.update-check');
 
 /**