atris 3.31.0 → 3.33.3

package/commands/run-front.js

@@ -0,0 +1,144 @@
+// atris run: thin front door over the mission runtime loop.
+// One bounded pursuit: start a mission from the objective (or resume the most
+// logical runnable mission), tick it, complete on pass, then exit.
+// The old plan→do→review loop lives on behind `atris run --legacy`.
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const CLI_PATH = path.join(__dirname, '..', 'bin', 'atris.js');
+
+const RUN_VALUE_FLAGS = new Set([
+  '--owner',
+  '--cadence',
+  '--minutes',
+  '--hours',
+  '--max-ticks',
+  '--max-wall',
+  '--runner',
+  '--runner-bin',
+  '--runner-template',
+  '--runner-model',
+  '--runner-profile',
+]);
+
+function readValueFlag(args, name) {
+  const index = args.indexOf(name);
+  return index >= 0 && index + 1 < args.length ? args[index + 1] : null;
+}
+
+function positiveNumber(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+
+function runBudgetSeconds(args = []) {
+  const hours = positiveNumber(readValueFlag(args, '--hours'));
+  if (hours) return Math.round(hours * 3600);
+  const minutes = positiveNumber(readValueFlag(args, '--minutes'));
+  if (minutes) return Math.round(minutes * 60);
+  return null;
+}
+
+function runObjective(args = []) {
+  const words = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (RUN_VALUE_FLAGS.has(arg)) { i++; continue; }
+    if (arg.startsWith('-')) continue;
+    words.push(arg);
+  }
+  return words.join(' ').trim();
+}
+
+// Runners a spawned `mission run` can drive unattended.
+const HEADLESS_DRIVABLE_RUNNERS = new Set(['claude', 'atris2']);
+const CALLER_SESSION_RUNNERS = new Set(['codex_goal', 'caller_session', 'current_agent']);
+
+function liveCodexSession(env = process.env) {
+  return Boolean(String(env.CODEX_THREAD_ID || '').trim());
+}
+
+function runnerDrivableForFrontDoor(runner, options = {}) {
+  const normalized = String(runner || '').trim().toLowerCase();
+  if (HEADLESS_DRIVABLE_RUNNERS.has(normalized)) return true;
+  if (options.allowCallerSessionRunners && CALLER_SESSION_RUNNERS.has(normalized)) return true;
+  return false;
+}
+
+// Most logical mission: a moving one beats a planned one, newer beats older.
+// ready is excluded — it waits for review, not for another worker pass.
+function pickRunnableMission(root = process.cwd(), missionMap = null, options = {}) {
+  let map = missionMap;
+  if (!map) {
+    try { map = require('./mission').loadMissionMap(root); } catch { return null; }
+  }
+  const candidates = Array.from(map.values())
+    .filter((mission) => mission && (mission.status === 'running' || mission.status === 'planning'))
+    .filter((mission) => runnerDrivableForFrontDoor(mission?.runner, options))
+    .filter((mission) => !/^decide and start the next useful mission after:/i.test(String(mission?.objective || '')))
+    .sort((a, b) => {
+      if (a.status !== b.status) return a.status === 'running' ? -1 : 1;
+      return String(b.updated_at || b.created_at || '').localeCompare(String(a.updated_at || a.created_at || ''));
+    });
+  return candidates[0] || null;
+}
+
+function runTickBudget(args, budgetSeconds) {
+  const explicit = positiveNumber(readValueFlag(args, '--max-ticks'));
+  if (explicit) return Math.floor(explicit);
+  // A timed run is a loop contract: keep picking the next useful move until
+  // the wall clock spends the budget (same rule as member run).
+  return budgetSeconds ? Math.max(4, Math.ceil(budgetSeconds / 300)) : 4;
+}
+
+async function runMissionFront(args = []) {
+  const objective = runObjective(args);
+  const budgetSeconds = runBudgetSeconds(args);
+  const maxTicks = runTickBudget(args, budgetSeconds);
+  const maxWallSeconds = positiveNumber(readValueFlag(args, '--max-wall')) || budgetSeconds || 1200;
+
+  if (objective) {
+    const { runRuntimeMissionLoop } = require('../lib/mission-runtime-loop');
+    const result = await runRuntimeMissionLoop({
+      objective,
+      owner: readValueFlag(args, '--owner') || 'mission-lead',
+      cadence: readValueFlag(args, '--cadence') || '',
+      maxTicks,
+      maxWallSeconds,
+      noComplete: args.includes('--no-complete'),
+    }, {
+      cliPath: CLI_PATH,
+      onProgress: (line) => console.log(`  ${line}`),
+    });
+    console.log(result.text || '');
+    return result.ok ? 0 : 1;
+  }
+
+  const mission = pickRunnableMission(process.cwd(), null, {
+    allowCallerSessionRunners: liveCodexSession(),
+  });
+  if (!mission) {
+    console.log('No objective given and no runnable mission found.');
+    console.log('Start one: atris run "<objective>" [--minutes N] [--owner <member>]');
+    console.log('Or keep going indefinitely: atris autopilot');
+    return 1;
+  }
+  console.log(`Resuming mission ${mission.id} (${mission.status}): ${mission.objective}`);
+  const result = spawnSync(process.execPath, [
+    CLI_PATH, 'mission', 'run', mission.id,
+    '--max-ticks', String(maxTicks),
+    '--max-wall', String(maxWallSeconds),
+    '--complete-on-pass',
+  ], { cwd: process.cwd(), stdio: 'inherit' });
+  return result.status || 0;
+}
+
+module.exports = {
+  runMissionFront,
+  pickRunnableMission,
+  liveCodexSession,
+  runnerDrivableForFrontDoor,
+  runObjective,
+  runBudgetSeconds,
+  runTickBudget,
+};

package/commands/run.js

@@ -381,12 +381,15 @@ async function runAtris(options = {}) {
     process.exit(1);
   }
 
-  // Check configured runner CLI is available.
-  try {
-    execSync(buildRunnerAvailabilityCommand(), { stdio: 'pipe' });
-  } catch (err) {
-    console.error(runnerAvailabilityFailureMessage(err));
-    process.exit(1);
+  // Check configured runner CLI is available. Dry runs preview context only —
+  // they must work on machines (and CI) without the runner installed.
+  if (!dryRun) {
+    try {
+      execSync(buildRunnerAvailabilityCommand(), { stdio: 'pipe' });
+    } catch (err) {
+      console.error(runnerAvailabilityFailureMessage(err));
+      process.exit(1);
+    }
   }
 
   console.log('');

package/commands/sign.js

@@ -0,0 +1,90 @@
+const fs = require('fs');
+const path = require('path');
+
+// atris sign: co-author trailer on every commit in an atris workspace.
+// Installs a prepare-commit-msg hook that appends "Co-authored-by: Atris"
+// when the repo has an atris/ folder — same credit line Claude and Cursor use.
+// Idempotent and non-destructive: appends a marked block, removes only its own block.
+
+const MARKER = '# atris co-author';
+const TRAILER = 'Co-authored-by: Atris <299057014+atris-builder[bot]@users.noreply.github.com>';
+
+const HOOK_BLOCK = `
+${MARKER}
+if [ -d "$(git rev-parse --show-toplevel 2>/dev/null)/atris" ] && [ "$2" != "merge" ] && [ "$2" != "squash" ]; then
+  if ! grep -qi "^co-authored-by: atris" "$1"; then
+    printf '\\nCo-authored-by: Atris <299057014+atris-builder[bot]@users.noreply.github.com>\\n' >> "$1"
+  fi
+fi
+`;
+
+function hookPathFor(root) {
+  return path.join(root, '.git', 'hooks', 'prepare-commit-msg');
+}
+
+// Install the marked block into .git/hooks/prepare-commit-msg. Returns { hookPath, already }.
+function installSignHook(root = process.cwd()) {
+  if (!fs.existsSync(path.join(root, '.git'))) throw new Error('not a git repo (no .git here)');
+  const hookPath = hookPathFor(root);
+  fs.mkdirSync(path.dirname(hookPath), { recursive: true });
+  let content = '';
+  try { content = fs.readFileSync(hookPath, 'utf8'); } catch {}
+  if (content.includes(MARKER)) return { hookPath, already: true };
+  if (!content) content = '#!/bin/sh\n';
+  if (!content.endsWith('\n')) content += '\n';
+  content += HOOK_BLOCK;
+  fs.writeFileSync(hookPath, content);
+  fs.chmodSync(hookPath, 0o755);
+  return { hookPath, already: false };
+}
+
+// Remove only our marked block; leave the rest of the hook untouched.
+function removeSignHook(root = process.cwd()) {
+  const hookPath = hookPathFor(root);
+  let content = '';
+  try { content = fs.readFileSync(hookPath, 'utf8'); } catch { return { hookPath, removed: false }; }
+  if (!content.includes(MARKER)) return { hookPath, removed: false };
+  const cleaned = content.replace(HOOK_BLOCK, '');
+  if (cleaned.trim() === '#!/bin/sh') {
+    fs.unlinkSync(hookPath);
+  } else {
+    fs.writeFileSync(hookPath, cleaned);
+  }
+  return { hookPath, removed: true };
+}
+
+function signStatus(root = process.cwd()) {
+  const hookPath = hookPathFor(root);
+  let content = '';
+  try { content = fs.readFileSync(hookPath, 'utf8'); } catch {}
+  return { hookPath, installed: content.includes(MARKER) };
+}
+
+function signCommand(sub) {
+  const rel = (p) => path.relative(process.cwd(), p);
+  if (sub === 'off' || sub === 'remove') {
+    const { hookPath, removed } = removeSignHook();
+    console.log(removed
+      ? `\n  ✓ atris co-author removed: ${rel(hookPath)}\n`
+      : `\n  nothing to remove — atris co-author is not installed\n`);
+    return 0;
+  }
+  if (sub === 'status') {
+    const { hookPath, installed } = signStatus();
+    console.log(installed
+      ? `\n  ✓ atris co-author is on: ${rel(hookPath)}\n    every commit gets: ${TRAILER}\n`
+      : `\n  atris co-author is off — run 'atris sign' to turn it on\n`);
+    return installed ? 0 : 1;
+  }
+  if (sub && sub !== 'on' && sub !== 'install') {
+    console.log(`\n  atris sign — co-author trailer on every commit\n\n  atris sign          install the prepare-commit-msg hook\n  atris sign off      remove it\n  atris sign status   check whether it's installed\n\n  While installed, any commit in a repo with an atris/ folder gets:\n    ${TRAILER}\n`);
+    return 0;
+  }
+  const { hookPath, already } = installSignHook();
+  console.log(already
+    ? `\n  already installed: ${rel(hookPath)}\n`
+    : `\n  ✓ atris co-author installed: ${rel(hookPath)}\n    every commit here now gets: ${TRAILER}\n`);
+  return 0;
+}
+
+module.exports = { signCommand, installSignHook, removeSignHook, signStatus, TRAILER };