opencode-onboard 0.0.5 → 0.1.1

package/src/steps/install-browser.js

@@ -1,9 +1,18 @@
 import { execa } from 'execa'
-import { error, header, success, warn } from '../utils/exec.js'
+import { header, info, success, warn, error } from '../utils/exec.js'
 import os from 'os'
 
+const AUTO_ANSWERS = [
+  { trigger: 'Press Enter when',             response: '' },
+  { trigger: 'Choose config location',       response: '2' },
+  { trigger: 'Add plugin automatically?',    response: 'y' },
+  { trigger: 'Create one?',                  response: 'y' },
+  { trigger: 'Add browser-automation skill', response: 'n' },
+  { trigger: 'Check broker',                 response: 'n' },
+]
+
 export async function installBrowser() {
-  header('Step 7, Installing opencode-browser')
+  header('Step 10, Installing opencode-browser')
 
   try {
     const child = execa('npx', ['@different-ai/opencode-browser', 'install'], {
@@ -12,37 +21,18 @@ export async function installBrowser() {
       reject: false,
     })
 
-    const AUTO_ANSWERS = [
-      { trigger: 'Choose config location', response: '2' }, // global config
-      { trigger: 'Create one?', response: 'y' },
-      { trigger: 'Add browser-automation skill', response: 'n' },
-      { trigger: 'Check broker', response: 'n' },
-    ]
-
-    let pendingTriggers = [...AUTO_ANSWERS]
-    let showOutput = true  // show output until after step 3 user interaction
-    let waitingForUser = false
+    const pendingTriggers = [...AUTO_ANSWERS]
+    let show = false
 
     child.stdout.on('data', (chunk) => {
       const text = chunk.toString()
 
-      if (showOutput) {
-        process.stdout.write(chunk)
-      }
+      // Show only the load/pin instructions, hide everything else
+      if (text.includes('To load the extension')) show = true
+      if (text.includes('Press Enter when'))      show = false
 
-      // Step 3 — let user press Enter, then suppress remaining output
-      if (text.includes('Press Enter when') && !waitingForUser) {
-        waitingForUser = true
-        process.stdin.resume()
-        process.stdin.once('data', () => {
-          child.stdin.write('\n')
-          process.stdin.pause()
-          showOutput = false  // suppress steps 4-9 output
-        })
-        return
-      }
+      if (show) process.stdout.write(chunk)
 
-      // Auto-answer remaining prompts
       for (let i = 0; i < pendingTriggers.length; i++) {
         if (text.includes(pendingTriggers[i].trigger)) {
           child.stdin.write(pendingTriggers[i].response + '\n')
@@ -52,6 +42,8 @@ export async function installBrowser() {
       }
     })
 
+    child.stderr.on('data', (chunk) => process.stderr.write(chunk))
+
     const result = await child
 
     if (result.exitCode === 0) {

package/src/utils/__tests__/copy.test.js

@@ -76,28 +76,6 @@ describe('copy utils', () => {
       expect(await fse.pathExists(path.join(dest, 'AGENTS.md'))).toBe(true)
     })
 
-    it('excludes azure files when platform is github', async () => {
-      await fse.ensureDir(path.join(src, 'skills', 'ob-userstory-az'))
-      await fse.writeFile(path.join(src, 'skills', 'ob-userstory-az', 'SKILL.md'), 'azure skill')
-      await fse.writeFile(path.join(src, 'agent-az.md'), 'azure agent')
-
-      await copyContent(src, dest, 'github')
-
-      expect(await fse.pathExists(path.join(dest, 'agent-az.md'))).toBe(false)
-      expect(await fse.pathExists(path.join(dest, 'skills', 'ob-userstory-az', 'SKILL.md'))).toBe(false)
-    })
-
-    it('excludes github files when platform is azure', async () => {
-      await fse.ensureDir(path.join(src, 'skills', 'ob-userstory-gh'))
-      await fse.writeFile(path.join(src, 'skills', 'ob-userstory-gh', 'SKILL.md'), 'gh skill')
-      await fse.writeFile(path.join(src, 'agent-gh.md'), 'gh agent')
-
-      await copyContent(src, dest, 'azure')
-
-      expect(await fse.pathExists(path.join(dest, 'agent-gh.md'))).toBe(false)
-      expect(await fse.pathExists(path.join(dest, 'skills', 'ob-userstory-gh', 'SKILL.md'))).toBe(false)
-    })
-
     it('always excludes .bootstrap folder', async () => {
       await fse.ensureDir(path.join(src, '.bootstrap'))
       await fse.writeFile(path.join(src, '.bootstrap', 'secret.md'), 'internal')

package/src/utils/__tests__/exec.test.js

@@ -3,7 +3,7 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 // Mock chalk to return the string as-is (no ANSI codes in tests)
 vi.mock('chalk', () => ({
   default: {
-    bold: { cyan: (s) => s },
+    bold: { hex: () => (s) => s },
     green: (s) => s,
     yellow: (s) => s,
     red: (s) => s,
@@ -14,7 +14,7 @@ vi.mock('chalk', () => ({
 
 // Mock ora spinner
 vi.mock('ora', () => ({
-  default: () => ({ start: () => ({ succeed: vi.fn(), fail: vi.fn() }) }),
+  default: () => ({ start: () => ({ succeed: vi.fn(), fail: vi.fn(), stop: vi.fn() }) }),
 }))
 
 // Mock execa
@@ -72,9 +72,11 @@ describe('exec utils', () => {
   })
 
   describe('console helpers', () => {
-    it('header() calls console.log', () => {
+    it('header() clears screen and writes output', () => {
+      vi.spyOn(process.stdout, 'write').mockImplementation(() => {})
+      vi.spyOn(console, 'clear').mockImplementation(() => {})
       header('Test Header')
-      expect(console.log).toHaveBeenCalled()
+      expect(process.stdout.write).toHaveBeenCalled()
     })
 
     it('success() calls console.log with text', () => {

package/src/utils/copy.js

@@ -1,7 +1,7 @@
 import fse from 'fs-extra'
 import path from 'path'
 
-// Folders never copied (internal bootstrap tooling)
+// Folders never copied (skills handled separately by chooseSkillsProvider, .bootstrap is internal tooling)
 const ALWAYS_EXCLUDE = ['.bootstrap', 'skills']
 
 /**

package/src/utils/exec.js

@@ -1,84 +1,161 @@
-import chalk from 'chalk'
-import { execa } from 'execa'
-import ora from 'ora'
-
-/**
- * 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.
- */
-export function header(text) {
-  console.log()
-  console.log(chalk.bold.cyan(`━━ ${text}`))
-  console.log()
-}
-
-/**
- * Print a success line.
- */
-export function success(text) {
-  console.log(chalk.green('✓ ') + text)
-}
-
-/**
- * Print a warning line.
- */
-export function warn(text) {
-  console.log(chalk.yellow('⚠ ') + text)
-}
-
-/**
- * Print an error line.
- */
-export function error(text) {
-  console.log(chalk.red('✗ ') + text)
-}
-
-/**
- * Print an info line.
- */
-export function info(text) {
-  console.log(chalk.dim('  ' + text))
-}
-
-/**
- * Print a code block.
- */
-export function code(lines) {
-  console.log()
-  for (const line of lines) {
-    console.log(chalk.bgGray.white('  ' + line + '  '))
-  }
-  console.log()
-}
+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
+  }
+}
+
+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
+  stepSpinner = ora({ text: chalk.dim('working...'), color: 'red' }).start()
+}
+
+/**
+ * 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

@@ -0,0 +1,101 @@
+import fse from 'fs-extra'
+import os from 'os'
+import path from 'path'
+
+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
+}
+
+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
+  } catch {
+    return null
+  }
+}
+
+async function saveCache(models) {
+  try {
+    await fse.ensureDir(CACHE_DIR)
+    await fse.writeJson(CACHE_FILE, { timestamp: Date.now(), models })
+  } catch {
+    // cache write failure is non-fatal
+  }
+}
+
+export async function fetchModels() {
+  // 1. Try cache first (fresh)
+  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' }
+  } 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' }
+      }
+    } catch {
+      // ignore
+    }
+    return { models: null, source: 'unavailable' }
+  }
+}

package/content/.opencode/agents/.bootstrap/CUSTOM-AGENT.template.md

@@ -1,24 +0,0 @@
-# Backend Agent
-
-> {{description_short}} - spawned by orchestrator via opencode-ensemble
-
-```
-name: {{name}}
-mode: subagent
-model: {{build|explore}}
-description: |
-  {{description_long}}
-tools:
-  read: {{true|false}}
-  write: {{true|false}}
-  execute: {{true|false}}
-  network: {{true|false}}
-```
-
-## RTK - MANDATORY
-
-Use `rtk` for ALL CLI commands:
-{{rtk_commands}}
-
-{{rest_of_content}}
-

package/src/presets/skills-providers.json

@@ -1,14 +0,0 @@
-[
-  {
-    "label": "ob-skills (default, ships with opencode-onboard)",
-    "value": "ob-skills",
-    "package": "opencode-onboard",
-    "description": "Default skill pack: GitHub and Azure DevOps user stories, pull requests, OpenSpec workflows."
-  },
-  {
-    "label": "None, I will add skills manually",
-    "value": "none",
-    "package": null,
-    "description": "Skip skill installation. Add skills to .opencode/skills/ manually."
-  }
-]

package/src/steps/__tests__/choose-team.test.js

@@ -1,105 +0,0 @@
-import fse from 'fs-extra'
-import os from 'os'
-import path from 'path'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-vi.mock('../../utils/exec.js', () => ({
-  header: vi.fn(),
-  success: vi.fn(),
-  info: vi.fn(),
-}))
-
-vi.mock('@inquirer/prompts', () => ({
-  checkbox: vi.fn(),
-  input: vi.fn(),
-}))
-
-import { checkbox, input } from '@inquirer/prompts'
-import { info } from '../../utils/exec.js'
-
-describe('chooseTeam()', () => {
-  let tmpDir
-  let originalCwd
-
-  beforeEach(async () => {
-    tmpDir = await fse.mkdtemp(path.join(os.tmpdir(), 'ob-team-test-'))
-    originalCwd = process.cwd()
-    process.chdir(tmpDir)
-    vi.clearAllMocks()
-  })
-
-  afterEach(async () => {
-    process.chdir(originalCwd)
-    await fse.remove(tmpDir)
-    vi.resetModules()
-  })
-
-  it('returns empty array and skips when no agents selected', async () => {
-    checkbox.mockResolvedValue([])
-    // single empty input to exit the custom loop
-    input.mockResolvedValue('')
-
-    // Dynamic import so process.cwd() is captured at call time
-    const { chooseTeam } = await import('../choose-team.js')
-    const result = await chooseTeam()
-
-    expect(result).toEqual([])
-    expect(info).toHaveBeenCalledWith('No agents selected, skipping team setup.')
-  })
-
-  it('creates agent files for selected preset agents', async () => {
-    checkbox.mockResolvedValue(['frontend', 'backend'])
-    input.mockResolvedValue('') // no custom agents
-
-    const { chooseTeam } = await import('../choose-team.js')
-    const result = await chooseTeam()
-
-    expect(result).toEqual(['frontend', 'backend'])
-
-    const frontendPath = path.join(tmpDir, '.opencode', 'agents', 'frontend.md')
-    const backendPath = path.join(tmpDir, '.opencode', 'agents', 'backend.md')
-    expect(await fse.pathExists(frontendPath)).toBe(true)
-    expect(await fse.pathExists(backendPath)).toBe(true)
-  })
-
-  it('creates agent file for custom agent name', async () => {
-    checkbox.mockResolvedValue([])
-    input.mockResolvedValueOnce('devops').mockResolvedValueOnce('') // one custom, then stop
-
-    const { chooseTeam } = await import('../choose-team.js')
-    const result = await chooseTeam()
-
-    expect(result).toContain('devops')
-    const devopsPath = path.join(tmpDir, '.opencode', 'agents', 'devops.md')
-    expect(await fse.pathExists(devopsPath)).toBe(true)
-  })
-
-  it('normalises custom agent name (lowercase, spaces to dashes)', async () => {
-    checkbox.mockResolvedValue([])
-    input.mockResolvedValueOnce('My Agent').mockResolvedValueOnce('')
-
-    const { chooseTeam } = await import('../choose-team.js')
-    const result = await chooseTeam()
-
-    expect(result).toContain('my-agent')
-    const agentPath = path.join(tmpDir, '.opencode', 'agents', 'my-agent.md')
-    expect(await fse.pathExists(agentPath)).toBe(true)
-  })
-
-  it('skips agent file creation if it already exists', async () => {
-    checkbox.mockResolvedValue(['frontend'])
-    input.mockResolvedValue('')
-
-    const agentsDir = path.join(tmpDir, '.opencode', 'agents')
-    await fse.ensureDir(agentsDir)
-    await fse.writeFile(path.join(agentsDir, 'frontend.md'), 'existing content')
-
-    const { chooseTeam } = await import('../choose-team.js')
-    await chooseTeam()
-
-    // File should still have original content (not overwritten)
-    const content = await fse.readFile(path.join(agentsDir, 'frontend.md'), 'utf-8')
-    expect(content).toBe('existing content')
-    expect(info).toHaveBeenCalledWith('frontend.md already exists, skipping')
-  })
-})