atris 3.35.0 → 3.37.0

package/commands/orb.js

@@ -0,0 +1,314 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const readline = require('node:readline');
+const { spawn } = require('node:child_process');
+const { workspaceRoot } = require('../lib/task-db');
+const { collectOrbContext, appendOrbChoice } = require('../lib/orb-context');
+const {
+  readOrbScorecard,
+  renderOrbScorecard,
+  parseOrbScorecardDays,
+} = require('../lib/orb-scorecard');
+
+const MAX_VISIBLE_SUGGESTIONS = 9;
+const MAX_CONCURRENT_JOBS = 3;
+const VALID_ENGINES = new Set(['claude', 'codex', 'fast']);
+
+function cleanLabel(value, max = 120) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+
+function slugify(value) {
+  return String(value || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 48) || 'run';
+}
+
+function parseEngine(args) {
+  const equalsArg = args.find((arg) => arg.startsWith('--engine='));
+  const flagIndex = args.indexOf('--engine');
+  const engine = equalsArg
+    ? equalsArg.slice('--engine='.length)
+    : flagIndex !== -1
+      ? args[flagIndex + 1]
+      : 'claude';
+  return String(engine || '').toLowerCase();
+}
+
+function engineInvocation(engine, prompt) {
+  if (engine === 'codex') return { command: 'codex', args: ['exec', prompt] };
+  if (engine === 'fast') return { command: 'ax', args: ['--fast', '--print', prompt] };
+  return { command: 'claude', args: ['-p', prompt] };
+}
+
+function findExecutableOnPath(command, pathValue = process.env.PATH) {
+  const candidates = String(command || '').includes(path.sep)
+    ? [command]
+    : String(pathValue || '').split(path.delimiter).filter(Boolean).map((dir) => path.join(dir, command));
+  for (const candidate of candidates) {
+    try {
+      fs.accessSync(candidate, fs.constants.X_OK);
+      return candidate;
+    } catch {}
+  }
+  return null;
+}
+
+function formatJobNotification(job) {
+  const failed = Boolean(job && job.error) || Number(job && job.exitCode) !== 0;
+  return failed
+    ? `✗ failed: ${job.label} (o to open)`
+    : `✔ ready: ${job.label} (o to open)`;
+}
+
+function renderContext(context) {
+  console.log('');
+  for (const beat of context.beats || []) console.log(beat);
+  console.log('');
+  const suggestions = (context.suggestions || []).slice(0, MAX_VISIBLE_SUGGESTIONS);
+  for (const [index, suggestion] of suggestions.entries()) {
+    const side = suggestion.side ? ` · ${suggestion.side}` : '';
+    console.log(`${index + 1}. ${suggestion.label}${side}`);
+    if (suggestion.reason) console.log(`   ${suggestion.reason}`);
+  }
+  console.log('');
+  return suggestions;
+}
+
+function renderHint() {
+  console.log('Pick 1-9, or type anything. Enter on empty = next; o = open a ready result; q = quit.');
+}
+
+function showHelp() {
+  console.log('Usage: atris orb [--once] [--engine claude|codex|fast]');
+  console.log('       atris orb scorecard [--days N]');
+  console.log('');
+  console.log('Choose a next move while background engine jobs keep working.');
+}
+
+function tailLines(text, count = 60) {
+  const lines = String(text || '').split(/\r?\n/);
+  if (lines[lines.length - 1] === '') lines.pop();
+  return lines.slice(-count).join('\n');
+}
+
+async function runOrb(args = []) {
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+    showHelp();
+    return 0;
+  }
+
+  if (args[0] === 'scorecard') {
+    const parsed = parseOrbScorecardDays(args.slice(1));
+    if (!parsed.ok) {
+      console.error(`orb scorecard: ${parsed.error}`);
+      return 2;
+    }
+    const scorecard = readOrbScorecard(workspaceRoot(), { days: parsed.days });
+    console.log(renderOrbScorecard(scorecard));
+    return 0;
+  }
+
+  const engine = parseEngine(args);
+  if (!VALID_ENGINES.has(engine)) {
+    console.error(`Unknown orb engine: ${engine || '(empty)'}. Use claude, codex, or fast.`);
+    return 2;
+  }
+
+  const engineCommand = engineInvocation(engine, '').command;
+  if (!findExecutableOnPath(engineCommand)) {
+    console.error(`orb warning: engine binary "${engineCommand}" is missing from PATH; picks will fail until it is installed.`);
+  }
+
+  const root = workspaceRoot();
+  let context = await collectOrbContext(root, { threads: [] });
+  let visibleSuggestions = renderContext(context);
+  const once = args.includes('--once') || !process.stdin.isTTY || !process.stdout.isTTY;
+  if (once) return 0;
+
+  renderHint();
+  const runsDir = path.join(root, '.atris', 'state', 'orb-runs');
+  const indexPath = path.join(runsDir, 'index.jsonl');
+  const jobs = [];
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  let closing = false;
+
+  function prompt() {
+    if (!closing) rl.prompt();
+  }
+
+  function notifyReady(job) {
+    if (closing) return;
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+    console.log(formatJobNotification(job));
+    prompt();
+  }
+
+  function runningJobs() {
+    return jobs.filter((job) => job.status === 'running');
+  }
+
+  function duplicateInFlight(label) {
+    const normalized = cleanLabel(label).toLowerCase();
+    return runningJobs().some((job) => cleanLabel(job.label).toLowerCase() === normalized);
+  }
+
+  function finishJob(job, code, error) {
+    if (job.status !== 'running') return;
+    job.exitCode = Number.isInteger(code) ? code : 1;
+    job.error = error ? String(error.message || error) : null;
+    job.status = job.exitCode === 0 && !job.error ? 'ready' : 'failed';
+    job.unread = true;
+    job.durationMs = Date.now() - job.startedAtMs;
+    if (error) {
+      try {
+        fs.appendFileSync(job.logPath, `\nengine launch failed: ${error.message || error}\n`, 'utf8');
+      } catch {}
+    }
+    const record = {
+      status: job.status,
+      ts: new Date().toISOString(),
+      label: job.label,
+      kind: job.kind,
+      engine: job.engine,
+      exitCode: job.exitCode,
+      durationMs: job.durationMs,
+      logPath: path.relative(root, job.logPath),
+      error: job.error,
+    };
+    fs.promises.appendFile(indexPath, `${JSON.stringify(record)}\n`, 'utf8').catch(() => {});
+    notifyReady(job);
+  }
+
+  async function dispatch(choice) {
+    const label = cleanLabel(choice.label);
+    if (duplicateInFlight(label)) {
+      console.log('already working on that');
+      return;
+    }
+    const running = runningJobs().length;
+    if (running >= MAX_CONCURRENT_JOBS) {
+      console.log(`that will have to wait - ${running} jobs running`);
+      return;
+    }
+
+    const appended = await appendOrbChoice(root, label);
+    if (!appended.ok) {
+      console.error(`Could not update now.md: ${appended.error}`);
+      return;
+    }
+
+    fs.mkdirSync(runsDir, { recursive: true });
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const logPath = path.join(runsDir, `${stamp}-${slugify(label)}.log`);
+    const logFd = fs.openSync(logPath, 'a');
+    const invocation = engineInvocation(engine, choice.prompt);
+    let child;
+    try {
+      child = spawn(invocation.command, invocation.args, {
+        cwd: root,
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+      });
+    } finally {
+      fs.closeSync(logFd);
+    }
+
+    const startedAt = new Date().toISOString();
+    const relativeLogPath = path.relative(root, logPath);
+    if (Number.isInteger(child.pid) && child.pid > 0) {
+      fs.appendFileSync(indexPath, `${JSON.stringify({
+        status: 'dispatched',
+        ts: startedAt,
+        label,
+        kind: choice.kind || 'freeform',
+        engine,
+        logPath: relativeLogPath,
+        pid: child.pid,
+      })}\n`, 'utf8');
+    }
+
+    const job = {
+      label,
+      kind: choice.kind || 'freeform',
+      engine,
+      startedAt,
+      startedAtMs: Date.now(),
+      logPath,
+      child,
+      status: 'running',
+      unread: false,
+    };
+    jobs.push(job);
+    child.once('error', (error) => finishJob(job, 1, error));
+    child.once('exit', (code) => finishJob(job, code));
+    child.unref();
+    console.log(`working: ${label}`);
+  }
+
+  async function refresh() {
+    context = await collectOrbContext(root, { threads: [] });
+    visibleSuggestions = renderContext(context);
+    renderHint();
+  }
+
+  async function openReady() {
+    const job = jobs.find((candidate) => ['ready', 'failed'].includes(candidate.status) && candidate.unread);
+    if (!job) {
+      console.log('No ready result yet.');
+      return;
+    }
+    job.unread = false;
+    try {
+      const output = tailLines(await fs.promises.readFile(job.logPath, 'utf8'));
+      console.log(`\n${job.label}`);
+      console.log(output || '(empty result)');
+      console.log('');
+    } catch (error) {
+      console.error(`Could not open result: ${error.message || error}`);
+    }
+  }
+
+  return await new Promise((resolve) => {
+    rl.setPrompt('> ');
+    prompt();
+    rl.on('line', async (line) => {
+      rl.pause();
+      const input = line.trim();
+      if (input.toLowerCase() === 'q') {
+        closing = true;
+        rl.close();
+        return;
+      }
+      if (!input) {
+        await refresh();
+      } else if (input.toLowerCase() === 'o') {
+        await openReady();
+      } else if (/^[1-9]$/.test(input) && visibleSuggestions[Number(input) - 1]) {
+        await dispatch(visibleSuggestions[Number(input) - 1]);
+      } else {
+        await dispatch({ label: input, kind: 'freeform', prompt: input });
+      }
+      rl.resume();
+      prompt();
+    });
+    rl.once('close', () => resolve(0));
+  });
+}
+
+module.exports = {
+  runOrb,
+  engineInvocation,
+  findExecutableOnPath,
+  formatJobNotification,
+  parseEngine,
+  renderContext,
+  tailLines,
+};

package/commands/pack-craft.js

@@ -0,0 +1,179 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function slugify(value, fallback = 'atris-pack') {
+  return String(value || fallback)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '') || fallback;
+}
+
+function titleFromSlug(slug) {
+  return String(slug || 'atris-pack')
+    .split('-')
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ') || 'Atris Pack';
+}
+
+function takeValue(args, name) {
+  const prefix = `${name}=`;
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = String(args[i]);
+    if (arg.startsWith(prefix)) {
+      args.splice(i, 1);
+      return arg.slice(prefix.length);
+    }
+    if (arg === name) {
+      const value = args[i + 1];
+      if (value === undefined || String(value).startsWith('--')) {
+        throw new Error(`${name} requires a value`);
+      }
+      args.splice(i, 2);
+      return value;
+    }
+  }
+  return null;
+}
+
+function takeFlag(args, name) {
+  const index = args.indexOf(name);
+  if (index === -1) return false;
+  args.splice(index, 1);
+  return true;
+}
+
+function shellQuote(value) {
+  const text = String(value || '.');
+  if (/^[A-Za-z0-9_./:-]+$/.test(text)) return text;
+  return `'${text.replace(/'/g, "'\\''")}'`;
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function isNonEmptyTarget(targetDir) {
+  if (!fs.existsSync(targetDir)) return false;
+  const stat = fs.statSync(targetDir);
+  if (!stat.isDirectory()) return true;
+  return fs.readdirSync(targetDir).length > 0;
+}
+
+// the registry requires a non-empty author, so fall back through the local
+// login and finally a placeholder the filler agent is told to replace
+function defaultAuthor() {
+  try {
+    const creds = JSON.parse(
+      fs.readFileSync(path.join(os.homedir(), '.atris', 'credentials.json'), 'utf8')
+    );
+    if (creds && typeof creds.email === 'string' && creds.email.trim()) return creds.email.trim();
+  } catch {
+    // not logged in; use the placeholder
+  }
+  return 'unknown author';
+}
+
+function buildCraftManifest(topic, slug) {
+  const title = titleFromSlug(slug);
+  return {
+    name: slug,
+    slug,
+    title,
+    description: `research pack on ${topic}, in progress`,
+    author: defaultAuthor(),
+    tags: [],
+    version: '0.0.1',
+    versions: [],
+  };
+}
+
+function buildAtrisBoot(topic) {
+  return [
+    '# research pack boot',
+    '',
+    `you are filling a research pack on ${topic}.`,
+    '',
+    'method:',
+    '- gather sources',
+    '- write wiki-style pages under wiki/ (one concept per file, sources cited inline as plain urls)',
+    "- keep atris/now.md updated with what is done and what is next (next = researchable questions, not tasks)",
+    '- never fabricate citations',
+    '- prefer primary sources; a secondary source is fine when the primary is unreachable, but say so inline next to the citation',
+    '- add a not-affiliated disclaimer in README.md if the topic is a person or company',
+    '',
+    'when the pack answers its topic well, bump pack.json to 0.1.0 and it is ready to publish with:',
+    '',
+    '    atris pack publish --push',
+    '',
+  ].join('\n');
+}
+
+function buildNowMd(topic) {
+  return `nothing gathered yet. start with the 3 most load-bearing questions about ${topic}.\n`;
+}
+
+function buildReadme(topic, title) {
+  return [
+    `# ${title}`,
+    '',
+    `research pack on ${topic}.`,
+    '',
+    'run your agent in this folder.',
+    '',
+  ].join('\n');
+}
+
+function buildWikiIndex() {
+  return [
+    '# wiki index',
+    '',
+    'pages: none yet',
+    '',
+  ].join('\n');
+}
+
+function craftPack(rawArgs, cwd = process.cwd()) {
+  const args = [...rawArgs];
+  const topic = args.shift();
+  if (!topic || topic === 'help' || topic === '--help' || topic === '-h') {
+    return { needsHelp: true };
+  }
+  const targetArg = takeValue(args, '--dir');
+  const force = takeFlag(args, '--force');
+  if (args.length) throw new Error(`unknown pack craft argument: ${args.join(' ')}`);
+
+  const slug = slugify(topic);
+  const targetDir = path.resolve(cwd, targetArg || slug);
+  if (isNonEmptyTarget(targetDir) && !force) {
+    const displayTarget = path.relative(cwd, targetDir) || targetDir;
+    throw new Error(`target is not empty: ${displayTarget}. rerun with --force to overwrite.`);
+  }
+
+  const manifest = buildCraftManifest(topic, slug);
+  const title = manifest.title;
+
+  fs.mkdirSync(path.join(targetDir, 'atris'), { recursive: true });
+  fs.mkdirSync(path.join(targetDir, 'wiki'), { recursive: true });
+  writeJson(path.join(targetDir, 'pack.json'), manifest);
+  fs.writeFileSync(path.join(targetDir, 'atris', 'atris.md'), buildAtrisBoot(topic));
+  fs.writeFileSync(path.join(targetDir, 'atris', 'now.md'), buildNowMd(topic));
+  fs.writeFileSync(path.join(targetDir, 'README.md'), buildReadme(topic, title));
+  fs.writeFileSync(path.join(targetDir, 'wiki', 'index.md'), buildWikiIndex());
+
+  const displayTarget = path.relative(cwd, targetDir) || '.';
+  console.log(`created ${slug} -> ${displayTarget}`);
+  console.log(`cd ${shellQuote(displayTarget)} && claude`);
+  return 0;
+}
+
+module.exports = {
+  craftPack,
+  slugify,
+  isNonEmptyTarget,
+  buildCraftManifest,
+};