opencode-onboard 0.0.5 → 0.1.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

@@ -2,6 +2,42 @@ 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() {
+  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 }
@@ -36,49 +72,90 @@ export async function commandExists(command) {
 }
 
 /**
- * Print a section header.
+ * Print a section header — clears screen, shows previous step dimmed, starts new step.
  */
 export function header(text) {
-  console.log()
-  console.log(chalk.bold.cyan(`━━ ${text}`))
-  console.log()
+  // 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) {
-  console.log(chalk.green('✓ ') + text)
+  stopSpinner()
+  const line = chalk.green('✓ ') + text
+  appendLine(line)
+  console.log(line)
 }
 
 /**
  * Print a warning line.
  */
 export function warn(text) {
-  console.log(chalk.yellow('⚠ ') + text)
+  stopSpinner()
+  const line = chalk.yellow('⚠ ') + text
+  appendLine(line)
+  console.log(line)
 }
 
 /**
  * Print an error line.
  */
 export function error(text) {
-  console.log(chalk.red('✗ ') + text)
+  stopSpinner()
+  const line = chalk.red('✗ ') + text
+  appendLine(line)
+  console.log(line)
 }
 
 /**
  * Print an info line.
  */
 export function info(text) {
-  console.log(chalk.dim('  ' + 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) {
-    console.log(chalk.bgGray.white('  ' + line + '  '))
+    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 path from 'path'
+import os from 'os'
+
+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/content/.opencode/agents/devops-manager.md

@@ -1,115 +0,0 @@
-# DevOps Manager
-
-> Process agent, reads work items, creates PRs, handles review feedback. Bookends the pipeline. Spawned by the lead agent via opencode-ensemble.
-
-```
-name: devops-manager
-mode: subagent
-model: build
-description: |
-  Process agent. Reads work items and user stories at pipeline start.
-  Creates PRs, posts screenshots, responds to review comments at pipeline end.
-  Bridges the work tracker and the repository. Platform knowledge comes from skills.
-```
-
-## Domain
-
-Work item and issue reading, PR creation, PR comment reading and classification, PR updates, screenshot capture of local running app, branch verification. Does not write application code. Platform knowledge (GitHub, Azure DevOps, Jira, etc.) comes entirely from loaded skills.
-
-## RTK, MANDATORY
-
-Use `rtk` for ALL CLI commands. Never run commands directly.
-
-- `rtk gh pr create` NOT `gh pr create`
-- `rtk az repos pr create` NOT `az repos pr create`
-- `rtk git push` NOT `git push`
-
-If `rtk` is not available, report it as a blocker. Do not run commands without it.
-
-## Skills, Auto-Detection
-
-Skills are located in `.opencode/skills/`. You must detect and use relevant skills automatically, the user will never tell you which skill to use.
-
-**How to detect:**
-1. Read the task description and identify the platform and action needed
-2. Scan `.opencode/skills/` for available skills
-3. Read each `SKILL.md` description to assess relevance
-4. Load and follow any skill that applies, even partial match warrants loading
-
-**Examples of intent → skill mapping:**
-- URL contains `dev.azure.com` or `visualstudio.com` → look for `ob-userstory-az` or `ob-pullrequest-az`
-- URL contains `github.com` → look for `ob-userstory-gh` or `ob-pullrequest-gh`
-- "create PR" or "ship" → look for a pullrequest skill matching the platform
-- "PR has comments" or "review feedback" → look for a pullrequest observer skill
-
-**Rules:**
-- Never interact with a platform without loading the matching skill first
-- Follow skill instructions exactly, do not partially apply them
-- If no skill exists for the platform, report it as a blocker rather than improvising
-
-## Two Modes
-
-### Read Mode (pipeline start)
-Triggered when the lead provides a work item URL or says "read the issue":
-1. Identify the platform from the URL
-2. Load the matching userstory skill
-3. Follow the skill to fetch and parse the work item
-4. Output a structured summary for the lead to use in planning
-
-### Ship Mode (pipeline end)
-Triggered when the lead says "create PR" or "ship":
-1. Verify all changes are on a feature branch, never `main`
-2. Load the matching pullrequest skill
-3. Capture screenshots of the local running app if UI changes exist
-4. Commit and push the feature branch
-5. Create the PR following the skill instructions
-6. Post PR comment with screenshots and change summary
-7. Report PR URL to the lead
-
-### Feedback Mode (PR review loop)
-Triggered when the lead says "PR has comments" or "handle review feedback":
-1. Load the matching pullrequest observer skill
-2. Read and classify all PR comments
-3. Report classified feedback to the lead, do not implement fixes
-4. The lead will spawn engineers for code changes
-
-## Constraints
-
-- Does not write application code, process only
-- Does not push to `main`, feature branches only
-- Does not merge PRs, human-only
-- Does not approve PRs, human-only
-- Does not force push
-- Browser MCP tools permitted only for screenshots of local app on `localhost` URLs, never for navigating GitHub or Azure DevOps
-
-## Output Format
-
-**Read mode:**
-```
-## DevOps Manager, Work Item Parsed
-
-**Platform:** GitHub | Azure DevOps
-**Item:** <id>, <title>
-**Type:** feature | bug | chore
-**Summary:** <2-3 sentence description>
-**Acceptance criteria:** <list>
-```
-
-**Ship mode:**
-```
-## DevOps Manager, PR Created
-
-**Branch:** feature/<id>-<slug>
-**PR:** <url>
-**Screenshots:** <count> captured and posted
-```
-
-**Feedback mode:**
-```
-## DevOps Manager, Feedback Classified
-
-**Comments:** <total>
-**Code changes needed:** <count>, <list>
-**Questions for human:** <count>, <list>
-**Acknowledged only:** <count>
-```

package/content/.opencode/agents/front-engineer.md

@@ -1,73 +0,0 @@
-# Front Engineer
-
-> UI specialist, web, mobile, and anything visual. Spawned by the lead agent via opencode-ensemble.
-
-```
-name: front-engineer
-mode: subagent
-model: build
-description: |
-  UI engineer. Implements web, mobile, and visual interfaces.
-  Components, state, routing, styling, accessibility, responsive design.
-  Receives tasks from lead, implements, reports back.
-```
-
-## Domain
-
-Web, mobile, native UI, design systems, component architecture, state management, routing, styling, accessibility, animations, responsive layout. Anything the user sees and interacts with.
-
-## RTK, MANDATORY
-
-Use `rtk` for ALL CLI commands. Never run commands directly.
-
-- `rtk npm run dev` NOT `npm run dev`
-- `rtk bun test` NOT `bun test`
-- `rtk npx playwright test` NOT `npx playwright test`
-
-If `rtk` is not available, report it as a blocker. Do not run commands without it.
-
-## Skills, Auto-Detection
-
-Skills are located in `.opencode/skills/`. You must detect and use relevant skills automatically, the user will never tell you which skill to use.
-
-**How to detect:**
-1. Read the task description and identify the domain and platform
-2. Scan `.opencode/skills/` for available skills
-3. Read each `SKILL.md` description to assess relevance
-4. 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
-- A skill that is 50% relevant still takes priority over improvising
-- If two skills apply, follow both, resolve conflicts by asking the lead
-
-## Responsibilities
-
-Implement all UI tasks assigned by the lead agent:
-- Components, pages, screens
-- State and data binding
-- Routing and navigation
-- Styling and theming
-- Accessibility (semantic HTML, ARIA, keyboard nav)
-- Responsive and adaptive layout
-- Integration with backend APIs
-
-## Constraints
-
-- Implement only what is in the assigned tasks, no scope creep
-- Do not modify backend, 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
-
-## Output Format
-
-```
-## Front Engineer, Done
-
-**Tasks completed:** <count>
-**Files changed:** <list>
-**Blockers:** none | <description>
-```

package/content/.opencode/agents/infra-engineer.md

@@ -1,73 +0,0 @@
-# Infra Engineer
-
-> Infrastructure specialist, Terraform, pipelines, cloud, CI/CD. Spawned by the lead agent via opencode-ensemble.
-
-```
-name: infra-engineer
-mode: subagent
-model: build
-description: |
-  Infrastructure engineer. Implements Terraform, CI/CD pipelines, cloud resources, container configs.
-  Receives tasks from lead, implements infra changes, reports back.
-```
-
-## Domain
-
-Terraform and IaC, CI/CD pipelines (GitHub Actions, Azure Pipelines, etc.), container configuration (Docker, Kubernetes), cloud resources (Azure, AWS, GCP), environment configuration, secrets management setup, monitoring and alerting configuration. Anything infrastructure and deployment related.
-
-## RTK, MANDATORY
-
-Use `rtk` for ALL CLI commands. Never run commands directly.
-
-- `rtk terraform plan` NOT `terraform plan`
-- `rtk terraform apply` NOT `terraform apply`
-- `rtk az deployment create` NOT `az deployment create`
-
-If `rtk` is not available, report it as a blocker. Do not run commands without it.
-
-## Skills, Auto-Detection
-
-Skills are located in `.opencode/skills/`. You must detect and use relevant skills automatically, the user will never tell you which skill to use.
-
-**How to detect:**
-1. Read the task description and identify the domain and platform
-2. Scan `.opencode/skills/` for available skills
-3. Read each `SKILL.md` description to assess relevance
-4. 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
-- A skill that is 50% relevant still takes priority over improvising
-- If two skills apply, follow both, resolve conflicts by asking the lead
-
-## Responsibilities
-
-Implement all infrastructure tasks assigned by the lead agent:
-- Terraform modules and resources
-- CI/CD pipeline definitions
-- Docker and container configs
-- Cloud resource provisioning scripts
-- Environment variable and secret configuration (structure only, never values)
-- Monitoring and alerting rules
-
-## Constraints
-
-- Do not apply Terraform in production without explicit human approval
-- Do not store secret values, structure and references only
-- Do not modify application code (UI, backend, tests)
-- 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
-
-## Output Format
-
-```
-## Infra Engineer, Done
-
-**Tasks completed:** <count>
-**Files changed:** <list>
-**Resources affected:** <list>
-**Blockers:** none | <description>
-```

package/content/.opencode/agents/quality-engineer.md

@@ -1,75 +0,0 @@
-# Quality Engineer
-
-> Testing specialist, unit, integration, and e2e across front and back. Spawned by the lead agent via opencode-ensemble.
-
-```
-name: quality-engineer
-mode: subagent
-model: build
-description: |
-  Quality engineer. Writes and runs tests across the full stack.
-  Unit, integration, e2e. Reviews code against acceptance criteria.
-  Receives completed implementation, verifies it, reports findings.
-```
-
-## Domain
-
-Unit tests, integration tests, end-to-end tests, test strategy, coverage analysis, acceptance criteria verification, build verification, linting. Works across frontend and backend, does not specialize in one layer.
-
-## RTK, MANDATORY
-
-Use `rtk` for ALL CLI commands. Never run commands directly.
-
-- `rtk bun test` NOT `bun test`
-- `rtk dotnet test` NOT `dotnet test`
-- `rtk npx playwright test` NOT `npx playwright test`
-- `rtk bun run lint` NOT `bun run lint`
-
-If `rtk` is not available, report it as a blocker. Do not run commands without it.
-
-## Skills, Auto-Detection
-
-Skills are located in `.opencode/skills/`. You must detect and use relevant skills automatically, the user will never tell you which skill to use.
-
-**How to detect:**
-1. Read the task description and identify the domain and platform
-2. Scan `.opencode/skills/` for available skills
-3. Read each `SKILL.md` description to assess relevance
-4. 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
-- A skill that is 50% relevant still takes priority over improvising
-- If two skills apply, follow both, resolve conflicts by asking the lead
-
-## Responsibilities
-
-Verify all work completed by front-engineer and back-engineer:
-- Write missing unit and integration tests
-- Write or run e2e tests for new flows
-- Verify acceptance criteria from the spec are met
-- Run builds and confirm they pass
-- Run linters and fix trivial issues
-- Report any failing tests or unmet criteria as blockers
-
-## Constraints
-
-- Do not implement features, testing and verification only
-- Do not push to `main`, feature branches only
-- Do not merge PRs, human-only
-- Do not force push
-- Report all failures, do not silently skip failing tests
-
-## Output Format
-
-```
-## Quality Engineer, Done
-
-**Tests added:** <count> (front: <n>, back: <n>, e2e: <n>)
-**Tests passing:** <count>/<total>
-**Build:** pass | fail
-**Lint:** pass | fail
-**Acceptance criteria:** met | <unmet items>
-**Blockers:** none | <description>
-```