atris 3.25.2 → 3.27.0

package/commands/moves.js

@@ -0,0 +1,156 @@
+'use strict';
+
+// `atris moves`: alive onboarding. Shows the 3 highest-leverage next moves and
+// lets you approve (seed it into the loop), kill (stop suggesting it), or skip.
+// This is the seed of proactiveness: the workspace proposes, you steer.
+
+const readline = require('readline');
+const {
+  nextMoves,
+  recordDecision,
+  seedInboxFromMove,
+} = require('../lib/next-moves');
+
+function currentMoves(root, limit) {
+  return nextMoves(root, limit);
+}
+
+function renderMoves(moves) {
+  if (!moves.length) {
+    return [
+      '',
+      'your next moves',
+      '',
+      '  nothing queued. add an item to ROADMAP.md under "## Open loop items",',
+      '  or jot an idea with `atris log`.',
+      '',
+    ].join('\n');
+  }
+  const lines = ['', 'your next moves', ''];
+  moves.forEach((m, i) => {
+    lines.push(`  ${i + 1}. ${m.title}`);
+    lines.push(`     why: ${m.why}   id: ${m.id}`);
+    lines.push('');
+  });
+  lines.push('  approve:  atris moves --approve <id|N>   seed it into the loop');
+  lines.push('  kill:     atris moves --kill <id|N>      stop suggesting it');
+  lines.push('  (use the id when you act later; the numbered order can shift)');
+  lines.push('');
+  return lines.join('\n');
+}
+
+function parseIndexes(value) {
+  return String(value || '')
+    .split(/[\s,]+/)
+    .map((s) => parseInt(s, 10))
+    .filter((n) => Number.isInteger(n) && n >= 1);
+}
+
+// Resolve --approve/--kill tokens to move objects. A token is either a stable
+// move id (m_...) or a 1-based position. The id is preferred because the list
+// can re-rank between viewing and acting, so a bare index can hit a different
+// move than the one you saw.
+function resolveSelection(moves, value) {
+  const tokens = String(value || '').split(/[\s,]+/).filter(Boolean);
+  const byId = new Map(moves.map((m) => [m.id, m]));
+  const seen = new Set();
+  const out = [];
+  for (const tok of tokens) {
+    let move = null;
+    if (byId.has(tok)) move = byId.get(tok);
+    else if (/^\d+$/.test(tok)) move = moves[parseInt(tok, 10) - 1];
+    if (move && !seen.has(move.id)) { seen.add(move.id); out.push(move); }
+  }
+  return out;
+}
+
+function applyDecision(root, selectedMoves, decision, stamp) {
+  const { claimRoadmapItem } = require('../lib/next-moves');
+  const acted = [];
+  for (const move of selectedMoves) {
+    recordDecision(root, move, decision, stamp);
+    if (decision === 'approve') {
+      // Seed then claim, mirroring the loop. For a roadmap-sourced move, mark it
+      // claimed in ROADMAP so the loop and the moves list agree it is handled.
+      const seeded = seedInboxFromMove(root, move);
+      if (move.source === 'roadmap') claimRoadmapItem(root, move.title);
+      acted.push({ move, seeded });
+    } else {
+      acted.push({ move });
+    }
+  }
+  return acted;
+}
+
+function readArgValue(args, name) {
+  const i = args.indexOf(name);
+  if (i === -1) return null;
+  return args[i + 1] || '';
+}
+
+async function movesCommand(args = [], root = process.cwd()) {
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+    console.log('');
+    console.log('Usage: atris moves [--approve <id|N>] [--kill <id|N>] [--json] [--limit N]');
+    console.log('');
+    console.log('Show the next moves and steer them. Each move has a stable id; prefer it');
+    console.log('over the position number, which can shift between viewing and acting.');
+    console.log('');
+    console.log('  atris moves                  Show the 3 next moves (prompts on a terminal)');
+    console.log('  atris moves --approve <id|N> Seed that move into the loop (writes the inbox)');
+    console.log('  atris moves --kill <id|N>    Stop suggesting that move');
+    console.log('  atris moves --json           Print the moves (with ids) as JSON, no prompt');
+    console.log('  atris moves --limit N        Show N moves (default 3)');
+    console.log('');
+    return 0;
+  }
+
+  const limitArg = readArgValue(args, '--limit');
+  const limit = limitArg && !Number.isNaN(parseInt(limitArg, 10)) ? Math.max(1, parseInt(limitArg, 10)) : 3;
+  const stamp = new Date().toISOString();
+
+  const approveVal = readArgValue(args, '--approve');
+  const killVal = readArgValue(args, '--kill');
+
+  if (approveVal !== null || killVal !== null) {
+    const moves = currentMoves(root, limit);
+    const killed = applyDecision(root, resolveSelection(moves, killVal), 'kill', stamp);
+    const approved = applyDecision(root, resolveSelection(moves, approveVal), 'approve', stamp);
+    for (const a of approved) {
+      const note = a.seeded && a.seeded.alreadyPresent ? 'already in the inbox' : 'seeded into the loop';
+      console.log(`approved: ${a.move.title}  ->  ${note}`);
+    }
+    for (const k of killed) console.log(`killed: ${k.move.title}  ->  will not suggest again`);
+    if (!approved.length && !killed.length) console.log('no matching move for that id or number.');
+    return 0;
+  }
+
+  const moves = currentMoves(root, limit);
+
+  if (args.includes('--json')) {
+    console.log(JSON.stringify({ moves }, null, 2));
+    return 0;
+  }
+
+  console.log(renderMoves(moves));
+
+  // Only prompt on a real terminal, so spawned/non-interactive runs never hang.
+  if (!process.stdin.isTTY || !moves.length) return 0;
+
+  const answer = await new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question('approve N, kill kN, or enter to skip: ', (a) => { rl.close(); resolve(a.trim()); });
+  });
+  if (!answer) return 0;
+
+  const killTokens = (answer.match(/k\s*\d+/gi) || []).map((t) => t.replace(/k/i, '').trim());
+  const approveTokens = answer.replace(/k\s*\d+/gi, '').trim();
+
+  const killed = applyDecision(root, resolveSelection(moves, killTokens.join(' ')), 'kill', stamp);
+  const approved = applyDecision(root, resolveSelection(moves, approveTokens), 'approve', stamp);
+  for (const a of approved) console.log(`approved: ${a.move.title}  ->  seeded into the loop`);
+  for (const k of killed) console.log(`killed: ${k.move.title}`);
+  return 0;
+}
+
+module.exports = { movesCommand, renderMoves, currentMoves, parseIndexes, resolveSelection };

package/commands/reel.js

@@ -0,0 +1,128 @@
+// atris reel — one line of text into a short, on-brand video (an animated card).
+//
+//   atris reel "Ship faster" --theme brand --size square
+//   atris reel "It just works." --kind quote --by "a founder" --seconds 3
+//
+// Renders frames with headless Chrome (the same one `atris card` uses) and encodes
+// with ffmpeg. No new dependency. Falls back to a card image if either is missing.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execFile, spawnSync } = require('child_process');
+const { promisify } = require('util');
+const pexec = promisify(execFile);
+const { buildReelFrame, reelFrames } = require('../lib/reel');
+const { SIZES, KINDS } = require('../lib/card');
+
+function parseFlags(argv) {
+  const flags = {}; const pos = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith('--')) {
+      const key = a.slice(2); const next = argv[i + 1];
+      if (next != null && !next.startsWith('--')) { flags[key] = next; i++; } else flags[key] = true;
+      continue;
+    }
+    pos.push(a);
+  }
+  return { flags, pos };
+}
+
+function findBin(macApps, names) {
+  for (const p of macApps) if (fs.existsSync(p)) return p;
+  for (const name of names) {
+    const r = spawnSync('command', ['-v', name], { shell: true, encoding: 'utf8' });
+    if (r.status === 0 && r.stdout.trim()) return r.stdout.trim();
+  }
+  return null;
+}
+const findChrome = () => (process.env.CHROME_PATH && fs.existsSync(process.env.CHROME_PATH))
+  ? process.env.CHROME_PATH
+  : findBin([
+      '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+      '/Applications/Chromium.app/Contents/MacOS/Chromium',
+      '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+    ], ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser', 'chrome']);
+const findFfmpeg = () => findBin(['/opt/homebrew/bin/ffmpeg', '/usr/local/bin/ffmpeg', '/usr/bin/ffmpeg'], ['ffmpeg']);
+
+async function renderFrames(chrome, ts, spec, dir, w, h, onDone) {
+  const pad = (i) => String(i).padStart(4, '0');
+  let idx = 0; let done = 0;
+  async function worker() {
+    while (idx < ts.length) {
+      const i = idx++;
+      const { html } = buildReelFrame(spec, ts[i]);
+      const hf = path.join(dir, `f-${pad(i)}.html`);
+      const pf = path.join(dir, `f-${pad(i)}.png`);
+      fs.writeFileSync(hf, html);
+      await pexec(chrome, [
+        '--headless=new', '--disable-gpu', '--hide-scrollbars', '--force-device-scale-factor=1',
+        `--window-size=${w},${h}`, '--virtual-time-budget=2200',
+        `--user-data-dir=${path.join(dir, 'ud-' + i)}`,
+        `--screenshot=${pf}`, `file://${hf}`,
+      ], { timeout: 60000 });
+      onDone && onDone(++done, ts.length);
+    }
+  }
+  const conc = Math.min(5, ts.length);
+  await Promise.all(Array.from({ length: conc }, worker));
+}
+
+async function run(argv) {
+  const { flags, pos } = parseFlags(argv);
+  if (pos[0] === 'help' || flags.help) {
+    console.log(`\n  atris reel — one line of text into a short on-brand video\n
+  atris reel "Your headline" [--kind statement|quote|stat] [--theme <name>] [--size square|og|wide|story] [--seconds 2.6]
+  flags: --sub --kicker --by --number --label --brand --version --out <file.mp4>\n`);
+    return 0;
+  }
+
+  const text = pos.join(' ').trim();
+  const kind = flags.kind || 'statement';
+  if (!KINDS.includes(kind)) { console.error(`  unknown kind "${kind}". try: ${KINDS.join(', ')}`); return 2; }
+  const size = flags.size || 'square';
+  if (!SIZES[size]) { console.error(`  unknown size "${size}". try: ${Object.keys(SIZES).join(', ')}`); return 2; }
+  if (kind === 'stat' && !flags.number && !text) { console.error('  stat reels need --number'); return 2; }
+  if (kind !== 'stat' && !text) { console.error('  give the reel some text: atris reel "Your headline"'); return 2; }
+
+  const seconds = Math.max(1, Math.min(8, parseFloat(flags.seconds) || 2.6));
+  const fps = 20;
+  const spec = {
+    kind, text, headline: text, theme: flags.theme, size,
+    sub: flags.sub, kicker: flags.kicker, by: flags.by,
+    number: flags.number, label: flags.label, brand: flags.brand, version: flags.version,
+  };
+  const { w, h } = SIZES[size];
+  const base = flags.out ? String(flags.out).replace(/\.mp4$/i, '') : `reel-${kind}-${flags.theme || 'atris'}-${size}`;
+  const outMp4 = path.resolve(`${base}.mp4`);
+
+  const chrome = findChrome();
+  if (!chrome) { console.error('\n  no Chrome found to render frames. install Chrome or set CHROME_PATH.\n'); return 1; }
+  const ffmpeg = findFfmpeg();
+  if (!ffmpeg) { console.error('\n  no ffmpeg found to encode the video. install ffmpeg (brew install ffmpeg).\n'); return 1; }
+
+  const ts = reelFrames(seconds, fps);
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-reel-'));
+  console.log(`\n  rendering ${ts.length} frames (${seconds}s, ${size})...`);
+  try {
+    await renderFrames(chrome, ts, spec, dir, w, h, (d, n) => {
+      if (d === n || d % 10 === 0) process.stdout.write(`\r  frames ${d}/${n}   `);
+    });
+    process.stdout.write('\n  encoding...\n');
+    await pexec(ffmpeg, [
+      '-y', '-framerate', String(fps), '-i', path.join(dir, 'f-%04d.png'),
+      '-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-movflags', '+faststart', outMp4,
+    ]);
+  } catch (e) {
+    console.error(`\n  render failed: ${String(e.message).split('\n')[0]}`); return 1;
+  } finally {
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+  }
+
+  if (!fs.existsSync(outMp4)) { console.error('  no video produced'); return 1; }
+  console.log(`\n  ✓ ${kind} reel, ${w}x${h}, ${seconds}s, theme ${flags.theme || 'atris'}\n    ${outMp4}\n`);
+  return 0;
+}
+
+module.exports = { run, findChrome, findFfmpeg };

package/commands/run.js

@@ -280,6 +280,35 @@ function hasWork(atrisDir) {
   return false;
 }
 
+/**
+ * Append a durable Master-loop receipt for one cycle's review verdict.
+ *
+ * Closes the loop: until now the validator's pass/fail lived only in RAM
+ * (carried to the next cycle's plan), so a crash lost it and `atris brain`
+ * could never see that the review step ran. This persists the verdict to
+ * .atris/state/master_loop_events.jsonl, the channel the brain reads for
+ * loop health. Best-effort: telemetry must never fail the run.
+ */
+function appendMasterLoopReceipt(receipt, stateDir = path.join(process.cwd(), '.atris', 'state')) {
+  try {
+    fs.mkdirSync(stateDir, { recursive: true });
+    const row = {
+      ts: new Date().toISOString(),
+      run_stamp: receipt.runStamp || null,
+      cycle: receipt.cycle,
+      verdict: receipt.verdict,
+      plan_ms: receipt.timing ? receipt.timing.plan : null,
+      do_ms: receipt.timing ? receipt.timing.do : null,
+      review_ms: receipt.timing ? receipt.timing.review : null,
+      review_summary: String(receipt.reviewOutput || '').replace(/\s+/g, ' ').trim().slice(0, 280),
+    };
+    fs.appendFileSync(path.join(stateDir, 'master_loop_events.jsonl'), JSON.stringify(row) + '\n');
+    return row;
+  } catch (_) {
+    return null;
+  }
+}
+
 /**
  * Log completion to journal
  */
@@ -453,6 +482,10 @@ async function runAtris(options = {}) {
       // Carry the review output into the next cycle's plan — closes the loop
       lastReviewOutput = reviewOutput;
 
+      // Persist the verdict durably so the brain can see the review actually ran.
+      const verdict = reviewOutput.includes('[REVIEW_FAILED]') ? 'fail' : 'pass';
+      appendMasterLoopReceipt({ runStamp, cycle, verdict, timing, reviewOutput });
+
       if (reviewOutput.includes('[REVIEW_FAILED]')) {
         console.log(verbose
           ? '⚠ Review found issues. Stopping for manual check.'
@@ -989,4 +1022,4 @@ function diffRunLogs(args = []) {
   }
 }
 
-module.exports = { runAtris, getRunLogDir, getRunLogPath, writePhaseToRunLog, listRunLogs, pruneRunLogs, searchRunLogs, statsRunLogs, exportRunLogs, diffRunLogs, buildRunPrompt };
+module.exports = { runAtris, getRunLogDir, getRunLogPath, writePhaseToRunLog, appendMasterLoopReceipt, listRunLogs, pruneRunLogs, searchRunLogs, statsRunLogs, exportRunLogs, diffRunLogs, buildRunPrompt };

package/commands/signup.js

@@ -0,0 +1,101 @@
+// atris signup <handle>
+//
+// One-call seedless agent signup. A brand-new agent with no account hits
+// POST /api/auth/agent/signup (unauthenticated) and gets back a real, INERT
+// Atris identity + token, then we write the active profile so `atris play`
+// works on the very next command. This closes the install -> signup -> play
+// seam: `npm i -g atris && atris signup x && atris play`.
+//
+// The account is born inert by design (0 credits, no executing agent, external
+// mail paid-gated) — identity is free, capability is earned via AgentXP.
+// Backend: backend/routers/agent_auth_router.py (POST /auth/agent/signup).
+
+const crypto = require('crypto');
+const { apiRequestJson, getApiBaseUrl } = require('../utils/api');
+const { saveCredentials } = require('../utils/auth');
+
+// Mirror the server rule exactly (^[a-z0-9]{3,30}$) so we fail fast and friendly
+// before spending a network round trip / a rate-limit slot.
+const HANDLE_RE = /^[a-z0-9]{3,30}$/;
+
+// Proof-of-work — mirror the server (agent_auth_router.py). The signup endpoint
+// requires a nonce whose sha256(prefix:handle:bucket:nonce) has DIFFICULTY_BITS
+// leading zero bits. Bucket = current 5-min window. Solved locally (~1s) so
+// signup stays a single call; this is the cost that makes mass-minting expensive.
+const POW_PREFIX = 'atris-signup-v1';
+const POW_WINDOW_S = 300;
+const POW_DIFFICULTY_BITS = 20;
+
+function solvePow(handle) {
+  const bucket = Math.floor(Date.now() / 1000 / POW_WINDOW_S);
+  const fullBytes = Math.floor(POW_DIFFICULTY_BITS / 8);
+  const remBits = POW_DIFFICULTY_BITS % 8;
+  for (let n = 0; ; n++) {
+    const d = crypto.createHash('sha256').update(`${POW_PREFIX}:${handle}:${bucket}:${n}`).digest();
+    let ok = true;
+    for (let i = 0; i < fullBytes; i++) { if (d[i] !== 0) { ok = false; break; } }
+    if (ok && remBits && (d[fullBytes] >> (8 - remBits)) !== 0) ok = false;
+    if (ok) return String(n);
+  }
+}
+
+function parseHandle(args = []) {
+  const positional = args.find((a) => a && !a.startsWith('-'));
+  return (positional || '').trim().toLowerCase();
+}
+
+async function signupCommand(args = []) {
+  const handle = parseHandle(args);
+
+  if (!handle) {
+    console.error('Usage: atris signup <handle>');
+    console.error('  handle: 3–30 characters, lowercase letters and digits only.');
+    return 1;
+  }
+  if (!HANDLE_RE.test(handle)) {
+    console.error(`✗ Invalid handle "${handle}".`);
+    console.error('  Must be 3–30 characters, lowercase letters and digits (a–z, 0–9). No spaces or symbols.');
+    return 1;
+  }
+
+  console.log(`Claiming @${handle} … (solving proof-of-work)`);
+  const pow = solvePow(handle);
+
+  const res = await apiRequestJson('/auth/agent/signup', {
+    method: 'POST',
+    body: { handle, pow },
+  });
+
+  if (res.ok && res.data && res.data.token) {
+    const { token, email, user_id: userId } = res.data;
+    const identity = email || `${handle}@atrismail.com`;
+    saveCredentials(token, null, identity, userId || null, 'atrisos');
+    console.log(`\n✓ You're in — ${identity}`);
+    console.log('  Inert starter account (0 credits): identity is free, capability is earned.');
+    console.log('  Saved to your active profile.');
+    console.log('\nNext:');
+    console.log('  atris play     # claim a starter mission and earn your first proof-backed rep');
+    console.log('  atris xp       # see where you stand on the board');
+    return 0;
+  }
+
+  // Friendly, actionable errors — no stack traces for expected cases.
+  if (res.status === 409) {
+    console.error(`✗ "${handle}" is already taken or reserved. Try a different handle.`);
+    return 1;
+  }
+  if (res.status === 429) {
+    console.error('✗ Too many signups right now. Wait a minute and try again.');
+    return 1;
+  }
+  if (res.status === 404) {
+    console.error('✗ Seedless signup isn’t available on this backend yet.');
+    console.error('  Use `atris login` for now, or try again after the next deploy.');
+    return 1;
+  }
+  console.error(`✗ Signup failed: ${res.error || 'unknown error'} (status ${res.status}).`);
+  console.error(`  API: ${getApiBaseUrl()}`);
+  return 1;
+}
+
+module.exports = { signupCommand, parseHandle, HANDLE_RE };

package/commands/site.js

@@ -0,0 +1,48 @@
+// atris site — turn a folder of markdown (docs, your wiki, memory) into a
+// beautiful, navigable static site in the design system. Built on lib/site.js.
+//
+//   atris site <dir|doc.md> [--out dist] [--theme atris|terminal|paper] [--title T] [--serve]
+
+const { buildSite, serveSite } = require('../lib/site');
+
+function flag(argv, name) { const i = argv.indexOf(name); return i !== -1 ? argv[i + 1] : null; }
+function hasFlag(argv, name) { return argv.includes(name); }
+
+async function run(argv) {
+  const input = argv.find((a) => !a.startsWith('-'));
+  if (!input || input === 'help' || hasFlag(argv, '--help')) {
+    console.log(`
+  atris site — a beautiful static site from a folder of markdown
+
+    atris site <dir|doc.md> [--out dist] [--theme atris|terminal|paper] [--title T]
+    atris site atris/wiki --title "Atris Wiki" --serve
+
+  Each .md becomes a page; an index links them all. Same anti-slop design system,
+  semantic data-atris-block sections, ready for the web app. --serve previews it.
+`);
+    return input === 'help' || hasFlag(argv, '--help') ? 0 : 2;
+  }
+
+  let res;
+  try {
+    res = buildSite(input, {
+      out: flag(argv, '--out') || 'dist',
+      theme: flag(argv, '--theme'),
+      title: flag(argv, '--title'),
+      brand: flag(argv, '--brand'),
+    });
+  } catch (e) { console.error(`  ${e.message}`); return 2; }
+
+  console.log(`\n  ✓ site built: ${res.pages.length} page${res.pages.length === 1 ? '' : 's'} + index -> ${res.outDir}/`);
+  console.log(`    open ${res.indexPath}`);
+
+  if (hasFlag(argv, '--serve')) {
+    const port = Number(flag(argv, '--port')) || 4321;
+    const { url } = await serveSite(res.outDir, port);
+    console.log(`\n  serving at ${url} (ctrl-c to stop)\n`);
+    await new Promise(() => {}); // keep alive until killed
+  }
+  return 0;
+}
+
+module.exports = { run };