atris 3.24.0 → 3.25.1

package/lib/ax-goal.js

@@ -0,0 +1,307 @@
+const GOAL_CLEAR_ALIASES = new Set(['clear', 'stop', 'off', 'reset', 'none', 'cancel']);
+const GOAL_ACHIEVED_RE = /^\s*GOAL_ACHIEVED:\s*(.+)$/im;
+const GOAL_JSON_RE = /\{[\s\S]*"achieved"\s*:\s*(true|false)[\s\S]*\}/i;
+
+function parseTokenBudget(raw) {
+  const text = String(raw || '').trim().toUpperCase();
+  const match = text.match(/^(\d+(?:\.\d+)?)([KMB])?$/);
+  if (!match) return null;
+  let value = Number(match[1]);
+  if (match[2] === 'K') value *= 1000;
+  if (match[2] === 'M') value *= 1000000;
+  if (match[2] === 'B') value *= 1000000000;
+  return Math.round(value);
+}
+
+function parseGoalCommand(line) {
+  const raw = String(line || '').trim();
+  const lower = raw.toLowerCase();
+  if (!lower.startsWith('/goal')) return null;
+
+  const rest = raw.slice(5).trim();
+  if (!rest) return { action: 'status' };
+
+  const firstWord = rest.split(/\s+/)[0].toLowerCase();
+  if (GOAL_CLEAR_ALIASES.has(firstWord)) return { action: 'clear' };
+
+  let condition = rest;
+  let tokenBudget = null;
+  const tokensMatch = condition.match(/^--tokens\s+(\S+)\s+([\s\S]+)$/i);
+  if (tokensMatch) {
+    tokenBudget = parseTokenBudget(tokensMatch[1]);
+    condition = tokensMatch[2].trim();
+  }
+
+  const maxTurnsMatch = condition.match(/\b(?:max|stop after|within)\s+(\d+)\s+turns?\b/i);
+  const maxTurns = maxTurnsMatch ? Number(maxTurnsMatch[1]) : null;
+
+  if (!condition) return { action: 'status' };
+  return { action: 'set', condition, maxTurns, tokenBudget };
+}
+
+function createGoalState(condition, options = {}) {
+  return {
+    active: true,
+    condition: String(condition || '').trim(),
+    maxTurns: Number.isFinite(options.maxTurns) ? options.maxTurns : null,
+    tokenBudget: Number.isFinite(options.tokenBudget) ? options.tokenBudget : null,
+    turns: 0,
+    evalTurns: 0,
+    tokensUsed: 0,
+    creditsUsed: 0,
+    startedAt: Date.now(),
+    lastReason: 'Goal started — working toward the condition.',
+    achieved: false,
+    achievedAt: null,
+  };
+}
+
+function goalElapsedMs(goal) {
+  const end = goal.achievedAt || Date.now();
+  return Math.max(0, end - (goal.startedAt || end));
+}
+
+function truncateGoalText(text, limit = 72) {
+  const value = String(text || '').trim();
+  if (value.length <= limit) return value;
+  return `${value.slice(0, limit - 1)}…`;
+}
+
+function compactGoalHistory(history = [], limit = 8) {
+  return history
+    .slice(-limit)
+    .map(turn => `${turn.role}: ${String(turn.content || '').slice(0, 900)}`)
+    .join('\n');
+}
+
+function buildGoalDirective(goal, options = {}) {
+  const condition = goal.condition;
+  const reason = goal.lastReason && goal.turns > 0
+    ? `\nEvaluator guidance from last turn: ${goal.lastReason}`
+    : '';
+  return [
+    'Work autonomously toward this completion condition:',
+    condition,
+    '',
+    'Use local tools as needed. Do not ask the user for permission between steps.',
+    'Do not declare the goal achieved yourself — a separate evaluator decides that.',
+    reason,
+    options.continue ? '\nContinue from the recent conversation below.' : '',
+  ].filter(Boolean).join('\n');
+}
+
+function buildGoalEvalPrompt(goal, history, lastOutput) {
+  return [
+    'You are a strict goal evaluator for a coding agent session.',
+    'Reply with JSON only: {"achieved": true|false, "reason": "short reason"}',
+    'Judge only from observable evidence in the transcript and latest output.',
+    'If the condition requires command output or file contents, require proof in the transcript.',
+    '',
+    `Goal condition: ${goal.condition}`,
+    '',
+    'Recent conversation:',
+    compactGoalHistory(history),
+    '',
+    'Latest assistant output:',
+    String(lastOutput || '').slice(0, 4000),
+  ].join('\n');
+}
+
+function parseGoalEvalResponse(text) {
+  const raw = String(text || '').trim();
+  if (!raw) return null;
+
+  const marker = raw.match(GOAL_ACHIEVED_RE);
+  if (marker) {
+    return { achieved: true, reason: marker[1].trim() };
+  }
+
+  const jsonMatch = raw.match(GOAL_JSON_RE);
+  if (!jsonMatch) return null;
+  try {
+    const parsed = JSON.parse(jsonMatch[0]);
+    return {
+      achieved: parsed.achieved === true,
+      reason: String(parsed.reason || '').trim() || (parsed.achieved ? 'Condition met.' : 'Condition not met yet.'),
+    };
+  } catch {
+    return null;
+  }
+}
+
+function parseGoalAchievedMarker(text) {
+  const marker = String(text || '').match(GOAL_ACHIEVED_RE);
+  if (!marker) return null;
+  return { achieved: true, reason: marker[1].trim() };
+}
+
+function accumulateGoalUsage(goal, result, creditsFromState) {
+  if (!goal || !result) return;
+  const credits = typeof creditsFromState === 'function' ? creditsFromState(result) : null;
+  if (Number.isFinite(credits) && credits > 0) {
+    goal.creditsUsed += credits;
+  }
+  const approxTokens = Math.max(0, Math.round(String(result.output || '').length / 4));
+  goal.tokensUsed += approxTokens;
+}
+
+function goalBudgetExceeded(goal) {
+  if (!goal || !Number.isFinite(goal.tokenBudget)) return false;
+  return goal.tokensUsed >= goal.tokenBudget;
+}
+
+function goalTurnLimitReached(goal) {
+  if (!goal || !Number.isFinite(goal.maxTurns)) return false;
+  return goal.turns >= goal.maxTurns;
+}
+
+function clearGoalState(goal) {
+  if (!goal) return null;
+  goal.active = false;
+  return goal;
+}
+
+function finishGoalAchieved(goal, reason) {
+  goal.active = false;
+  goal.achieved = true;
+  goal.achievedAt = Date.now();
+  goal.lastReason = reason || 'Condition met.';
+  return goal;
+}
+
+function formatGoalCounter(goal) {
+  const turns = `${goal.turns}${Number.isFinite(goal.maxTurns) ? `/${goal.maxTurns}` : ''}`;
+  const duration = `${Math.max(1, Math.round(goalElapsedMs(goal) / 1000))}s`;
+  const usage = [];
+  if (goal.creditsUsed > 0) usage.push(`${goal.creditsUsed} credits`);
+  if (goal.tokensUsed > 0) usage.push(`~${goal.tokensUsed} tokens`);
+  return { turns, duration, usage: usage.join(' · ') };
+}
+
+function formatGoalStatus(goal, options = {}) {
+  const paint = options.paint || ((text) => String(text));
+  if (!goal) {
+    return 'No active goal. Set one with /goal <condition>.';
+  }
+
+  const counter = formatGoalCounter(goal);
+  const lines = [];
+
+  if (goal.active) {
+    lines.push(paint('◎ /goal active', [options.bold, options.magenta]));
+    lines.push(paint(goal.condition, [options.bold]));
+    lines.push(paint(`turn ${counter.turns} · ${counter.duration}${counter.usage ? ` · ${counter.usage}` : ''}`, [options.muted]));
+    if (goal.lastReason) lines.push(paint(`reason: ${goal.lastReason}`, [options.muted]));
+    if (Number.isFinite(goal.tokenBudget)) {
+      lines.push(paint(`budget: ~${goal.tokensUsed}/${goal.tokenBudget} tokens`, [options.muted]));
+    }
+    return lines.join('\n');
+  }
+
+  if (goal.achieved) {
+    lines.push(paint('✦ /goal achieved', [options.bold, options.ok || options.magenta]));
+    lines.push(paint(goal.condition, [options.bold]));
+    lines.push(paint(`${counter.turns} turns · ${counter.duration}${counter.usage ? ` · ${counter.usage}` : ''}`, [options.muted]));
+    if (goal.lastReason) lines.push(paint(`reason: ${goal.lastReason}`, [options.muted]));
+    return lines.join('\n');
+  }
+
+  lines.push(paint('Goal stopped.', [options.muted]));
+  lines.push(paint(goal.condition, [options.bold]));
+  lines.push(paint(`turn ${counter.turns} · ${counter.duration}`, [options.muted]));
+  if (goal.lastReason) lines.push(paint(`reason: ${goal.lastReason}`, [options.muted]));
+  return lines.join('\n');
+}
+
+function formatGoalActiveBanner(goal, options = {}) {
+  if (!goal || !goal.active) return '';
+  const paint = options.paint || ((text) => String(text));
+  const counter = formatGoalCounter(goal);
+  return paint(
+    `◎ /goal active · ${truncateGoalText(goal.condition, 56)} · turn ${counter.turns}${Number.isFinite(goal.maxTurns) ? `/${goal.maxTurns}` : ''} · ${counter.duration}`,
+    [options.bold, options.magenta]
+  );
+}
+
+function formatGoalAchieved(goal, options = {}) {
+  const paint = options.paint || ((text) => String(text));
+  const counter = formatGoalCounter(goal);
+  return [
+    paint('✦ Goal achieved', [options.bold, options.magenta]),
+    paint(goal.condition, [options.bold, options.accent]),
+    paint(`${counter.turns} turns · ${counter.duration}${counter.usage ? ` · ${counter.usage}` : ''}`, [options.muted]),
+    goal.lastReason ? paint(`reason: ${goal.lastReason}`, [options.muted]) : '',
+  ].filter(Boolean).join('\n');
+}
+
+function formatGoalContinue(goal, options = {}) {
+  const paint = options.paint || ((text) => String(text));
+  return paint(`◎ continuing goal · turn ${goal.turns + 1}${Number.isFinite(goal.maxTurns) ? `/${goal.maxTurns}` : ''} · ${goal.lastReason}`, [options.magenta]);
+}
+
+function formatGoalStopped(goal, reason, options = {}) {
+  const paint = options.paint || ((text) => String(text));
+  const counter = formatGoalCounter(goal);
+  return [
+    paint('◎ Goal stopped', [options.bold, options.muted]),
+    paint(reason, [options.muted]),
+    paint(`${counter.turns} turns · ${counter.duration}`, [options.muted]),
+  ].join('\n');
+}
+
+async function evaluateGoalTurn(goal, ctx = {}, deps = {}) {
+  const marker = parseGoalAchievedMarker(ctx.lastOutput);
+  if (marker) return marker;
+
+  if (typeof deps.evaluateGoal === 'function') {
+    return deps.evaluateGoal(goal, ctx);
+  }
+
+  if (typeof deps.postTurn !== 'function') {
+    return { achieved: false, reason: goal.lastReason || 'Condition not met yet.' };
+  }
+
+  const evalOutput = { isTTY: false, write() {} };
+  try {
+    const result = await deps.postTurn(buildGoalEvalPrompt(goal, ctx.history || [], ctx.lastOutput), {
+      ...(ctx.turnOptions || {}),
+      mode: 'fast',
+      history: [],
+      output: evalOutput,
+      showProgress: false,
+      goalEval: true,
+    });
+    const parsed = parseGoalEvalResponse(result.output);
+    if (parsed) return parsed;
+  } catch (error) {
+    return { achieved: false, reason: `Evaluator unavailable: ${error.message}` };
+  }
+
+  return { achieved: false, reason: goal.lastReason || 'Condition not met yet.' };
+}
+
+module.exports = {
+  GOAL_CLEAR_ALIASES,
+  accumulateGoalUsage,
+  buildGoalDirective,
+  buildGoalEvalPrompt,
+  clearGoalState,
+  compactGoalHistory,
+  createGoalState,
+  evaluateGoalTurn,
+  finishGoalAchieved,
+  formatGoalAchieved,
+  formatGoalActiveBanner,
+  formatGoalContinue,
+  formatGoalCounter,
+  formatGoalStatus,
+  formatGoalStopped,
+  goalBudgetExceeded,
+  goalElapsedMs,
+  goalTurnLimitReached,
+  parseGoalAchievedMarker,
+  parseGoalCommand,
+  parseGoalEvalResponse,
+  parseTokenBudget,
+  truncateGoalText,
+};

package/lib/ax-prefs.js

@@ -0,0 +1,70 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const MEMBER_SLUG = 'ax';
+const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
+
+function prefsPath() {
+  return path.join(process.env.HOME || os.homedir(), '.atris', 'ax.json');
+}
+
+const PREFS_PATH = prefsPath();
+
+function truthy(value) {
+  return TRUTHY.has(String(value || '').trim().toLowerCase());
+}
+
+function loadAxPrefs() {
+  const filePath = prefsPath();
+  try {
+    if (!fs.existsSync(filePath)) {
+      return { member_slug: MEMBER_SLUG, bypass_permissions: false };
+    }
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return {
+      member_slug: MEMBER_SLUG,
+      bypass_permissions: parsed.bypass_permissions === true,
+    };
+  } catch {
+    return { member_slug: MEMBER_SLUG, bypass_permissions: false };
+  }
+}
+
+function saveAxPrefs(prefs) {
+  const filePath = prefsPath();
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify({
+    member_slug: MEMBER_SLUG,
+    bypass_permissions: prefs.bypass_permissions === true,
+    updated_at: new Date().toISOString(),
+  }, null, 2)}\n`);
+  return loadAxPrefs();
+}
+
+function setBypassPermissions(enabled, { persist = true } = {}) {
+  const next = { member_slug: MEMBER_SLUG, bypass_permissions: enabled === true };
+  return persist ? saveAxPrefs(next) : next;
+}
+
+function resolveBypassPermissions(options = {}) {
+  if (options.bypassPermissions === true) return true;
+  if (options.bypassPermissions === false) return false;
+  if (truthy(process.env.AX_BYPASS_PERMISSIONS)) return true;
+  if (truthy(process.env.AX_SAFE_PERMISSIONS)) return false;
+  return loadAxPrefs().bypass_permissions === true;
+}
+
+function permissionsLabel(options = {}) {
+  return resolveBypassPermissions(options) ? 'bypass' : 'safe';
+}
+
+module.exports = {
+  MEMBER_SLUG,
+  PREFS_PATH,
+  loadAxPrefs,
+  saveAxPrefs,
+  setBypassPermissions,
+  resolveBypassPermissions,
+  permissionsLabel,
+};

package/lib/ax-shimmer.js

@@ -0,0 +1,63 @@
+const ANSI = {
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  muted: '\x1b[90m',
+  white: '\x1b[37m',
+  bright: '\x1b[97m',
+};
+
+function useColor(options = {}) {
+  if (options.color === false) return false;
+  if (process.env.NO_COLOR) return false;
+  return Boolean(options.color || options.isTTY);
+}
+
+function paint(text, codes, options = {}) {
+  if (!useColor(options)) return String(text);
+  const styles = codes.filter(Boolean);
+  if (!styles.length) return String(text);
+  return `${styles.join('')}${text}${ANSI.reset}`;
+}
+
+const SHIMMER_TICK_STEP = 0.44;
+
+function shimmerStyleForDistance(dist) {
+  // Obelisk .shimmer-text: pure grayscale luminance sweep — no bold, no hue.
+  const t = Math.min(Math.max(dist, 0) / 3.4, 1);
+  if (t <= 0.2) return [ANSI.bright];
+  if (t <= 0.48) return [ANSI.white];
+  if (t <= 0.72) return [ANSI.muted];
+  return [ANSI.dim, ANSI.muted];
+}
+
+function renderShimmerText(text, tick = 0, options = {}) {
+  const value = String(text || '');
+  if (!value) return '';
+  if (!useColor(options)) return value;
+
+  const len = Math.max(1, value.length);
+  const cycle = len + 12;
+  const head = (Number(tick) * SHIMMER_TICK_STEP) % cycle;
+
+  let out = '';
+  for (let i = 0; i < value.length; i += 1) {
+    const char = value[i];
+    if (char === ' ') {
+      out += ' ';
+      continue;
+    }
+    let dist = Math.abs(i - head);
+    if (dist > cycle / 2) dist = cycle - dist;
+    out += paint(char, shimmerStyleForDistance(dist), options);
+  }
+  return out;
+}
+
+module.exports = {
+  ANSI,
+  SHIMMER_TICK_STEP,
+  paint,
+  renderShimmerText,
+  shimmerStyleForDistance,
+  useColor,
+};

package/lib/context-gatherer.js

@@ -25,6 +25,13 @@ function hasContextProfile(root = process.cwd()) {
   return Boolean(profile && String(profile.first_answer || '').trim());
 }
 
+function isAtrisMetaQuestion(value) {
+  const text = String(value || '').trim().toLowerCase().replace(/[?.!]+$/g, '');
+  if (!text) return false;
+  return /^(what is|what's|whats|who is|who's|whos|explain|tell me about)\s+atris\b/.test(text)
+    || /^atris\s+(help|overview|what is this|what are you)$/i.test(text);
+}
+
 function compactText(value, max = 160) {
   const text = String(value || '').replace(/\s+/g, ' ').trim();
   if (!text) return '';
@@ -39,31 +46,6 @@ function inferDomain(answer) {
   return 'general';
 }
 
-function normalizeQuestionText(value) {
-  return String(value || '')
-    .toLowerCase()
-    .replace(/[^\w\s']/g, ' ')
-    .replace(/\s+/g, ' ')
-    .trim();
-}
-
-function isAtrisMetaQuestion(value) {
-  const text = normalizeQuestionText(value);
-  if (!text) return false;
-
-  const taskVerb = /\b(add|audit|build|change|create|debug|deploy|edit|fix|implement|make|patch|refactor|remove|review|run|ship|test|update|write)\b/;
-  if (taskVerb.test(text)) return false;
-
-  return [
-    /^(what'?s|what is|what are|who is|who are)\s+(atris|you|this)\b/,
-    /^what\s+atris\s+is\b/,
-    /^(what|how)\s+(does|do|can)\s+(atris|you|this)\b/,
-    /^(explain|describe|define)\s+(atris|this)\b/,
-    /^tell me\s+(about|what)\s+(atris|this)\b/,
-    /^why\s+atris\b/,
-  ].some((pattern) => pattern.test(text));
-}
-
 function starterTaskTitle(answer) {
   const summary = compactText(answer, 80) || 'first useful path';
   return `First useful step: ${summary}`;
@@ -160,10 +142,10 @@ module.exports = {
   profilePath,
   loadContextProfile,
   hasContextProfile,
-  isAtrisMetaQuestion,
   saveContextProfile,
   createStarterTask,
   shouldGatherContext,
+  isAtrisMetaQuestion,
   renderPrompt,
   starterTaskTitle,
   inferDomain,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.24.0",
+  "version": "3.25.1",
   "main": "bin/atris.js",
   "bin": {
     "atris": "bin/atris.js",
@@ -19,6 +19,7 @@
     "atris.md",
     "GETTING_STARTED.md",
     "PERSONA.md",
+    "atris/atrisDev.md",
     "atris/CLAUDE.md",
     "atris/GEMINI.md",
     "atris/GETTING_STARTED.md",

package/commands/card.js

@@ -1,121 +0,0 @@
-// atris card — one line of text -> a beautiful, on-brand image (your theme).
-//
-//   atris card "Ship faster" --kind statement --theme brand --size og
-//   atris card "It just works" --kind quote --by "a happy user"
-//   atris card --kind stat --number "10x" --label "faster reviews"
-//
-// Writes an .html (always) and a .png (when headless Chrome is available).
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const { execFileSync, spawnSync } = require('child_process');
-const { buildCard, 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 === '--html-only') { flags.htmlOnly = true; continue; }
-    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 };
-}
-
-// find an installed Chrome/Chromium without adding a dependency
-function findChrome() {
-  if (process.env.CHROME_PATH && fs.existsSync(process.env.CHROME_PATH)) return process.env.CHROME_PATH;
-  const macApps = [
-    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
-    '/Applications/Chromium.app/Contents/MacOS/Chromium',
-    '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
-  ];
-  for (const p of macApps) if (fs.existsSync(p)) return p;
-  for (const name of ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser', 'chrome']) {
-    const r = spawnSync('command', ['-v', name], { shell: true, encoding: 'utf8' });
-    if (r.status === 0 && r.stdout.trim()) return r.stdout.trim();
-  }
-  return null;
-}
-
-function renderPng(chrome, html, width, height, outPng) {
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-card-'));
-  const htmlFile = path.join(tmp, 'card.html');
-  fs.writeFileSync(htmlFile, html);
-  const args = [
-    '--headless=new', '--disable-gpu', '--hide-scrollbars',
-    '--force-device-scale-factor=2',
-    `--window-size=${width},${height}`,
-    '--virtual-time-budget=4000',
-    `--screenshot=${outPng}`,
-    `file://${htmlFile}`,
-  ];
-  execFileSync(chrome, args, { stdio: 'ignore', timeout: 60000 });
-  return fs.existsSync(outPng);
-}
-
-function run(argv) {
-  const { flags, pos } = parseFlags(argv);
-
-  if (pos[0] === 'help' || flags.help) {
-    console.log(`\n  atris card — one line of text into an on-brand image\n
-  atris card "Your headline" [--kind statement|quote|stat] [--theme <name>] [--size og|wide|square|story]
-  flags: --sub --kicker --by --number --label --brand --version --out <file.png> --html-only\n
-  examples:
-    atris card "Design that builds itself" --kicker "Atris v3.23.0" --theme brand
-    atris card "It just works." --kind quote --by "a founder" --size square
-    atris card --kind stat --number "1260" --label "tests, all green"\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; }
-  if (flags.size && !SIZES[flags.size]) { console.error(`  unknown size "${flags.size}". try: ${Object.keys(SIZES).join(', ')}`); return 2; }
-  if (kind === 'stat' && !flags.number && !text) { console.error('  stat cards need --number (e.g. --number "10x")'); return 2; }
-  if (kind !== 'stat' && !text) { console.error('  give the card some text: atris card "Your headline"'); return 2; }
-
-  const spec = {
-    kind, text, headline: text,
-    theme: flags.theme, size: flags.size,
-    sub: flags.sub, kicker: flags.kicker, by: flags.by,
-    number: flags.number, label: flags.label,
-    brand: flags.brand, version: flags.version,
-  };
-
-  let card;
-  try { card = buildCard(spec); }
-  catch (e) { console.error(`  could not build card: ${e.message}`); return 1; }
-
-  const base = (flags.out ? String(flags.out).replace(/\.png$/i, '') : `card-${kind}-${card.theme}-${card.size}`);
-  const outPng = path.resolve(`${base}.png`);
-  const outHtml = path.resolve(`${base}.html`);
-  fs.writeFileSync(outHtml, card.html);
-
-  if (flags.htmlOnly) {
-    console.log(`\n  ✓ ${card.kind} card (${card.width}x${card.height}, theme ${card.theme})\n    html: ${outHtml}\n    open it, or render a png with Chrome installed.\n`);
-    return 0;
-  }
-
-  const chrome = findChrome();
-  if (!chrome) {
-    console.log(`\n  ✓ wrote html: ${outHtml}\n    no Chrome found for png. open the html, or set CHROME_PATH and re-run.\n`);
-    return 0;
-  }
-  try {
-    renderPng(chrome, card.html, card.width, card.height, outPng);
-    console.log(`\n  ✓ ${card.kind} card, ${card.width}x${card.height}, theme ${card.theme}\n    ${outPng}\n`);
-    return 0;
-  } catch (e) {
-    console.log(`\n  ! png render failed (${e.message.split('\n')[0]})\n    html is ready: ${outHtml}\n`);
-    return 0;
-  }
-}
-
-module.exports = { run };