opencode-onboard 0.3.3 → 0.4.2

package/src/utils/exec.js

@@ -1,173 +1,131 @@
-import chalk from 'chalk'
-import { execa } from 'execa'
-import ora from 'ora'
-
-// ── Screen / step state ──────────────────────────────────────────────────────
-
-const previousSteps = []    // up to 2 completed steps, each is an array of lines
-let currentStepLines = []   // lines accumulated in the current step
-let stepSpinner = null      // ora spinner shown while step is working
-
-function appendLine(line) {
-  currentStepLines.push(line)
-}
-
-function stopSpinner() {
-  if (stepSpinner) {
-    stepSpinner.stop()
-    stepSpinner = null
-  }
+import chalk from 'chalk'
+import { execa } from 'execa'
+import ora from 'ora'
+import { appendLine, redraw, rotateStep, startSpinner, stopSpinner } from './exec-spinner.js'
+
+// ── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Run a shell command with a spinner.
+ * Returns { success, stdout, stderr }
+ */
+export async function run(command, args = [], { label, cwd = process.cwd() } = {}) {
+  const spinner = ora(label ?? `${command} ${args.join(' ')}`).start();
+  try {
+    const result = await execa(command, args, { cwd, reject: false });
+    if (result.exitCode === 0) {
+      spinner.succeed();
+    } else {
+      spinner.fail();
+    }
+    return { success: result.exitCode === 0, stdout: result.stdout, stderr: result.stderr };
+  } catch (err) {
+    spinner.fail();
+    return { success: false, stdout: '', stderr: err.message };
+  }
 }
 
-function startSpinner(text = 'working...') {
-  stopSpinner()
-  stepSpinner = ora({ text: chalk.dim(text), color: 'red' }).start()
+/**
+ * Check if a command is available on PATH.
+ * Returns true/false.
+ */
+export async function commandExists(command) {
+  try {
+    const result = await execa(command, ['--version'], { reject: false });
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
 }
-
-function redraw() {
-  if (process.stdout.isTTY) console.clear()
-
-  // Show up to 2 previous steps dimmed
-  for (const stepLines of previousSteps) {
-    for (const line of stepLines) {
-      process.stdout.write(chalk.dim(line) + '\n')
-    }
-    process.stdout.write('\n')
-  }
-
-  // Current step output
-  for (const line of currentStepLines) {
-    process.stdout.write(line + '\n')
-  }
-}
-
-// ── Public API ───────────────────────────────────────────────────────────────
-
-/**
- * Run a shell command with a spinner.
- * Returns { success, stdout, stderr }
- */
-export async function run(command, args = [], { label, cwd = process.cwd() } = {}) {
-  const spinner = ora(label ?? `${command} ${args.join(' ')}`).start()
-  try {
-    const result = await execa(command, args, { cwd, reject: false })
-    if (result.exitCode === 0) {
-      spinner.succeed()
-    } else {
-      spinner.fail()
-    }
-    return { success: result.exitCode === 0, stdout: result.stdout, stderr: result.stderr }
-  } catch (err) {
-    spinner.fail()
-    return { success: false, stdout: '', stderr: err.message }
-  }
-}
-
-/**
- * Check if a command is available on PATH.
- * Returns true/false.
- */
-export async function commandExists(command) {
-  try {
-    const result = await execa(command, ['--version'], { reject: false })
-    return result.exitCode === 0
-  } catch {
-    return false
-  }
-}
-
-/**
- * Print a section header, clears screen, shows previous step dimmed, starts new step.
- */
-export function header(text) {
-  // Rotate buffers, keep last 2 completed steps
-  previousSteps.push(currentStepLines)
-  if (previousSteps.length > 2) previousSteps.shift()
-  currentStepLines = []
-
-  const line1 = ''
-  const line2 = chalk.bold.hex('#fe3d57')(`━━ ${text}`)
-  const line3 = ''
-
-  appendLine(line1)
-  appendLine(line2)
-  appendLine(line3)
-
-  redraw()
 
-  // Start a spinner while the step is working
-  startSpinner('working...')
+/**
+ * Print a section header, clears screen, shows previous step dimmed, starts new step.
+ */
+export function header(text) {
+  rotateStep();
+
+  const line1 = '';
+  const line2 = chalk.bold.hex('#fe3d57')(`━━ ${text}`);
+  const line3 = '';
+
+  appendLine(line1);
+  appendLine(line2);
+  appendLine(line3);
+
+  redraw();
+
+  startSpinner('working...');
 }
 
 /**
  * Restart the step spinner after prompts or logs.
  */
 export function loading(text = 'working...') {
-  startSpinner(text)
+  startSpinner(text);
+}
+
+/**
+ * Print a success line.
+ */
+export function success(text) {
+  stopSpinner();
+  const line = chalk.green('✓ ') + text;
+  appendLine(line);
+  console.log(line);
+}
+
+/**
+ * Print a warning line.
+ */
+export function warn(text) {
+  stopSpinner();
+  const line = chalk.yellow('⚠ ') + text;
+  appendLine(line);
+  console.log(line);
+}
+
+/**
+ * Print an error line.
+ */
+export function error(text) {
+  stopSpinner();
+  const line = chalk.red('✗ ') + text;
+  appendLine(line);
+  console.log(line);
+}
+
+/**
+ * Print an info line.
+ */
+export function info(text) {
+  stopSpinner();
+  const line = chalk.dim('  ' + text);
+  appendLine(line);
+  console.log(line);
+}
+
+/**
+ * Print an action prompt line (white bold, requires user interaction).
+ */
+export function prompt(text) {
+  stopSpinner();
+  const line = chalk.bold('  ' + text);
+  appendLine(line);
+  console.log(line);
+}
+
+/**
+ * Print a code block.
+ */
+export function code(lines) {
+  stopSpinner();
+  appendLine('');
+  console.log();
+  for (const line of lines) {
+    const formatted = chalk.bgGray.white('  ' + line + '  ');
+    appendLine(formatted);
+    console.log(formatted);
+  }
+  appendLine('');
+  console.log();
 }
-
-/**
- * Print a success line.
- */
-export function success(text) {
-  stopSpinner()
-  const line = chalk.green('✓ ') + text
-  appendLine(line)
-  console.log(line)
-}
-
-/**
- * Print a warning line.
- */
-export function warn(text) {
-  stopSpinner()
-  const line = chalk.yellow('⚠ ') + text
-  appendLine(line)
-  console.log(line)
-}
-
-/**
- * Print an error line.
- */
-export function error(text) {
-  stopSpinner()
-  const line = chalk.red('✗ ') + text
-  appendLine(line)
-  console.log(line)
-}
-
-/**
- * Print an info line.
- */
-export function info(text) {
-  stopSpinner()
-  const line = chalk.dim('  ' + text)
-  appendLine(line)
-  console.log(line)
-}
-
-/**
- * Print an action prompt line (white bold, requires user interaction).
- */
-export function prompt(text) {
-  stopSpinner()
-  const line = chalk.bold('  ' + text)
-  appendLine(line)
-  console.log(line)
-}
-
-/**
- * Print a code block.
- */
-export function code(lines) {
-  stopSpinner()
-  appendLine('')
-  console.log()
-  for (const line of lines) {
-    const formatted = chalk.bgGray.white('  ' + line + '  ')
-    appendLine(formatted)
-    console.log(formatted)
-  }
-  appendLine('')
-  console.log()
-}

package/src/utils/models-cache.js

@@ -1,73 +1,30 @@
 import fse from 'fs-extra'
 import os from 'os'
 import path from 'path'
+import { parseModels } from './models-pricing.js'
 
-const CACHE_DIR = path.join(os.homedir(), '.config', 'opencode-onboard')
-const CACHE_FILE = path.join(CACHE_DIR, 'models-cache.json')
-const CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000 // 7 days
-const MODELS_URL = 'https://models.dev/api.json'
-
-// Providers considered "canonical" for reference pricing, in priority order.
-// When a model's own provider has no cost (e.g. github-copilot shows $0),
-// we look up the same model name in these providers and attach canonicalCost.
-const CANONICAL_PROVIDERS = ['anthropic', 'openai', 'google', 'mistral', 'meta', 'cohere']
-
-function parseModels(data) {
-  // Build name → canonical cost lookup from authoritative providers first
-  // name is the human-readable model name, e.g. "Claude Opus 4.6"
-  const canonicalCostByName = new Map()
-  for (const providerId of CANONICAL_PROVIDERS) {
-    const provider = data[providerId]
-    if (!provider?.models) continue
-    for (const model of Object.values(provider.models)) {
-      if (!model.tool_call) continue
-      const name = model.name
-      if (name && model.cost?.input !== undefined && !canonicalCostByName.has(name)) {
-        canonicalCostByName.set(name, model.cost.input)
-      }
-    }
-  }
-
-  const models = []
-  for (const [providerId, provider] of Object.entries(data)) {
-    if (!provider.models) continue
-    for (const [modelId, model] of Object.entries(provider.models)) {
-      if (!model.tool_call) continue
-      const name = model.name || modelId
-      const cost = model.cost?.input
-      const canonicalCost = canonicalCostByName.get(name)
-      models.push({
-        id: `${providerId}/${modelId}`,
-        name,
-        cost,
-        // canonicalCost: cost from the authoritative provider for this model name.
-        // Defined when cost !== canonicalCost (different provider, reseller, or $0 subscription).
-        canonicalCost: canonicalCost !== undefined && canonicalCost !== cost ? canonicalCost : undefined,
-        context: model.limit?.context,
-      })
-    }
-  }
-  models.sort((a, b) => (a.cost ?? Infinity) - (b.cost ?? Infinity))
-  return models
-}
+const CACHE_DIR = path.join(os.homedir(), '.config', 'opencode-onboard');
+const CACHE_FILE = path.join(CACHE_DIR, 'models-cache.json');
+const CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+const MODELS_URL = 'https://models.dev/api.json';
 
 async function loadCache() {
   try {
-    if (!await fse.pathExists(CACHE_FILE)) return null
-    const cache = await fse.readJson(CACHE_FILE)
-    if (!cache.timestamp || !cache.models) return null
-    const age = Date.now() - cache.timestamp
-    if (age > CACHE_TTL_MS) return null // expired
-    return cache.models
+    if (!await fse.pathExists(CACHE_FILE)) return null;
+    const cache = await fse.readJson(CACHE_FILE);
+    if (!cache.timestamp || !cache.models) return null;
+    const age = Date.now() - cache.timestamp;
+    if (age > CACHE_TTL_MS) return null; // expired
+    return cache.models;
   } catch {
-    return null
+    return null;
   }
 }
 
 async function saveCache(models) {
   try {
-    await fse.ensureDir(CACHE_DIR)
-    await fse.writeJson(CACHE_FILE, { timestamp: Date.now(), models })
+    await fse.ensureDir(CACHE_DIR);
+    await fse.writeJson(CACHE_FILE, { timestamp: Date.now(), models });
   } catch {
     // cache write failure is non-fatal
   }
@@ -75,27 +32,27 @@ async function saveCache(models) {
 
 export async function fetchModels() {
   // 1. Try cache first (fresh)
-  const cached = await loadCache()
-  if (cached) return { models: cached, source: 'cache' }
+  const cached = await loadCache();
+  if (cached) return { models: cached, source: 'cache' };
 
   // 2. Try network
   try {
-    const res = await fetch(MODELS_URL, { signal: AbortSignal.timeout(8000) })
-    if (!res.ok) throw new Error(`HTTP ${res.status}`)
-    const data = await res.json()
-    const models = parseModels(data)
-    await saveCache(models)
-    return { models, source: 'network' }
+    const res = await fetch(MODELS_URL, { signal: AbortSignal.timeout(8000) });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const data = await res.json();
+    const models = parseModels(data);
+    await saveCache(models);
+    return { models, source: 'network' };
   } catch {
     // 3. Network failed, fall back to stale cache if available
     try {
       if (await fse.pathExists(CACHE_FILE)) {
-        const cache = await fse.readJson(CACHE_FILE)
-        if (cache.models?.length) return { models: cache.models, source: 'stale-cache' }
+        const cache = await fse.readJson(CACHE_FILE);
+        if (cache.models?.length) return { models: cache.models, source: 'stale-cache' };
       }
     } catch {
       // ignore
     }
-    return { models: null, source: 'unavailable' }
+    return { models: null, source: 'unavailable' };
   }
 }

package/src/utils/models-pricing.js

@@ -0,0 +1,42 @@
+// Providers considered "canonical" for reference pricing, in priority order.
+// When a model's own provider has no cost (e.g. github-copilot shows $0),
+// we look up the same model name in these providers and attach canonicalCost.
+export const CANONICAL_PROVIDERS = ['anthropic', 'openai', 'google', 'mistral', 'meta', 'cohere'];
+
+export function parseModels(data) {
+  // Build name → canonical cost lookup from authoritative providers first
+  const canonicalCostByName = new Map();
+  for (const providerId of CANONICAL_PROVIDERS) {
+    const provider = data[providerId];
+    if (!provider?.models) continue;
+    for (const model of Object.values(provider.models)) {
+      if (!model.tool_call) continue;
+      const name = model.name;
+      if (name && model.cost?.input !== undefined && !canonicalCostByName.has(name)) {
+        canonicalCostByName.set(name, model.cost.input);
+      }
+    }
+  }
+
+  const models = [];
+  for (const [providerId, provider] of Object.entries(data)) {
+    if (!provider.models) continue;
+    for (const [modelId, model] of Object.entries(provider.models)) {
+      if (!model.tool_call) continue;
+      const name = model.name || modelId;
+      const cost = model.cost?.input;
+      const canonicalCost = canonicalCostByName.get(name);
+      models.push({
+        id: `${providerId}/${modelId}`,
+        name,
+        cost,
+        // canonicalCost: cost from the authoritative provider for this model name.
+        // Defined when cost !== canonicalCost (different provider, reseller, or $0 subscription).
+        canonicalCost: canonicalCost !== undefined && canonicalCost !== cost ? canonicalCost : undefined,
+        context: model.limit?.context,
+      });
+    }
+  }
+  models.sort((a, b) => (a.cost ?? Infinity) - (b.cost ?? Infinity));
+  return models;
+}

package/src/utils/models-pricing.test.js

@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest'
+import { CANONICAL_PROVIDERS, parseModels } from './models-pricing.js'
+
+describe('CANONICAL_PROVIDERS', () => {
+  it('contains expected major providers', () => {
+    expect(CANONICAL_PROVIDERS).toContain('anthropic')
+    expect(CANONICAL_PROVIDERS).toContain('openai')
+    expect(CANONICAL_PROVIDERS).toContain('google')
+  })
+})
+
+describe('parseModels()', () => {
+  it('filters to tool-calling models only', () => {
+    const data = {
+      anthropic: {
+        models: {
+          'claude-3-sonnet': { name: 'Claude 3 Sonnet', tool_call: true, cost: { input: 3 } },
+          'claude-3-haiku': { name: 'Claude 3 Haiku', tool_call: false, cost: { input: 0.25 } },
+        },
+      },
+    }
+
+    const result = parseModels(data)
+
+    expect(result).toHaveLength(1)
+    expect(result[0].id).toBe('anthropic/claude-3-sonnet')
+  })
+
+  it('builds canonical cost lookup from authoritative providers', () => {
+    const data = {
+      anthropic: {
+        models: {
+          'claude-3-5-sonnet': { name: 'Claude 3.5 Sonnet', tool_call: true, cost: { input: 3 } },
+        },
+      },
+      'some-reseller': {
+        models: {
+          'claude-3-5-sonnet': { name: 'Claude 3.5 Sonnet', tool_call: true, cost: { input: 0 } },
+        },
+      },
+    }
+
+    const result = parseModels(data)
+
+    expect(result).toHaveLength(2)
+    const reseller = result.find(m => m.id.startsWith('some-reseller'))
+    expect(reseller?.canonicalCost).toBe(3)
+  })
+
+  it('sorts by cost ascending', () => {
+    const data = {
+      openai: {
+        models: {
+          'gpt-4': { name: 'GPT-4', tool_call: true, cost: { input: 30 } },
+          'gpt-3.5-turbo': { name: 'GPT-3.5 Turbo', tool_call: true, cost: { input: 0.5 } },
+        },
+      },
+    }
+
+    const result = parseModels(data)
+
+    expect(result[0].cost).toBe(0.5)
+    expect(result[1].cost).toBe(30)
+  })
+
+  it('handles missing cost', () => {
+    const data = {
+      test: {
+        models: {
+          'unknown-model': { name: 'Unknown', tool_call: true },
+        },
+      },
+    }
+
+    const result = parseModels(data)
+
+    expect(result[0].cost).toBeUndefined()
+  })
+
+  it('extracts context limit', () => {
+    const data = {
+      anthropic: {
+        models: {
+          'claude-3-opus': { name: 'Claude 3 Opus', tool_call: true, cost: { input: 15 }, limit: { context: 200000 } },
+        },
+      },
+    }
+
+    const result = parseModels(data)
+
+    expect(result[0].context).toBe(200000)
+  })
+})

package/content/.agents/agents/back-engineer.md

@@ -1,87 +0,0 @@
----
-description: Backend engineer. Implements APIs, services, data models, business logic, AI integrations. Anything that is not UI. Receives tasks from lead, implements, reports back.
-mode: subagent
-color: #68A063
-temperature: 0.2
-permission:
-  edit: allow
-  bash: allow
-  read: allow
-  glob: allow
-  grep: allow
----
-
-# Back Engineer
-
-Backend specialist, APIs, monoliths, data, AI, anything not UI. Spawned by the lead agent via opencode-ensemble.
-
-## Domain
-
-REST and GraphQL APIs, monolithic services, microservices, databases and data models, business logic, background jobs, queues, caching, AI/LLM integrations, third-party service integrations, authentication and authorization logic. Anything that runs server-side or outside the UI.
-
-## RTK, MANDATORY
-
-Use `rtk` for ALL CLI commands. Never run commands directly.
-
-- `rtk dotnet test` NOT `dotnet test`
-- `rtk bun test` NOT `bun test`
-- `rtk npm run build` NOT `npm run build`
-
-If `rtk` is not available, report it as a blocker. Do not run commands without it.
-
-## Skills, Auto-Detection
-
-Skills are located in `.agents/skills/`. Detect and use relevant skills automatically, the user will never tell you which skill to use.
-
-1. If the spawn prompt lists specific skills to load, read those `SKILL.md` files FIRST before any implementation
-2. Additionally, read the task and identify domain and platform
-3. Scan `.agents/skills/` for available skills
-4. Read each `SKILL.md` description to assess relevance
-5. Load and follow any skill that applies, even partial match warrants loading
-
-Rules:
-- Never implement directly if a skill applies
-- Follow skill instructions exactly, do not partially apply them
-- If two skills apply, follow both, resolve conflicts by asking the lead
-- Skills listed in the spawn prompt are MANDATORY, not optional
-
-## Responsibilities
-
-- API endpoints and controllers
-- Data models and migrations
-- Business logic and domain services
-- Authentication and authorization
-- Background jobs and workers
-- AI/LLM integrations and prompt engineering
-- Third-party service integrations
-- Performance and query optimization
-
-## Constraints
-
-- Implement only what is in the assigned tasks, no scope creep
-- Do not modify UI, infra, or pipeline files
-- Do not push to `main`, feature branches only
-- Do not merge PRs, human-only
-- Do not force push
-- Report blockers immediately rather than working around them
-
-## Workflow
-
-When spawned by the lead:
-0. Read ALL skills listed in the spawn prompt FIRST. Do not proceed until every listed SKILL.md has been read. Reply to lead with `team_message` confirming which skills were loaded.
-1. For each assigned task: call `team_claim task_id:<id>` before starting
-2. Implement the task following loaded skill rules
-3. Call `team_tasks_complete task_id:<id>` after finishing
-4. When all tasks are done or blocked, send results to lead via `team_message`
-
-## Output Format
-
-Send via `team_message` to lead when done:
-
-```
-## Back Engineer, Done
-
-**Tasks completed:** <count>
-**Files changed:** <list>
-**Blockers:** none | <description>
-```