vibepup 1.0.2 → 1.0.3

package/lib/ralph-win.js

@@ -0,0 +1,401 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { spawn, spawnSync } = require('child_process');
+
+const ENGINE_DIR = path.resolve(__dirname);
+const PROJECT_DIR = process.cwd();
+const RUNS_DIR = path.join(PROJECT_DIR, '.ralph', 'runs');
+
+const DEFAULT_ITERATIONS = 5;
+const RALPH_MAX_TURN_SECONDS = Number.parseInt(process.env.RALPH_MAX_TURN_SECONDS || '900', 10);
+const RALPH_NO_OUTPUT_SECONDS = Number.parseInt(process.env.RALPH_NO_OUTPUT_SECONDS || '180', 10);
+
+const BUILD_MODELS_PREF = [
+  'github-copilot/gpt-5.2-codex',
+  'github-copilot/claude-sonnet-4.5',
+  'github-copilot/gemini-3-pro-preview',
+  'github-copilot-enterprise/gpt-5.2-codex',
+  'github-copilot-enterprise/claude-sonnet-4.5',
+  'github-copilot-enterprise/gemini-3-pro-preview',
+  'openai/gpt-5.2-codex',
+  'openai/gpt-5.1-codex-max',
+  'google/gemini-3-pro-preview',
+  'opencode/grok-code',
+];
+
+const PLAN_MODELS_PREF = [
+  'github-copilot/claude-opus-4.5',
+  'github-copilot/gemini-3-pro-preview',
+  'github-copilot-enterprise/claude-opus-4.5',
+  'github-copilot-enterprise/gemini-3-pro-preview',
+  'openai/gpt-5.2',
+  'google/antigravity-claude-opus-4-5-thinking',
+  'google/gemini-3-pro-preview',
+  'opencode/glm-4.7-free',
+];
+
+const SYSTEM_PROMPT = path.join(ENGINE_DIR, 'prompt.md');
+const ARCHITECT_FILE = path.join(ENGINE_DIR, 'agents', 'architect.md');
+
+const isWindows = process.platform === 'win32';
+
+const parseArgs = () => {
+  const args = process.argv.slice(2);
+  let iterations = DEFAULT_ITERATIONS;
+  let watchMode = false;
+  let mode = 'default';
+  let projectIdea = '';
+  let freeMode = false;
+
+  let index = 0;
+  while (index < args.length) {
+    const arg = args[index];
+    if (arg === 'free') {
+      freeMode = true;
+      index += 1;
+      continue;
+    }
+    if (arg === 'new') {
+      mode = 'new';
+      projectIdea = args[index + 1] || '';
+      index += 2;
+      continue;
+    }
+    if (arg === '--watch') {
+      watchMode = true;
+      index += 1;
+      continue;
+    }
+    if (/^\d+$/.test(arg)) {
+      iterations = Number.parseInt(arg, 10);
+      index += 1;
+      continue;
+    }
+    index += 1;
+  }
+
+  return {
+    iterations,
+    watchMode,
+    mode,
+    projectIdea,
+    freeMode,
+  };
+};
+
+const ensureDir = (dir) => fs.mkdirSync(dir, { recursive: true });
+
+const md5File = (filePath) => {
+  const content = fs.readFileSync(filePath, 'utf8');
+  return crypto.createHash('md5').update(content).digest('hex');
+};
+
+const fileExists = (filePath) => fs.existsSync(filePath);
+
+const readTail = (filePath, maxLines) => {
+  if (!fileExists(filePath)) return '';
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split(/\r?\n/);
+  return lines.slice(Math.max(0, lines.length - maxLines)).join('\n');
+};
+
+const ensureProjectFiles = () => {
+  if (!fileExists(path.join(PROJECT_DIR, 'prd.md'))) {
+    if (fileExists(path.join(PROJECT_DIR, 'prd.json'))) {
+      console.log('🔄 Migrating legacy prd.json to prd.md...');
+      const data = JSON.parse(fs.readFileSync(path.join(PROJECT_DIR, 'prd.json'), 'utf8'));
+      const lines = data.map((item) => `- [ ] ${item.description}`);
+      fs.writeFileSync(path.join(PROJECT_DIR, 'prd.md'), lines.join('\n') + '\n', 'utf8');
+      fs.renameSync(path.join(PROJECT_DIR, 'prd.json'), path.join(PROJECT_DIR, 'prd.json.bak'));
+    } else {
+      console.log('⚠️  No prd.md found. Initializing...');
+      const init = [
+        '# Product Requirements Document (PRD)',
+        '',
+        '- [ ] Initialize repo-map.md with project architecture',
+        '- [ ] Setup initial project structure',
+        '',
+      ].join('\n');
+      fs.writeFileSync(path.join(PROJECT_DIR, 'prd.md'), init, 'utf8');
+    }
+  }
+
+  if (!fileExists(path.join(PROJECT_DIR, 'repo-map.md'))) {
+    fs.writeFileSync(path.join(PROJECT_DIR, 'repo-map.md'), '', 'utf8');
+  }
+
+  if (!fileExists(path.join(PROJECT_DIR, 'prd.state.json'))) {
+    fs.writeFileSync(path.join(PROJECT_DIR, 'prd.state.json'), '{}', 'utf8');
+  }
+
+  if (!fileExists(path.join(PROJECT_DIR, 'progress.log'))) {
+    fs.writeFileSync(path.join(PROJECT_DIR, 'progress.log'), '', 'utf8');
+  }
+};
+
+const detectPhase = () => {
+  const repoMapPath = path.join(PROJECT_DIR, 'repo-map.md');
+  if (!fileExists(repoMapPath)) return 'PLAN';
+  const content = fs.readFileSync(repoMapPath, 'utf8');
+  return content.trim().length === 0 ? 'PLAN' : 'BUILD';
+};
+
+const resolveAvailableModels = (prefModels) => {
+  console.error('🔍 Verifying available models...');
+  const result = spawnSync('opencode', ['models', '--refresh'], { encoding: 'utf8' });
+  const output = result.stdout || '';
+  const lines = output.split(/\r?\n/).filter((line) => /^[a-z0-9-]+\/[a-z0-9.-]+$/.test(line));
+  const available = [];
+  for (const pref of prefModels) {
+    if (lines.includes(pref)) {
+      available.push(pref);
+    }
+  }
+  if (available.length === 0) {
+    console.error('⚠️  No preferred models found. Falling back to generic discovery.');
+    const gptFallback = lines.find((line) => line.includes('gpt-4o'));
+    const claudeFallback = lines.find((line) => line.includes('claude-sonnet'));
+    if (gptFallback) available.push(gptFallback);
+    if (claudeFallback) available.push(claudeFallback);
+  }
+  if (available.length === 0) {
+    available.push('opencode/grok-code');
+    console.error('⚠️  Using fallback model: opencode/grok-code');
+  }
+  return available;
+};
+
+const runWithWatchdog = (logPath, command, args) => new Promise((resolve) => {
+  fs.writeFileSync(logPath, '', 'utf8');
+  const logStream = fs.createWriteStream(logPath, { flags: 'a' });
+  const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+  let lastOutput = Date.now();
+  let killed = false;
+
+  const handleData = (data) => {
+    lastOutput = Date.now();
+    logStream.write(data);
+    process.stdout.write(data);
+  };
+
+  child.stdout.on('data', handleData);
+  child.stderr.on('data', handleData);
+
+  const interval = setInterval(() => {
+    const now = Date.now();
+    if (now - lastOutput > RALPH_NO_OUTPUT_SECONDS * 1000) {
+      logStream.write('[RALPH] NO OUTPUT: likely waiting for input / hung tool\n');
+      if (!killed) {
+        killed = true;
+        child.kill('SIGINT');
+        setTimeout(() => child.kill('SIGTERM'), 3000);
+        setTimeout(() => child.kill('SIGKILL'), 4000);
+      }
+    }
+    if (now - startTime > RALPH_MAX_TURN_SECONDS * 1000) {
+      logStream.write('[RALPH] TIMEOUT: killing opencode turn\n');
+      if (!killed) {
+        killed = true;
+        child.kill('SIGINT');
+        setTimeout(() => child.kill('SIGTERM'), 3000);
+        setTimeout(() => child.kill('SIGKILL'), 4000);
+      }
+    }
+  }, 5000);
+
+  const startTime = Date.now();
+
+  child.on('close', (code) => {
+    clearInterval(interval);
+    logStream.end();
+    resolve(code || 0);
+  });
+});
+
+const runAgent = async (model, phase, iterDir) => {
+  const logPath = path.join(iterDir, 'agent_response.txt');
+  const promptSuffix = phase === 'PLAN'
+    ? 'MODE: PLAN. Focus on exploring and mapping. Do NOT write implementation code yet.'
+    : 'MODE: BUILD. Focus on completing tasks in prd.md.';
+
+  const args = [
+    'run',
+    `Proceed with task. ${promptSuffix}`,
+    '--file', SYSTEM_PROMPT,
+    '--file', path.join(PROJECT_DIR, 'prd.md'),
+    '--file', path.join(PROJECT_DIR, 'prd.state.json'),
+    '--file', path.join(PROJECT_DIR, 'repo-map.md'),
+    '--file', path.join(iterDir, 'progress.tail.log'),
+    '--model', model,
+  ];
+
+  return runWithWatchdog(logPath, 'opencode', args);
+};
+
+const runArchitect = () => {
+  console.log('🏗️  Phase 0: The Architect');
+  const args = [
+    'run',
+    `PROJECT IDEA: ${projectIdea}`,
+    '--file', ARCHITECT_FILE,
+    '--agent', 'general',
+    '--model', planModels[0],
+  ];
+  const result = spawnSync('opencode', args, { stdio: 'inherit' });
+  return result.status || 0;
+};
+
+const ensureOpencode = (freeMode) => {
+  const exists = spawnSync('opencode', ['--version'], { stdio: 'ignore' }).status === 0;
+  if (exists) return true;
+
+  if (freeMode) {
+    console.log('🔧 Free setup: installing opencode...');
+    const npmAvailable = spawnSync('npm', ['--version'], { stdio: 'ignore' }).status === 0;
+    if (!npmAvailable) {
+      console.error('❌ npm not found. Install Node.js or use WSL2 for full setup.');
+      return false;
+    }
+    spawnSync('npm', ['install', '-g', 'opencode-ai', 'opencode-antigravity-auth'], { stdio: 'inherit' });
+  } else {
+    console.error('❌ opencode not found. Vibepup requires opencode to run.');
+    console.error('   Install with: npm install -g opencode-ai');
+    console.error('   Free-tier option: vibepup free');
+    return false;
+  }
+  return true;
+};
+
+const runFreeSetup = () => {
+  console.log('✨ Vibepup Free Setup');
+  console.log('   1) Installing auth plugin');
+  spawnSync('npm', ['install', '-g', 'opencode-antigravity-auth'], { stdio: 'inherit' });
+  console.log('   2) Starting Google auth');
+  spawnSync('opencode', ['auth', 'login', 'antigravity'], { stdio: 'inherit' });
+  console.log('   3) Refreshing models');
+  spawnSync('opencode', ['models', '--refresh'], { stdio: 'inherit' });
+  console.log("✅ Free setup complete. Run 'vibepup --watch' next.");
+  process.exit(0);
+};
+
+const { iterations, watchMode, mode, projectIdea, freeMode } = parseArgs();
+
+console.log('🐾 Vibepup v1.0 (Windows Native CLI Mode)');
+console.log(`   Engine:  ${ENGINE_DIR}`);
+console.log(`   Context: ${PROJECT_DIR}`);
+console.log('   Tips:');
+console.log("   - Run 'vibepup free' for free-tier setup");
+console.log("   - Run 'vibepup new \"My idea\"' to bootstrap a project");
+console.log("   - Run 'vibepup --tui' for a guided interface");
+
+ensureDir(RUNS_DIR);
+ensureProjectFiles();
+
+if (!ensureOpencode(freeMode)) {
+  process.exit(127);
+}
+
+if (freeMode) {
+  runFreeSetup();
+}
+
+const buildModels = resolveAvailableModels(BUILD_MODELS_PREF);
+const planModels = resolveAvailableModels(PLAN_MODELS_PREF);
+
+if (mode === 'new') {
+  const code = runArchitect();
+  if (code !== 0) process.exit(code);
+  console.log('✅ Architect initialization complete.');
+}
+
+let lastHash = md5File(path.join(PROJECT_DIR, 'prd.md'));
+let i = 1;
+
+const runLoop = async () => {
+  while (true) {
+    const currentHash = md5File(path.join(PROJECT_DIR, 'prd.md'));
+    if (currentHash !== lastHash) {
+      console.log('👀 PRD Changed! Restarting loop...');
+      fs.appendFileSync(path.join(PROJECT_DIR, 'progress.log'), '--- PRD CHANGED: RESTARTING LOOP ---\n', 'utf8');
+      lastHash = currentHash;
+      if (watchMode) {
+        i = 1;
+      }
+    }
+
+    if (!watchMode && i > iterations) {
+      console.log('⏸️  Max iterations reached.');
+      break;
+    }
+
+    const phase = detectPhase();
+    const iterId = `iter-${String(i).padStart(4, '0')}`;
+    const iterDir = path.join(RUNS_DIR, iterId);
+    ensureDir(iterDir);
+    const tail = readTail(path.join(PROJECT_DIR, 'progress.log'), 200);
+    fs.writeFileSync(path.join(iterDir, 'progress.tail.log'), tail, 'utf8');
+    const latestLink = path.join(RUNS_DIR, 'latest');
+    try {
+      if (fileExists(latestLink)) fs.rmSync(latestLink, { recursive: true, force: true });
+    } catch (_) {}
+    try {
+      fs.symlinkSync(iterDir, latestLink, 'junction');
+    } catch (_) {}
+
+    console.log('');
+    console.log(`🔁 Loop ${i} (${phase} Phase)`);
+    console.log(`   Logs: ${iterDir}`);
+
+    const models = phase === 'PLAN' ? planModels : buildModels;
+    let success = false;
+
+    for (const model of models) {
+      console.log(`   Using: ${model}`);
+      const exitCode = await runAgent(model, phase, iterDir);
+      const response = fs.readFileSync(path.join(iterDir, 'agent_response.txt'), 'utf8');
+
+      if (/not supported|ModelNotFoundError|Make sure the model is enabled/i.test(response)) {
+        console.log(`   ⚠️  Model ${model} not supported. Falling back...`);
+        continue;
+      }
+
+      if (exitCode === 0 && response.trim().length > 0) {
+        success = true;
+        if (response.includes('<promise>COMPLETE</promise>')) {
+          console.log('✅ Agent signaled completion.');
+          if (!watchMode) {
+            process.exit(0);
+          }
+          console.log('⏸️  Project Complete. Waiting for changes in prd.md...');
+          while (md5File(path.join(PROJECT_DIR, 'prd.md')) === lastHash) {
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+          }
+          console.log('👀 Change detected! Resuming...');
+          i = 1;
+          break;
+        }
+        break;
+      }
+
+      console.log(`   ⚠️  Model ${model} failed (Exit: ${exitCode}). Falling back...`);
+    }
+
+    if (!success) {
+      console.log('❌ All models failed this iteration.');
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
+
+    lastHash = md5File(path.join(PROJECT_DIR, 'prd.md'));
+    i += 1;
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+};
+
+runLoop().catch((err) => {
+  console.error('❌ Vibepup Windows runner failed.');
+  console.error(String(err));
+  process.exit(1);
+});

package/lib/ralph.sh

@@ -1,5 +1,6 @@
 #!/bin/bash
 set -e
+set -o pipefail
 
 
 # --- Hardened Environment (Anti-Interactive) ---
@@ -86,7 +87,7 @@ while [[ "$#" -gt 0 ]]; do
     esac
 done
 
-echo "🐾 Vibepup v1.0 (CLI Mode)"
+echo "🐾 Vibepup v1.0.3 (CLI Mode)"
 echo "   Engine:  $ENGINE_DIR"
 echo "   Context: $PROJECT_DIR"
 
@@ -144,28 +145,14 @@ fi
 # --- Smart Model Discovery ---
 get_available_models() {
     local PREF_MODELS=("$@")
-    local AVAILABLE_MODELS=()
+    local AVAILABLE_MODELS=("${PREF_MODELS[@]}")
     
-    echo "🔍 Verifying available models..." >&2
-    
-    local ALL_MODELS
-    ALL_MODELS=$(opencode models --refresh 2>/dev/null | grep -E "^[a-z0-9-]+/[a-z0-9.-]+" || true)
-    
-    for PREF in "${PREF_MODELS[@]}"; do
-        if echo "$ALL_MODELS" | grep -q "^$PREF$"; then
-            AVAILABLE_MODELS+=("$PREF")
-        fi
-    done
-    
-    if [ ${#AVAILABLE_MODELS[@]} -eq 0 ]; then
-        echo "⚠️  No preferred models found. Falling back to generic discovery." >&2
-        AVAILABLE_MODELS+=($(echo "$ALL_MODELS" | grep "gpt-4o" | head -n 1))
-        AVAILABLE_MODELS+=($(echo "$ALL_MODELS" | grep "claude-sonnet" | head -n 1))
-    fi
+    # Refresh models cache silently (ignoring errors) to ensure CLI is ready
+    opencode models --refresh >/dev/null 2>&1 || true
 
-    if [ ${#AVAILABLE_MODELS[@]} -eq 0 ]; then
-        AVAILABLE_MODELS=("opencode/grok-code")
-        echo "⚠️  Using fallback model: opencode/grok-code" >&2
+    # Always add a reliable fallback at the end if not present
+    if [[ ! " ${AVAILABLE_MODELS[*]} " =~ " opencode/grok-code " ]]; then
+         AVAILABLE_MODELS+=("opencode/grok-code")
     fi
     
     echo "${AVAILABLE_MODELS[@]}"
@@ -192,7 +179,6 @@ if [ "$MODE" == "new" ]; then
     # NOTE: We assume agents/architect.md is in lib/agents/
     opencode run "PROJECT IDEA: $PROJECT_IDEA" \
         --file "$ENGINE_DIR/agents/architect.md" \
-        --agent general \
         --model "$ARCHITECT_MODEL"
         
     echo "✅ Architect initialization complete."
@@ -368,6 +354,7 @@ while true; do
         MODELS=("${BUILD_MODELS[@]}")
     fi
 
+    echo "   Queue: ${MODELS[*]}"
     SUCCESS=false
     for MODEL in "${MODELS[@]}"; do
         echo "   Using: $MODEL"
@@ -378,7 +365,7 @@ while true; do
         
         RESPONSE=$(cat "$ITER_DIR/agent_response.txt")
 
-        if echo "$RESPONSE" | grep -qi "not supported\|ModelNotFoundError\|Make sure the model is enabled"; then
+        if echo "$RESPONSE" | grep -Eiq "not supported|ModelNotFoundError|Make sure the model is enabled"; then
             echo "   ⚠️  Model $MODEL not supported. Falling back..."
             continue
         fi

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "vibepup",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "A loyal, DX-first split-brain agent harness with cyberpunk vibes.",
   "bin": {
     "vibepup": "bin/ralph.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "cd tui && go build -o vibepup-tui .",
+    "run:local": "node bin/ralph.js",
+    "pack:local": "npm run build && npm pack"
   },
   "repository": {
     "type": "git",

package/prd.md

@@ -0,0 +1,4 @@
+# Product Requirements Document (PRD)
+
+- [ ] Initialize repo-map.md with project architecture
+- [ ] Setup initial project structure

package/prd.state.json

@@ -0,0 +1 @@
+{}

package/tui/animations/loaders.go

@@ -0,0 +1,55 @@
+package animations
+
+import "time"
+
+var (
+	vhsFrames = []string{
+		"▞▚▞▚▞▚▞▚▞▚▞▚",
+		"▚▞▚▞▚▞▚▞▚▞▚▞",
+		"▞▚▞▚▞▚▞▚▞▚▞▚",
+	}
+	crtFrames = []string{
+		"│││││││││││││",
+		"┃┃┃┃┃┃┃┃┃┃┃┃┃",
+		"║║║║║║║║║║║║║",
+	}
+	matrixFrames = []string{
+		"ａａｂｂ０１０１ｚｚ",
+		"０１０１ｚｚａａｂｂ",
+		"ｚｚａａｂｂ０１０１",
+	}
+	slimeFrames = []string{
+		"(o˶╹︿╹˶o)",
+		"(o˶╹﹏╹˶o)",
+		"(o˶╹︿╹˶o)~",
+		"~(o˶╹︿╹˶o)",
+	}
+	floppyFrames = []string{
+		"💾",
+		"💽",
+		"💿",
+	}
+	waveFrames = []string{
+		"~    ~    ~",
+		"  ~    ~   ",
+		"    ~    ~  ",
+		" ~    ~    ~",
+	}
+	fireworkFrames = []string{
+		"  .  ",
+		" .*. ",
+		".*★*",
+		" .*. ",
+		"  '  ",
+	}
+)
+
+func init() {
+	Register(Preset{Name: "vhs-scan", Kind: Loader, Frames: vhsFrames, Interval: 70 * time.Millisecond, Density: 3})
+	Register(Preset{Name: "crt-wipe", Kind: Loader, Frames: crtFrames, Interval: 60 * time.Millisecond, Density: 2})
+	Register(Preset{Name: "matrix-rain", Kind: Loader, Frames: matrixFrames, Interval: 90 * time.Millisecond, Density: 2})
+	Register(Preset{Name: "slime-bounce", Kind: Loader, Frames: slimeFrames, Interval: 80 * time.Millisecond, Density: 1})
+	Register(Preset{Name: "floppy-spin", Kind: Loader, Frames: floppyFrames, Interval: 80 * time.Millisecond, Density: 1})
+	Register(Preset{Name: "vibe-wave", Kind: Idle, Frames: waveFrames, Interval: 120 * time.Millisecond, Density: 1})
+	Register(Preset{Name: "fireworks", Kind: Event, Frames: fireworkFrames, Interval: 100 * time.Millisecond, Density: 2})
+}

package/tui/animations/memes.go

@@ -0,0 +1,35 @@
+package animations
+
+import "time"
+
+var (
+	dogeFrames = []string{
+		"wow much wait",
+		"such load very vibe",
+		"plz hold pupper",
+	}
+	shrekFrames = []string{
+		"  ／|、",
+		" (°､ ｡ 7",
+		" | 、`\\",
+		" じしf_, )ノ",
+	}
+	catFrames = []string{
+		"/ᐠ. ｡.ᐟ\\", // cat face
+		"/ᐠ｡‸｡ᐟ\\",
+		"/ᐠ – ᆽ – ᐟ\\",
+	}
+	wojakFrames = []string{
+		"(・_・;)",
+		"(・_・`)",
+		"(・_・;)",
+		"(・_・`)",
+	}
+)
+
+func init() {
+	Register(Preset{Name: "doge-wow", Kind: Event, Frames: dogeFrames, Interval: 110 * time.Millisecond, Density: 1})
+	Register(Preset{Name: "shrek-blink", Kind: Event, Frames: shrekFrames, Interval: 140 * time.Millisecond, Density: 1})
+	Register(Preset{Name: "cat-bounce", Kind: Event, Frames: catFrames, Interval: 90 * time.Millisecond, Density: 1})
+	Register(Preset{Name: "wojak-stare", Kind: Event, Frames: wojakFrames, Interval: 120 * time.Millisecond, Density: 1})
+}

package/tui/animations/registry.go

@@ -0,0 +1,54 @@
+package animations
+
+import "time"
+
+type Kind string
+
+const (
+	Loader Kind = "loader"
+	Idle   Kind = "idle"
+	Event  Kind = "event"
+)
+
+type Preset struct {
+	Name     string
+	Kind     Kind
+	Frames   []string
+	Interval time.Duration
+	Density  int
+}
+
+var presets = map[string]Preset{}
+
+func Register(p Preset) {
+	if p.Interval == 0 {
+		p.Interval = time.Millisecond * 80
+	}
+	if p.Density == 0 {
+		p.Density = 1
+	}
+	presets[p.Name] = p
+}
+
+func Get(name string) Preset {
+	if p, ok := presets[name]; ok {
+		return p
+	}
+	return presets["vhs-scan"]
+}
+
+func All() []Preset {
+	out := make([]Preset, 0, len(presets))
+	for _, p := range presets {
+		out = append(out, p)
+	}
+	return out
+}
+
+func Frame(p Preset, index int) (string, int) {
+	if len(p.Frames) == 0 {
+		return "", index
+	}
+	next := (index + 1) % len(p.Frames)
+	return p.Frames[index%len(p.Frames)], next
+}

package/tui/config/flags.go

@@ -0,0 +1,34 @@
+package config
+
+import "flag"
+
+type Flags struct {
+	Quiet    bool
+	NoEmoji  bool
+	Dense    bool
+	PerfLow  bool
+	Snark    string
+	Theme    string
+	Anim     string
+	FX       string
+	NoAlt    bool
+	ForceRun bool
+	Runner   string
+}
+
+func Parse() Flags {
+	f := Flags{}
+	flag.BoolVar(&f.Quiet, "quiet", false, "reduce motion and chatter")
+	flag.BoolVar(&f.NoEmoji, "no-emoji", false, "disable emoji rendering")
+	flag.BoolVar(&f.Dense, "dense", false, "increase animation density")
+	flag.BoolVar(&f.PerfLow, "perf-low", false, "lower FPS and effects for slower terminals")
+	flag.StringVar(&f.Snark, "snark", "mild", "snark level: mild|spicy|unhinged")
+	flag.StringVar(&f.Theme, "theme", "dracula-vibe", "theme name")
+	flag.StringVar(&f.Anim, "anim", "vhs-scan", "animation preset")
+	flag.StringVar(&f.FX, "fx", "fire", "sysc effect: fire|matrix|none")
+	flag.BoolVar(&f.NoAlt, "no-alt", true, "disable alt screen (stay in current terminal)")
+	flag.BoolVar(&f.ForceRun, "force-run", false, "run child process even if stdout is not a TTY")
+	flag.StringVar(&f.Runner, "runner", "", "path to runner script (internal use)")
+	flag.Parse()
+	return f
+}