atris 3.52.0 → 3.55.0

package/commands/now.js

@@ -270,7 +270,13 @@ function taskReceiptTitle(row) {
 // one per receipt, landed result + human proof state. Shares the collector
 // with the count so the number and the visible list always match.
 function todayTaskReceiptLines(root = process.cwd(), date = new Date(), limit = 6) {
-  return collectTaskReceiptsToday(root, date)
+  return formatTaskReceiptLines(collectTaskReceiptsToday(root, date), limit);
+}
+
+// Format an already-collected receipt list, so a caller that needs both the
+// count and the lines (renderDefaultNow) parses the receipt files only once.
+function formatTaskReceiptLines(receipts, limit = 6) {
+  return receipts
     .slice(-limit)
     .reverse()
     .map((r) => {
@@ -411,7 +417,8 @@ function renderDefaultNow(root = process.cwd()) {
   const journalPath = currentJournalPath(root);
   const openTodoCount = countOpenWorkItems(root, todoPath);
   const inboxCount = countMatches(journalPath, /^-\s+\*\*I\d+:/gm);
-  const taskReceiptCount = countTaskReceiptsToday(root);
+  const taskReceipts = collectTaskReceiptsToday(root);
+  const taskReceiptCount = taskReceipts.length;
   const missionReceiptCount = countMissionReceiptsToday(root);
   const completedCount = taskReceiptCount + missionReceiptCount || countJournalCompletedReceipts(journalPath);
   const generated = formatLocalTimestamp();
@@ -419,7 +426,7 @@ function renderDefaultNow(root = process.cwd()) {
   const whatMattersNow = moveLine
     ? `${moveLine}\n\n- Run the named next action and leave proof before choosing another.`
     : '- Decide the next useful move before opening more context.';
-  const receiptLines = todayTaskReceiptLines(root);
+  const receiptLines = formatTaskReceiptLines(taskReceipts);
   const missionReceiptLines = todayMissionReceiptLines(root);
   const commitLines = landedCommitLines(root);
   const hiddenReceiptCount = Math.max(0, completedCount - missionReceiptLines.length - receiptLines.length);
@@ -572,7 +579,7 @@ function refreshNowFile(root = process.cwd(), options = {}) {
 function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
   const help = args.includes('--help') || args.includes('-h') || args[0] === 'help';
   if (help) {
-    console.log('Usage: atris now [--init|--refresh|--all|--path]');
+    console.log('Usage: atris now [--init|--refresh|--all|--path] [--json]');
     console.log('');
     console.log('Show the current operating truth for this workspace.');
     console.log('');
@@ -581,6 +588,7 @@ function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
     console.log('  atris now --refresh Regenerate a small local now.md');
     console.log('  atris now --all     Refresh this parent and every child Atris workspace');
     console.log('  atris now --path    Print the file path only');
+    console.log('  atris now --json    Emit path and content as JSON');
     return;
   }
 
@@ -588,6 +596,7 @@ function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
   const refresh = args.includes('--refresh');
   const all = args.includes('--all');
   const pathOnly = args.includes('--path');
+  const asJson = args.includes('--json');
 
   let result;
   if (all) {
@@ -596,7 +605,7 @@ function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
       refreshNowFile(workspace.root);
     }
     result = refreshNowFile(root);
-    if (!pathOnly) {
+    if (!pathOnly && !asJson) {
       console.log(`Refreshed ${workspaces.length} child workspace${workspaces.length === 1 ? '' : 's'}.`);
       console.log('');
     }
@@ -614,12 +623,22 @@ function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
     return;
   }
 
+  const content = fs.readFileSync(result.path, 'utf8').trimEnd();
+  if (asJson) {
+    console.log(JSON.stringify({
+      ok: true,
+      path: rel,
+      created: Boolean(result.created),
+      content,
+    }, null, 2));
+    return;
+  }
+
   if (result.created) {
     console.log(`Created ${rel}`);
     console.log('');
   }
 
-  const content = fs.readFileSync(result.path, 'utf8').trimEnd();
   console.log(content);
 }
 

package/commands/orb.js

@@ -86,10 +86,68 @@ function renderHint() {
 }
 
 function showHelp() {
-  console.log('Usage: atris orb [--once] [--engine claude|codex|fast]');
+  console.log('Usage: atris orb [--once] [--json] [--engine claude|codex|fast]');
+  console.log('       atris orb <n> | atris orb --pick <n>');
   console.log('       atris orb scorecard [--days N]');
   console.log('');
   console.log('Choose a next move while background engine jobs keep working.');
+  console.log('--json emits {moves:[{n,label,command}]} and exits.');
+  console.log('Supported flags: --once, --json, --pick, --engine, --help, -h');
+}
+
+function suggestionCommand(suggestion, n) {
+  const kind = String(suggestion && suggestion.kind || '');
+  const label = String(suggestion && suggestion.label || '');
+  if (kind === 'digest') return 'atris stream --once';
+  if (kind === 'log') return 'atris log';
+  if (kind === 'review' && /^accept\b/i.test(label)) return 'atris task reviews';
+  return `atris orb --pick ${n}`;
+}
+
+function movesPayload(suggestions) {
+  return {
+    moves: suggestions.map((suggestion, index) => {
+      const n = index + 1;
+      return {
+        n,
+        label: suggestion.label || '',
+        command: suggestionCommand(suggestion, n),
+      };
+    }),
+  };
+}
+
+function parsePick(args = []) {
+  const equals = args.find((arg) => arg.startsWith('--pick='));
+  if (equals) {
+    const value = Number(equals.slice('--pick='.length));
+    return Number.isInteger(value) && value >= 1 ? value : null;
+  }
+  const idx = args.indexOf('--pick');
+  if (idx !== -1) {
+    const value = Number(args[idx + 1]);
+    return Number.isInteger(value) && value >= 1 ? value : null;
+  }
+  const positional = args.find((arg) => /^[1-9]$/.test(String(arg)));
+  if (positional) return Number(positional);
+  return null;
+}
+
+function unknownOrbFlags(args = []) {
+  const known = new Set(['--once', '--json', '--help', '-h', '--engine', '--pick']);
+  const unknown = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = String(args[i] || '');
+    if (!arg.startsWith('-')) continue;
+    if (arg.startsWith('--engine=')) continue;
+    if (arg.startsWith('--pick=')) continue;
+    if (arg === '--engine' || arg === '--pick') {
+      i += 1;
+      continue;
+    }
+    if (!known.has(arg)) unknown.push(arg);
+  }
+  return unknown;
 }
 
 function tailLines(text, count = 60) {
@@ -115,20 +173,57 @@ async function runOrb(args = []) {
     return 0;
   }
 
+  const unknown = unknownOrbFlags(args);
+  if (unknown.length) {
+    console.error(`unknown orb option: ${unknown.join(', ')}`);
+    console.error('supported flags: --once, --json, --pick, --engine, --help, -h');
+    return 2;
+  }
+
   const engine = parseEngine(args);
   if (!VALID_ENGINES.has(engine)) {
     console.error(`Unknown orb engine: ${engine || '(empty)'}. Use claude, codex, or fast.`);
     return 2;
   }
 
+  const asJson = args.includes('--json');
+  const pick = parsePick(args);
   const engineCommand = engineInvocation(engine, '').command;
-  if (!findExecutableOnPath(engineCommand)) {
+  if (!asJson && !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: [] });
+
+  if (asJson) {
+    const suggestions = (context.suggestions || []).slice(0, MAX_VISIBLE_SUGGESTIONS);
+    console.log(JSON.stringify(movesPayload(suggestions), null, 2));
+    return 0;
+  }
+
   let visibleSuggestions = renderContext(context);
+
+  if (pick != null) {
+    const choice = visibleSuggestions[pick - 1];
+    if (!choice) {
+      console.error(`orb: no move ${pick}. Pick 1-${visibleSuggestions.length || 0}.`);
+      return 2;
+    }
+    // One-shot pick: record the choice and print the runnable command, then exit.
+    // Interactive mode still launches background engines; agents use --json + --pick.
+    const appended = await appendOrbChoice(root, cleanLabel(choice.label));
+    if (!appended.ok) {
+      console.error(`Could not update now.md: ${appended.error}`);
+      return 1;
+    }
+    const command = suggestionCommand(choice, pick);
+    console.log(`picked ${pick}: ${choice.label}`);
+    console.log(`next: ${command}`);
+    if (choice.prompt) console.log(`prompt: ${choice.prompt}`);
+    return 0;
+  }
+
   const once = args.includes('--once') || !process.stdin.isTTY || !process.stdout.isTTY;
   if (once) return 0;
 

package/commands/pack.js

@@ -745,6 +745,74 @@ async function postPackToRegistry(manifest, zipBuffer, deps = {}) {
   return parsed.data;
 }
 
+function paidPackBarrierFromResponse(response, slug) {
+  const status = Number(response && response.status) || 0;
+  if (status === 404) return null;
+
+  const rawBody = response && response.body;
+  const body = !rawBody
+    ? Buffer.alloc(0)
+    : (Buffer.isBuffer(rawBody) ? rawBody : Buffer.from(String(rawBody)));
+  const empty = body.length === 0;
+  const parsed = parseJsonBody(body);
+  const data = parsed.data && typeof parsed.data === 'object' && !Array.isArray(parsed.data)
+    ? parsed.data
+    : {};
+  const priceRaw = data.price_cents ?? data.priceCents;
+  const priceCents = Number(priceRaw);
+  const hasPrice = Number.isFinite(priceCents) && priceCents > 0;
+  const nameSource = [data.name, data.title, data.slug, slug]
+    .find((value) => typeof value === 'string' && value.trim());
+  const details = {
+    name: String(nameSource || slug || 'this pack').trim().toLowerCase(),
+    priceCents: hasPrice ? Math.round(priceCents) : null,
+  };
+
+  const entitled = data.entitled === true
+    || data.has_access === true
+    || data.hasAccess === true
+    || data.is_owner === true
+    || data.isOwner === true;
+  const unentitled = data.entitled === false
+    || data.has_access === false
+    || data.hasAccess === false
+    || data.entitlement === false
+    || data.entitlement === null;
+  const message = String(data.error || data.message || data.detail || '');
+  const looksLikeZip = body.length >= 4 && body[0] === 0x50 && body[1] === 0x4b;
+  const paid = status === 402
+    || data.paid === true
+    || data.is_paid === true
+    || data.isPaid === true
+    || data.purchase_required === true
+    || typeof data.checkout_hint === 'string'
+    || /purchase required/i.test(message)
+    || (hasPrice && (unentitled || !looksLikeZip));
+
+  if (entitled && status >= 200 && status < 300 && looksLikeZip) return null;
+  if (status === 402 || status === 403) return details;
+  if (status >= 200 && status < 300 && empty) return details;
+  if (paid && !entitled && !looksLikeZip) return details;
+  return null;
+}
+
+function printPaidPackBarrier(slug, details = {}, deps = {}) {
+  const name = String(details.name || slug || 'this pack').trim().toLowerCase() || 'this pack';
+  const cents = Number(details.priceCents);
+  const price = Number.isFinite(cents) && cents > 0 ? ` (${formatSalesDollars(cents)})` : '';
+  console.error(`this pack is paid: ${name}${price}.`);
+  console.error('buy it on its page, then run this again.');
+  console.error(registryUrl(`/packs/${encodeURIComponent(slug)}`, deps));
+  console.error('already bought it? run atris login');
+}
+
+function throwPaidPackBarrier(barrier, status) {
+  const error = new Error('this pack is paid');
+  error.status = status;
+  error.paidPack = barrier;
+  throw error;
+}
+
 async function fetchRegistryZip(slug, deps = {}) {
   const url = registryUrl(`/api/pack/registry/${encodeURIComponent(slug)}`, deps);
   let result;
@@ -756,8 +824,10 @@ async function fetchRegistryZip(slug, deps = {}) {
     throw new Error('could not reach pack registry. check your connection and try again.');
   }
   const { response, authenticated } = result;
+  if (response.status === 404) throw registryNotFoundError(slug, authenticated);
+  const barrier = paidPackBarrierFromResponse(response, slug);
+  if (barrier) throwPaidPackBarrier(barrier, response.status);
   if (response.status < 200 || response.status >= 300) {
-    if (response.status === 404) throw registryNotFoundError(slug, authenticated);
     const error = new Error(responseErrorText(response, `registry lookup failed for ${slug} with status ${response.status}`));
     error.status = response.status;
     throw error;
@@ -772,9 +842,8 @@ async function fetchRegistryZipForUser(slug, deps = {}) {
   try {
     return await fetchRegistryZip(slug, deps);
   } catch (error) {
-    if (error.status !== 402) throw error;
-    console.error('this pack is paid. buy it on its page, then run this again.');
-    console.error(registryUrl(`/packs/${encodeURIComponent(slug)}`, deps));
+    if (!error || !error.paidPack) throw error;
+    printPaidPackBarrier(slug, error.paidPack, deps);
     return null;
   }
 }
@@ -2734,17 +2803,22 @@ async function updatePack(rawArgs, cwd = process.cwd(), options = {}) {
     const headers = credentials && credentials.token ? { Authorization: `Bearer ${credentials.token}` } : {};
     response = await request(url, { method: 'GET', headers });
   }
-  if (response.status < 200 || response.status >= 300) {
-    if (origin.type === 'registry' && response.status === 404) {
+  if (origin.type === 'registry') {
+    if (response.status === 404) {
       throw registryNotFoundError(origin.slug, authenticated);
     }
-    if (origin.type === 'registry' && response.status === 402) {
-      console.error('this pack is paid. buy it on its page, then run this again.');
-      console.error(registryUrl(`/packs/${encodeURIComponent(origin.slug)}`, deps));
+    const barrier = paidPackBarrierFromResponse(response, origin.slug);
+    if (barrier) {
+      printPaidPackBarrier(origin.slug, barrier, deps);
       return 1;
     }
+  }
+  if (response.status < 200 || response.status >= 300) {
     throw new Error(`download failed with status ${response.status}`);
   }
+  if (!response.body || response.body.length === 0) {
+    throw new Error('download returned an empty zip');
+  }
 
   const entries = readZipBuffer(response.body);
   return stagePackUpdate({