@fuzeelogik/myflo 1.0.0-rc.4

package/lib/tasks-cmd.js

@@ -0,0 +1,160 @@
+import {
+  createTask,
+  updateTask,
+  completeTask,
+  deleteTask,
+  listTasks,
+  getTask,
+  taskCounts,
+  STATUSES,
+} from './tasks-store.js';
+
+export async function tasksCommand(args) {
+  const [sub = 'help', ...rest] = args;
+  if (sub === 'help' || sub === '--help' || sub === '-h') return printHelp();
+  if (sub === 'create' || sub === 'add') return createCmd(rest);
+  if (sub === 'list') return listCmd(rest);
+  if (sub === 'update') return updateCmd(rest);
+  if (sub === 'complete' || sub === 'done') return completeCmd(rest);
+  if (sub === 'delete' || sub === 'rm') return deleteCmd(rest);
+  if (sub === 'get' || sub === 'show') return getCmd(rest);
+  if (sub === 'counts' || sub === 'count') return countsCmd(rest);
+  console.error(`flo tasks: unknown subcommand '${sub}'`);
+  console.error(`Available: create, list, update, complete, delete, get, counts, help`);
+  process.exit(2);
+}
+
+function printHelp() {
+  console.log(`flo tasks — persistent task tracker (~/.flo/tasks.jsonl)
+
+Usage:
+  flo tasks create <subject> [--description <s>] [--tags a,b] [--owner <name>] [--parent <id>] [--status pending|in_progress|completed]
+  flo tasks list [--status <s>] [--owner <name>] [--tag <t>] [--limit N] [--json]
+  flo tasks update <id> [--subject <s>] [--description <s>] [--tags a,b] [--owner <name>] [--status <s>]
+  flo tasks complete <id>
+  flo tasks delete <id>
+  flo tasks get <id>
+  flo tasks counts [--json]
+
+Status transitions: pending → in_progress → completed. Storage is append-only
+event log; deletes are tombstones, history is preserved.
+`);
+}
+
+function parseFlags(args) {
+  const out = { positional: [] };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--json') out.json = true;
+    else if (a === '--description') out.description = args[++i];
+    else if (a === '--tags') out.tags = (args[++i] || '').split(',').map((t) => t.trim()).filter(Boolean);
+    else if (a === '--tag') out.tag = args[++i];
+    else if (a === '--owner') out.owner = args[++i];
+    else if (a === '--parent') out.parent = args[++i];
+    else if (a === '--status') out.status = args[++i];
+    else if (a === '--subject') out.subject = args[++i];
+    else if (a === '--limit') out.limit = Number(args[++i]);
+    else if (!a.startsWith('--')) out.positional.push(a);
+  }
+  return out;
+}
+
+async function createCmd(args) {
+  const opts = parseFlags(args);
+  const subject = opts.subject || opts.positional.join(' ');
+  if (!subject) { console.error(`flo tasks create: missing <subject>`); process.exit(2); }
+  const task = await createTask({
+    subject,
+    description: opts.description,
+    tags: opts.tags,
+    owner: opts.owner,
+    parent: opts.parent,
+    status: opts.status,
+  });
+  if (opts.json) console.log(JSON.stringify(task));
+  else console.log(`flo tasks create: ${task.id} — ${task.subject}`);
+}
+
+async function listCmd(args) {
+  const opts = parseFlags(args);
+  const tasks = await listTasks({
+    status: opts.status,
+    owner: opts.owner,
+    tag: opts.tag,
+    limit: opts.limit || 100,
+  });
+  if (opts.json) { console.log(JSON.stringify(tasks, null, 2)); return; }
+  if (!tasks.length) { console.log(`flo tasks: nothing matches`); return; }
+  const stsW = 13, idW = 20;
+  console.log(`status         id                    subject`);
+  console.log(`-------------  --------------------  -------`);
+  for (const t of tasks) {
+    const sts = (t.status || '?').padEnd(stsW).slice(0, stsW);
+    const id = (t.id || '?').padEnd(idW).slice(0, idW);
+    const tagStr = t.tags?.length ? `  [${t.tags.join(',')}]` : '';
+    console.log(`${sts}  ${id}  ${t.subject}${tagStr}`);
+  }
+}
+
+async function updateCmd(args) {
+  const opts = parseFlags(args);
+  const id = opts.positional[0];
+  if (!id) { console.error(`flo tasks update: missing <id>`); process.exit(2); }
+  const patch = {};
+  for (const k of ['subject', 'description', 'tags', 'owner', 'status']) {
+    if (opts[k] !== undefined) patch[k] = opts[k];
+  }
+  if (Object.keys(patch).length === 0) {
+    console.error(`flo tasks update: nothing to change`);
+    process.exit(2);
+  }
+  const task = await updateTask({ id, ...patch });
+  if (!task) { console.error(`flo tasks update: no task ${id}`); process.exit(1); }
+  if (opts.json) console.log(JSON.stringify(task));
+  else console.log(`flo tasks update: ${task.id} → status=${task.status}`);
+}
+
+async function completeCmd(args) {
+  const opts = parseFlags(args);
+  const id = opts.positional[0];
+  if (!id) { console.error(`flo tasks complete: missing <id>`); process.exit(2); }
+  const task = await completeTask(id);
+  if (!task) { console.error(`flo tasks complete: no task ${id}`); process.exit(1); }
+  console.log(`flo tasks complete: ${task.id} — ${task.subject}`);
+}
+
+async function deleteCmd(args) {
+  const opts = parseFlags(args);
+  const id = opts.positional[0];
+  if (!id) { console.error(`flo tasks delete: missing <id>`); process.exit(2); }
+  await deleteTask(id);
+  console.log(`flo tasks delete: tombstoned ${id}`);
+}
+
+async function getCmd(args) {
+  const opts = parseFlags(args);
+  const id = opts.positional[0];
+  if (!id) { console.error(`flo tasks get: missing <id>`); process.exit(2); }
+  const task = await getTask(id);
+  if (!task) { console.error(`flo tasks get: no task ${id}`); process.exit(1); }
+  if (opts.json) console.log(JSON.stringify(task, null, 2));
+  else {
+    console.log(`${task.id}`);
+    console.log(`subject:     ${task.subject}`);
+    console.log(`status:      ${task.status}`);
+    if (task.tags?.length) console.log(`tags:        ${task.tags.join(', ')}`);
+    if (task.owner) console.log(`owner:       ${task.owner}`);
+    if (task.parent) console.log(`parent:      ${task.parent}`);
+    console.log(`createdAt:   ${task.createdAt}`);
+    console.log(`updatedAt:   ${task.updatedAt}`);
+    if (task.completedAt) console.log(`completedAt: ${task.completedAt}`);
+    if (task.description) { console.log(`\n${task.description}`); }
+  }
+}
+
+async function countsCmd(args) {
+  const opts = parseFlags(args);
+  const c = await taskCounts();
+  if (opts.json) console.log(JSON.stringify(c));
+  else console.log(`flo tasks counts: total=${c.total} pending=${c.pending} in_progress=${c.in_progress} completed=${c.completed}`);
+}

package/lib/tasks-store.js

@@ -0,0 +1,152 @@
+// flo tasks — persistent task tracker.
+// Append-only event log at ~/.flo/tasks.jsonl. Each line is one event:
+//   { id, op: 'create' | 'update' | 'delete', ts, ...patch }
+// listTasks() folds events into current state. Survives session boundaries.
+
+import { mkdir, readFile, appendFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+
+const FLO_HOME = process.env.FLO_HOME || join(homedir(), '.flo');
+const TASKS_PATH = join(FLO_HOME, 'tasks.jsonl');
+
+export const STATUSES = ['pending', 'in_progress', 'completed'];
+
+async function ensureHome() {
+  if (!existsSync(FLO_HOME)) await mkdir(FLO_HOME, { recursive: true });
+}
+
+function newId() {
+  return `t-${Date.now()}-${randomBytes(2).toString('hex')}`;
+}
+
+async function appendEvent(event) {
+  await ensureHome();
+  await appendFile(TASKS_PATH, JSON.stringify(event) + '\n', 'utf8');
+}
+
+async function readEvents() {
+  if (!existsSync(TASKS_PATH)) return [];
+  let raw = '';
+  try { raw = await readFile(TASKS_PATH, 'utf8'); } catch { return []; }
+  const out = [];
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try { out.push(JSON.parse(line)); } catch { /* skip malformed */ }
+  }
+  return out;
+}
+
+export async function createTask({ subject, description, tags, owner, parent, status }) {
+  if (!subject || !subject.trim()) throw new Error('createTask: subject is required');
+  const id = newId();
+  const now = new Date().toISOString();
+  const event = {
+    id,
+    op: 'create',
+    ts: now,
+    subject: subject.trim(),
+    description: description || null,
+    tags: Array.isArray(tags) ? tags.map(String) : [],
+    owner: owner || null,
+    parent: parent || null,
+    status: STATUSES.includes(status) ? status : 'pending',
+    createdAt: now,
+    updatedAt: now,
+  };
+  await appendEvent(event);
+  return materializeOne([event]);
+}
+
+export async function updateTask({ id, ...patch }) {
+  if (!id) throw new Error('updateTask: id is required');
+  if (patch.status && !STATUSES.includes(patch.status)) {
+    throw new Error(`updateTask: invalid status '${patch.status}'. Valid: ${STATUSES.join(', ')}`);
+  }
+  const ts = new Date().toISOString();
+  const event = { id, op: 'update', ts, ...patch, updatedAt: ts };
+  await appendEvent(event);
+  // Read full state to return updated record
+  const tasks = await listAllTasks({ includeDeleted: false });
+  return tasks.find((t) => t.id === id) || null;
+}
+
+export async function completeTask(id) {
+  return updateTask({ id, status: 'completed', completedAt: new Date().toISOString() });
+}
+
+export async function deleteTask(id) {
+  if (!id) throw new Error('deleteTask: id is required');
+  await appendEvent({ id, op: 'delete', ts: new Date().toISOString() });
+}
+
+function materializeOne(events) {
+  const map = new Map();
+  for (const e of events) {
+    if (e.op === 'delete') {
+      map.delete(e.id);
+      continue;
+    }
+    if (e.op === 'create') {
+      const { op, ts, ...record } = e;
+      map.set(e.id, record);
+    } else if (e.op === 'update') {
+      const existing = map.get(e.id);
+      if (!existing) continue;
+      const { op, ts, ...patch } = e;
+      map.set(e.id, { ...existing, ...patch });
+    }
+  }
+  return [...map.values()][0] || null;
+}
+
+export async function listAllTasks({ includeDeleted = false } = {}) {
+  const events = await readEvents();
+  const map = new Map();
+  const tombstones = new Set();
+  for (const e of events) {
+    if (e.op === 'delete') {
+      tombstones.add(e.id);
+      if (!includeDeleted) map.delete(e.id);
+      else if (map.has(e.id)) map.set(e.id, { ...map.get(e.id), _deleted: true });
+      continue;
+    }
+    if (e.op === 'create') {
+      const { op, ts, ...record } = e;
+      map.set(e.id, record);
+    } else if (e.op === 'update') {
+      const existing = map.get(e.id);
+      if (!existing) continue;
+      const { op, ts, ...patch } = e;
+      map.set(e.id, { ...existing, ...patch });
+    }
+  }
+  return [...map.values()].sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : -1));
+}
+
+export async function listTasks({ status, owner, tag, limit = 100 } = {}) {
+  const all = await listAllTasks();
+  return all
+    .filter((t) => !status || t.status === status)
+    .filter((t) => !owner || t.owner === owner)
+    .filter((t) => !tag || (t.tags || []).includes(tag))
+    .slice(0, limit);
+}
+
+export async function getTask(id) {
+  const all = await listAllTasks();
+  return all.find((t) => t.id === id) || null;
+}
+
+export async function taskCounts() {
+  const all = await listAllTasks();
+  const out = { total: all.length, pending: 0, in_progress: 0, completed: 0 };
+  for (const t of all) {
+    if (out[t.status] !== undefined) out[t.status]++;
+  }
+  return out;
+}
+
+export const _internal = { TASKS_PATH };

package/lib/terminal-attach.js

@@ -0,0 +1,281 @@
+// `flo session terminal-attach` — port of nigelglenday/a-team.
+// Tracks named terminal sessions (cwd + title + app) in ~/.flo/terminals.json
+// and uses AppleScript on macOS to open them in Ghostty/iTerm/Terminal.
+
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+const execFileAsync = promisify(execFile);
+const FLO_HOME = process.env.FLO_HOME || join(homedir(), '.flo');
+const REGISTRY_PATH = join(FLO_HOME, 'terminals.json');
+
+const VALID_APPS = ['ghostty', 'iterm', 'terminal'];
+
+function slugify(input) {
+  return String(input || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 40) || 'terminal';
+}
+
+async function ensureHome() {
+  if (!existsSync(FLO_HOME)) await mkdir(FLO_HOME, { recursive: true });
+}
+
+export async function loadRegistry() {
+  await ensureHome();
+  if (!existsSync(REGISTRY_PATH)) return { version: 1, terminals: [] };
+  try {
+    const raw = await readFile(REGISTRY_PATH, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.terminals)) {
+      return { version: 1, terminals: [] };
+    }
+    return parsed;
+  } catch {
+    return { version: 1, terminals: [] };
+  }
+}
+
+export async function saveRegistry(reg) {
+  await ensureHome();
+  await writeFile(REGISTRY_PATH, JSON.stringify(reg, null, 2) + '\n', 'utf8');
+}
+
+export async function addTerminal({ slug, cwd, title, app = 'ghostty', command }) {
+  if (!VALID_APPS.includes(app)) {
+    throw new Error(`unknown app '${app}'. Valid: ${VALID_APPS.join(', ')}`);
+  }
+  const reg = await loadRegistry();
+  const resolvedCwd = resolve(cwd.replace(/^~/, homedir()));
+  const finalSlug = slugify(slug || title || `term-${reg.terminals.length + 1}`);
+  let unique = finalSlug;
+  let n = 1;
+  while (reg.terminals.find((t) => t.slug === unique)) {
+    unique = `${finalSlug}-${++n}`;
+  }
+  const entry = {
+    slug: unique,
+    cwd: resolvedCwd,
+    title: title || unique,
+    app,
+    command: command || null,
+    createdAt: new Date().toISOString(),
+  };
+  reg.terminals.push(entry);
+  await saveRegistry(reg);
+  return entry;
+}
+
+export async function removeTerminal(slug) {
+  const reg = await loadRegistry();
+  const before = reg.terminals.length;
+  reg.terminals = reg.terminals.filter((t) => t.slug !== slug);
+  await saveRegistry(reg);
+  return before - reg.terminals.length > 0;
+}
+
+export async function listTerminals() {
+  const reg = await loadRegistry();
+  return reg.terminals;
+}
+
+function escapeAppleScriptString(s) {
+  return String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function applescriptFor({ app, cwd, title, command }) {
+  const escCwd = escapeAppleScriptString(cwd);
+  const escTitle = escapeAppleScriptString(title);
+  const cmdPart = command
+    ? `${escapeAppleScriptString(command)}`
+    : '';
+  if (app === 'ghostty') {
+    // Ghostty does not have first-class AppleScript support; use `open` on the
+    // app and an osascript that focuses it, then type via System Events. Most
+    // users prefer the simpler `open -a Ghostty .` approach via `open`.
+    return null; // caller falls back to `open` flow
+  }
+  if (app === 'iterm') {
+    const tellCmd = command
+      ? `set command to "cd \\"${escCwd}\\" && ${cmdPart}"`
+      : `set command to "cd \\"${escCwd}\\""`;
+    return [
+      'tell application "iTerm2"',
+      '  activate',
+      '  create window with default profile',
+      '  tell current session of current window',
+      `    ${tellCmd}`,
+      '    write text command',
+      `    set name to "${escTitle}"`,
+      '  end tell',
+      'end tell',
+    ].join('\n');
+  }
+  if (app === 'terminal') {
+    const tellCmd = command
+      ? `do script "cd \\"${escCwd}\\" && ${cmdPart}"`
+      : `do script "cd \\"${escCwd}\\""`;
+    return [
+      'tell application "Terminal"',
+      '  activate',
+      `  set newTab to ${tellCmd}`,
+      `  set custom title of newTab to "${escTitle}"`,
+      'end tell',
+    ].join('\n');
+  }
+  return null;
+}
+
+async function openGhostty({ cwd, command }) {
+  // Ghostty CLI accepts --working-directory and -e for command. Fall back to
+  // `open -a Ghostty <cwd>` if the binary isn't on PATH.
+  try {
+    const args = ['--working-directory', cwd];
+    if (command) args.push('-e', command);
+    await execFileAsync('ghostty', args);
+    return;
+  } catch {
+    await execFileAsync('open', ['-na', 'Ghostty', '--args', '--working-directory', cwd]);
+  }
+}
+
+export async function restoreTerminal(entry) {
+  if (process.platform !== 'darwin') {
+    throw new Error(`terminal-attach restore is macOS-only (current: ${process.platform})`);
+  }
+  if (entry.app === 'ghostty') {
+    await openGhostty({ cwd: entry.cwd, command: entry.command });
+    return;
+  }
+  const script = applescriptFor(entry);
+  if (!script) throw new Error(`no AppleScript path for app '${entry.app}'`);
+  await execFileAsync('osascript', ['-e', script], { timeout: 30_000 });
+}
+
+export async function restoreAll() {
+  const terminals = await listTerminals();
+  const results = [];
+  for (const t of terminals) {
+    try {
+      await restoreTerminal(t);
+      results.push({ slug: t.slug, ok: true });
+    } catch (err) {
+      results.push({ slug: t.slug, ok: false, error: err.message });
+    }
+  }
+  return results;
+}
+
+export async function sessionCommand(args) {
+  const [sub = 'help', ...rest] = args;
+  if (sub === 'help' || sub === '--help' || sub === '-h') return printHelp();
+  if (sub === 'terminal-add') return addCmd(rest);
+  if (sub === 'terminal-list') return listCmd(rest);
+  if (sub === 'terminal-remove') return removeCmd(rest);
+  if (sub === 'terminal-restore') return restoreCmd(rest);
+  console.error(`flo session: unknown subcommand '${sub}'`);
+  console.error(`Available: terminal-add, terminal-list, terminal-remove, terminal-restore, help`);
+  process.exit(2);
+}
+
+function printHelp() {
+  console.log(`flo session — registered terminal windows (a-team port, macOS)
+
+Usage:
+  flo session terminal-add <slug> [--cwd <path>] [--title <s>] [--app ghostty|iterm|terminal] [--command <cmd>]
+  flo session terminal-list [--json]
+  flo session terminal-remove <slug>
+  flo session terminal-restore [<slug> | --all]
+
+Registry: ~/.flo/terminals.json. Each entry records cwd, title, target app,
+and an optional command to run on attach.
+
+Defaults: --cwd is the current directory, --app is ghostty, --title is the slug.
+
+Supported apps:
+  - ghostty   uses the ghostty CLI (or 'open -a Ghostty' fallback)
+  - iterm     drives iTerm2 via AppleScript
+  - terminal  drives macOS Terminal.app via AppleScript
+`);
+}
+
+function parseFlags(args) {
+  const out = { positional: [] };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--cwd') out.cwd = args[++i];
+    else if (a === '--title') out.title = args[++i];
+    else if (a === '--app') out.app = args[++i];
+    else if (a === '--command') out.command = args[++i];
+    else if (a === '--json') out.json = true;
+    else if (a === '--all') out.all = true;
+    else if (!a.startsWith('--')) out.positional.push(a);
+  }
+  return out;
+}
+
+async function addCmd(args) {
+  const opts = parseFlags(args);
+  const slug = opts.positional[0];
+  if (!slug) {
+    console.error(`flo session terminal-add: missing <slug>`);
+    process.exit(2);
+  }
+  const entry = await addTerminal({
+    slug,
+    cwd: opts.cwd || process.cwd(),
+    title: opts.title,
+    app: opts.app || 'ghostty',
+    command: opts.command,
+  });
+  console.log(`flo session terminal-add: registered '${entry.slug}' (${entry.app}) → ${entry.cwd}`);
+}
+
+async function listCmd(args) {
+  const opts = parseFlags(args);
+  const terminals = await listTerminals();
+  if (opts.json) { console.log(JSON.stringify(terminals, null, 2)); return; }
+  if (!terminals.length) { console.log(`flo session: no terminals registered`); return; }
+  console.log(`slug                  app        title                 cwd`);
+  console.log(`--------------------  ---------  --------------------  ---`);
+  for (const t of terminals) {
+    const slug = (t.slug || '?').padEnd(20).slice(0, 20);
+    const app = (t.app || '?').padEnd(9).slice(0, 9);
+    const title = (t.title || '?').padEnd(20).slice(0, 20);
+    console.log(`${slug}  ${app}  ${title}  ${t.cwd}`);
+  }
+}
+
+async function removeCmd(args) {
+  const opts = parseFlags(args);
+  const slug = opts.positional[0];
+  if (!slug) { console.error(`flo session terminal-remove: missing <slug>`); process.exit(2); }
+  const removed = await removeTerminal(slug);
+  if (removed) console.log(`flo session terminal-remove: removed '${slug}'`);
+  else { console.error(`flo session terminal-remove: no terminal with slug '${slug}'`); process.exit(1); }
+}
+
+async function restoreCmd(args) {
+  const opts = parseFlags(args);
+  if (opts.all || !opts.positional.length) {
+    const results = await restoreAll();
+    for (const r of results) {
+      console.log(`  ${r.ok ? 'OK ' : 'FAIL'}  ${r.slug}${r.error ? ` — ${r.error}` : ''}`);
+    }
+    const failed = results.filter((r) => !r.ok).length;
+    if (failed) process.exit(1);
+    return;
+  }
+  const slug = opts.positional[0];
+  const terminals = await listTerminals();
+  const entry = terminals.find((t) => t.slug === slug);
+  if (!entry) { console.error(`flo session terminal-restore: no terminal '${slug}'`); process.exit(1); }
+  await restoreTerminal(entry);
+  console.log(`flo session terminal-restore: launched '${entry.slug}' (${entry.app})`);
+}

package/lib/transcribe-cmd.js

@@ -0,0 +1,75 @@
+import { transcribe, transcribeAndSaveSidecar, detectTool } from './transcribe.js';
+
+export async function transcribeCommand(args) {
+  const parsed = parseArgs(args);
+  if (parsed.help) {
+    console.log(`flo transcribe — local audio transcription
+
+Detects mlx-whisper / openai-whisper / whisper-cpp at runtime and uses the
+first available. No cloud calls.
+
+Usage:
+  flo transcribe <audio-file> [--save] [--model base|small|medium|large]
+  flo transcribe --detect
+
+Options:
+  --save           Write a sidecar .txt next to the audio file.
+  --model <name>   Whisper model (default: base; env FLO_WHISPER_MODEL).
+  --detect         Just report which tool would be used.
+  --json           JSON output.
+  -h, --help       Show this help.
+
+Audio formats: m4a, wav, mp3, aiff, flac (anything ffmpeg can decode).
+`);
+    return;
+  }
+
+  if (parsed.detect) {
+    const tool = await detectTool();
+    if (parsed.json) {
+      console.log(JSON.stringify({ tool: tool?.name || null, binary: tool?.binary || null }));
+    } else if (tool) {
+      console.log(`flo transcribe: would use ${tool.name} (${tool.binary})`);
+    } else {
+      console.log(`flo transcribe: no tool available. Install one of: mlx-whisper, openai-whisper, whisper-cpp.`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (!parsed.file) {
+    console.error(`flo transcribe: missing <audio-file>`);
+    console.error(`Usage: flo transcribe <audio-file> [--save]`);
+    process.exit(2);
+  }
+
+  const result = parsed.save
+    ? await transcribeAndSaveSidecar(parsed.file, { model: parsed.model })
+    : await transcribe(parsed.file, { model: parsed.model });
+
+  if (parsed.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else if (result.text) {
+    if (parsed.save) {
+      process.stderr.write(`flo transcribe: wrote ${result.sidecar}\n`);
+    }
+    console.log(result.text);
+  } else {
+    console.error(`flo transcribe: ${result.error}`);
+    process.exit(1);
+  }
+}
+
+function parseArgs(args) {
+  const out = { help: false, file: null, save: false, json: false, detect: false, model: null };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--help' || a === '-h') out.help = true;
+    else if (a === '--save') out.save = true;
+    else if (a === '--json') out.json = true;
+    else if (a === '--detect') out.detect = true;
+    else if (a === '--model') out.model = args[++i];
+    else if (!a.startsWith('--') && !out.file) out.file = a;
+  }
+  return out;
+}