opencode-onboard 0.0.1 → 0.1.0

package/src/steps/__tests__/check-env.test.js

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+vi.mock('../../utils/exec.js', () => ({
+  commandExists: vi.fn(),
+  header: vi.fn(),
+  success: vi.fn(),
+  error: vi.fn(),
+}))
+
+// Mock execa used directly in check-env.js
+vi.mock('execa', () => ({ execa: vi.fn() }))
+
+import { commandExists, error, success } from '../../utils/exec.js'
+import { checkEnv } from '../check-env.js'
+
+describe('checkEnv()', () => {
+  const originalVersion = process.version
+  const originalExit = process.exit
+
+  beforeEach(() => {
+    process.exit = vi.fn()
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    Object.defineProperty(process, 'version', { value: originalVersion, writable: true })
+    process.exit = originalExit
+  })
+
+  it('exits with error when Node version is < 18', async () => {
+    Object.defineProperty(process, 'version', { value: 'v16.0.0', writable: true })
+    commandExists.mockResolvedValue(true)
+
+    await checkEnv()
+
+    expect(error).toHaveBeenCalledWith(expect.stringContaining('v16.0.0'))
+    expect(process.exit).toHaveBeenCalledWith(1)
+  })
+
+  it('succeeds when Node version is >= 18 and pnpm is available', async () => {
+    Object.defineProperty(process, 'version', { value: 'v20.0.0', writable: true })
+    commandExists.mockImplementation(async (cmd) => cmd === 'pnpm')
+
+    await checkEnv()
+
+    expect(process.exit).not.toHaveBeenCalled()
+    expect(success).toHaveBeenCalledWith(expect.stringContaining('v20.0.0'))
+    expect(success).toHaveBeenCalledWith('pnpm available')
+  })
+
+  it('succeeds when Node version is >= 18 and only npm is available', async () => {
+    Object.defineProperty(process, 'version', { value: 'v18.0.0', writable: true })
+    commandExists.mockImplementation(async (cmd) => cmd === 'npm')
+
+    await checkEnv()
+
+    expect(process.exit).not.toHaveBeenCalled()
+    expect(success).toHaveBeenCalledWith('npm available')
+  })
+
+  it('exits when neither npm nor pnpm available', async () => {
+    Object.defineProperty(process, 'version', { value: 'v20.0.0', writable: true })
+    commandExists.mockResolvedValue(false)
+
+    await checkEnv()
+
+    expect(error).toHaveBeenCalledWith(expect.stringContaining('Neither npm nor pnpm'))
+    expect(process.exit).toHaveBeenCalledWith(1)
+  })
+})

package/src/steps/__tests__/check-platform.test.js

@@ -0,0 +1,104 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+vi.mock('../../utils/exec.js', () => ({
+  commandExists: vi.fn(),
+  header: vi.fn(),
+  success: vi.fn(),
+  warn: vi.fn(),
+  info: vi.fn(),
+  code: vi.fn(),
+}))
+
+vi.mock('execa', () => ({
+  execa: vi.fn(),
+}))
+
+import { execa } from 'execa'
+import { commandExists, success, warn } from '../../utils/exec.js'
+import { checkPlatform } from '../check-platform.js'
+
+describe('checkPlatform()', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('github path', () => {
+    it('prints success when gh is installed and authenticated', async () => {
+      commandExists.mockResolvedValue(true)
+      execa.mockResolvedValue({ exitCode: 0, stdout: '' })
+
+      await checkPlatform('github')
+
+      expect(success).toHaveBeenCalledWith('GitHub CLI (gh) available')
+      expect(success).toHaveBeenCalledWith('GitHub CLI authenticated')
+    })
+
+    it('warns when gh is installed but not authenticated', async () => {
+      commandExists.mockResolvedValue(true)
+      execa.mockResolvedValue({ exitCode: 1, stdout: '' })
+
+      await checkPlatform('github')
+
+      expect(success).toHaveBeenCalledWith('GitHub CLI (gh) available')
+      expect(warn).toHaveBeenCalledWith(expect.stringContaining('not authenticated'))
+    })
+
+    it('warns when gh is not installed', async () => {
+      commandExists.mockResolvedValue(false)
+
+      await checkPlatform('github')
+
+      expect(warn).toHaveBeenCalledWith('GitHub CLI (gh) not found.')
+      expect(success).not.toHaveBeenCalled()
+    })
+
+    it('warns when gh auth status check throws', async () => {
+      commandExists.mockResolvedValue(true)
+      execa.mockRejectedValue(new Error('spawn error'))
+
+      await checkPlatform('github')
+
+      expect(warn).toHaveBeenCalledWith('Could not check gh auth status.')
+    })
+  })
+
+  describe('azure path', () => {
+    it('prints success when az is installed and azure-devops extension present', async () => {
+      commandExists.mockResolvedValue(true)
+      execa.mockResolvedValue({ exitCode: 0, stdout: 'azure-devops\tsome info' })
+
+      await checkPlatform('azure')
+
+      expect(success).toHaveBeenCalledWith('Azure CLI (az) available')
+      expect(success).toHaveBeenCalledWith('azure-devops extension installed')
+    })
+
+    it('warns when az is installed but azure-devops extension is missing', async () => {
+      commandExists.mockResolvedValue(true)
+      execa.mockResolvedValue({ exitCode: 0, stdout: '' })
+
+      await checkPlatform('azure')
+
+      expect(success).toHaveBeenCalledWith('Azure CLI (az) available')
+      expect(warn).toHaveBeenCalledWith(expect.stringContaining('azure-devops extension not found'))
+    })
+
+    it('warns when az is not installed', async () => {
+      commandExists.mockResolvedValue(false)
+
+      await checkPlatform('azure')
+
+      expect(warn).toHaveBeenCalledWith('Azure CLI (az) not found.')
+      expect(success).not.toHaveBeenCalled()
+    })
+
+    it('warns when extension check throws', async () => {
+      commandExists.mockResolvedValue(true)
+      execa.mockRejectedValue(new Error('spawn error'))
+
+      await checkPlatform('azure')
+
+      expect(warn).toHaveBeenCalledWith('Could not check azure-devops extension. Run:')
+    })
+  })
+})

package/src/steps/__tests__/check-rtk.test.js

@@ -0,0 +1,37 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+vi.mock('../../utils/exec.js', () => ({
+  commandExists: vi.fn(),
+  header: vi.fn(),
+  success: vi.fn(),
+  warn: vi.fn(),
+  info: vi.fn(),
+  code: vi.fn(),
+}))
+
+import { commandExists, success, warn } from '../../utils/exec.js'
+import { checkRtk } from '../check-rtk.js'
+
+describe('checkRtk()', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('prints success when rtk is available', async () => {
+    commandExists.mockResolvedValue(true)
+
+    await checkRtk()
+
+    expect(success).toHaveBeenCalledWith('rtk is available')
+    expect(warn).not.toHaveBeenCalled()
+  })
+
+  it('prints warning with install instructions when rtk is not found', async () => {
+    commandExists.mockResolvedValue(false)
+
+    await checkRtk()
+
+    expect(warn).toHaveBeenCalledWith('rtk not found on PATH.')
+    expect(success).not.toHaveBeenCalled()
+  })
+})

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

@@ -0,0 +1,38 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+vi.mock('../../utils/exec.js', () => ({
+  header: vi.fn(),
+  success: vi.fn(),
+}))
+
+vi.mock('@inquirer/prompts', () => ({
+  select: vi.fn(),
+}))
+
+import { select } from '@inquirer/prompts'
+import { success } from '../../utils/exec.js'
+import { choosePlatform } from '../choose-platform.js'
+
+describe('choosePlatform()', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('returns "github" when user selects GitHub', async () => {
+    select.mockResolvedValue('github')
+
+    const result = await choosePlatform()
+
+    expect(result).toBe('github')
+    expect(success).toHaveBeenCalledWith('Platform: GitHub')
+  })
+
+  it('returns "azure" when user selects Azure DevOps', async () => {
+    select.mockResolvedValue('azure')
+
+    const result = await choosePlatform()
+
+    expect(result).toBe('azure')
+    expect(success).toHaveBeenCalledWith('Platform: Azure DevOps')
+  })
+})

package/src/steps/__tests__/clean-ai-files.test.js

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import fse from 'fs-extra'
+import os from 'os'
+import path from 'path'
+
+vi.mock('../../utils/exec.js', () => ({
+  header: vi.fn(),
+  success: vi.fn(),
+  warn: vi.fn(),
+  info: vi.fn(),
+  prompt: vi.fn(),
+}))
+
+import { success, warn } from '../../utils/exec.js'
+
+describe('cleanAiFiles()', () => {
+  let tmpDir
+  let originalCwd
+
+  beforeEach(async () => {
+    tmpDir = await fse.mkdtemp(path.join(os.tmpdir(), 'ob-clean-test-'))
+    originalCwd = process.cwd()
+    process.chdir(tmpDir)
+    vi.clearAllMocks()
+    vi.resetModules()
+  })
+
+  afterEach(async () => {
+    process.chdir(originalCwd)
+    await fse.remove(tmpDir)
+  })
+
+  it('prints success when no AI files are found', async () => {
+    const { cleanAiFiles } = await import('../clean-ai-files.js')
+
+    // Simulate immediate Enter key
+    const stdinPush = () => process.stdin.emit('data', '\n')
+    setTimeout(stdinPush, 10)
+
+    await cleanAiFiles()
+
+    expect(success).toHaveBeenCalledWith('No existing AI config files found')
+  })
+
+  it('removes found AI files after Enter', async () => {
+    await fse.writeFile(path.join(tmpDir, 'AGENTS.md'), '# agents')
+    await fse.writeFile(path.join(tmpDir, 'CLAUDE.md'), '# claude')
+
+    const { cleanAiFiles } = await import('../clean-ai-files.js')
+
+    setTimeout(() => process.stdin.emit('data', '\n'), 10)
+
+    await cleanAiFiles()
+
+    expect(await fse.pathExists(path.join(tmpDir, 'AGENTS.md'))).toBe(false)
+    expect(await fse.pathExists(path.join(tmpDir, 'CLAUDE.md'))).toBe(false)
+    expect(success).toHaveBeenCalledWith('Removed existing AI config files')
+  })
+
+  it('removes .agents sub-entries but preserves .agents/skills', async () => {
+    const agentsDir = path.join(tmpDir, '.agents')
+    await fse.ensureDir(path.join(agentsDir, 'agents'))
+    await fse.ensureDir(path.join(agentsDir, 'skills', 'my-skill'))
+    await fse.writeFile(path.join(agentsDir, 'agents', 'front-engineer.md'), 'agent')
+    await fse.writeFile(path.join(agentsDir, 'skills', 'my-skill', 'SKILL.md'), 'skill')
+
+    const { cleanAiFiles } = await import('../clean-ai-files.js')
+
+    setTimeout(() => process.stdin.emit('data', '\n'), 10)
+
+    await cleanAiFiles()
+
+    expect(await fse.pathExists(path.join(agentsDir, 'agents'))).toBe(false)
+    expect(await fse.pathExists(path.join(agentsDir, 'skills', 'my-skill', 'SKILL.md'))).toBe(true)
+  })
+})

package/src/steps/__tests__/copy-content.test.js

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+vi.mock('../../utils/exec.js', () => ({
+  header: vi.fn(),
+  success: vi.fn(),
+  error: vi.fn(),
+}))
+
+vi.mock('../../utils/copy.js', () => ({
+  copyContent: vi.fn(),
+}))
+
+import { copyContent } from '../../utils/copy.js'
+import { success, error } from '../../utils/exec.js'
+import { copyContentStep } from '../copy-content.js'
+
+describe('copyContentStep()', () => {
+  const originalExit = process.exit
+
+  beforeEach(() => {
+    process.exit = vi.fn()
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    process.exit = originalExit
+  })
+
+  it('calls copyContent with the correct platform and prints success', async () => {
+    copyContent.mockResolvedValue(undefined)
+
+    await copyContentStep('github')
+
+    expect(copyContent).toHaveBeenCalledWith(
+      expect.stringContaining('content'),
+      process.cwd(),
+      'github'
+    )
+    expect(success).toHaveBeenCalledWith('Files copied to project root')
+  })
+
+  it('calls copyContent with azure platform', async () => {
+    copyContent.mockResolvedValue(undefined)
+
+    await copyContentStep('azure')
+
+    expect(copyContent).toHaveBeenCalledWith(
+      expect.stringContaining('content'),
+      process.cwd(),
+      'azure'
+    )
+  })
+
+  it('calls process.exit(1) when copyContent throws', async () => {
+    copyContent.mockRejectedValue(new Error('disk full'))
+
+    await copyContentStep('github')
+
+    expect(error).toHaveBeenCalledWith(expect.stringContaining('disk full'))
+    expect(process.exit).toHaveBeenCalledWith(1)
+  })
+})

package/src/steps/check-env.js

@@ -0,0 +1,26 @@
+import { commandExists, error, header, success } from '../utils/exec.js'
+
+export async function checkEnv() {
+  header('Step 1, Checking environment')
+
+  // Node version
+  const nodeVersion = process.version
+  const major = parseInt(nodeVersion.slice(1).split('.')[0], 10)
+  if (major < 18) {
+    error(`Node.js ${nodeVersion} detected. Version 18+ is required.`)
+    process.exit(1)
+  }
+  success(`Node.js ${nodeVersion}`)
+
+  // npm or pnpm
+  const hasPnpm = await commandExists('pnpm')
+  const hasNpm = await commandExists('npm')
+
+  if (!hasPnpm && !hasNpm) {
+    error('Neither npm nor pnpm found. Please install Node.js from https://nodejs.org')
+    process.exit(1)
+  }
+
+  if (hasPnpm) success('pnpm available')
+  else success('npm available')
+}

package/src/steps/check-platform.js

@@ -0,0 +1,80 @@
+import { execa } from 'execa'
+import { code, commandExists, header, info, success, warn } from '../utils/exec.js'
+
+export async function checkPlatform(platform) {
+  if (platform === 'azure') {
+    await checkAzure()
+  } else {
+    await checkGithub()
+  }
+}
+
+async function checkAzure() {
+  header('Step 4, Checking Azure DevOps CLI')
+
+  // Check az is installed
+  const hasAz = await commandExists('az')
+  if (!hasAz) {
+    warn('Azure CLI (az) not found.')
+    info('Install from: https://learn.microsoft.com/en-us/cli/azure/install-azure-cli')
+    return
+  }
+  success('Azure CLI (az) available')
+
+  // Check az devops extension
+  try {
+    const result = await execa('az', ['extension', 'list', '--query', "[?name=='azure-devops']", '-o', 'tsv'], {
+      reject: false,
+    })
+    const hasExtension = result.stdout && result.stdout.includes('azure-devops')
+
+    if (hasExtension) {
+      success('azure-devops extension installed')
+    } else {
+      warn('azure-devops extension not found. Run:')
+      code([
+        'az extension add --name azure-devops',
+        'az config set extension.dynamic_install_allow_preview=true',
+        'az login',
+        'az devops login --organization https://dev.azure.com/<your-org>',
+      ])
+    }
+  } catch {
+    warn('Could not check azure-devops extension. Run:')
+    code([
+      'az extension add --name azure-devops',
+      'az config set extension.dynamic_install_allow_preview=true',
+      'az login',
+      'az devops login --organization https://dev.azure.com/<your-org>',
+    ])
+  }
+}
+
+async function checkGithub() {
+  header('Step 4, Checking GitHub CLI')
+
+  const hasGh = await commandExists('gh')
+
+  if (hasGh) {
+    success('GitHub CLI (gh) available')
+
+    // Check auth status
+    try {
+      const result = await execa('gh', ['auth', 'status'], { reject: false })
+      if (result.exitCode === 0) {
+        success('GitHub CLI authenticated')
+      } else {
+        warn('GitHub CLI not authenticated. Run:')
+        code(['gh auth login'])
+      }
+    } catch {
+      warn('Could not check gh auth status.')
+    }
+  } else {
+    warn('GitHub CLI (gh) not found.')
+    info('Install from: https://cli.github.com')
+    console.log()
+    info('After installing, authenticate with:')
+    code(['gh auth login'])
+  }
+}

package/src/steps/check-rtk.js

@@ -0,0 +1,20 @@
+import { code, commandExists, header, info, success, warn } from '../utils/exec.js'
+
+export async function checkRtk() {
+  header('Step 9, Checking rtk')
+
+  const available = await commandExists('rtk')
+
+  if (available) {
+    success('rtk is available')
+    return
+  }
+
+  warn('rtk not found on PATH.')
+  console.log()
+  info('rtk is required for agents to run CLI commands safely.')
+  info('Install it from: https://github.com/rtk-ai/rtk#pre-built-binaries')
+  console.log()
+  info('After installing, verify with:')
+  code(['rtk --version'])
+}

package/src/steps/choose-models.js

@@ -0,0 +1,141 @@
+import { search } from '@inquirer/prompts'
+import fse from 'fs-extra'
+import path from 'path'
+import { header, info, success, warn } from '../utils/exec.js'
+import { fetchModels } from '../utils/models-cache.js'
+
+const COST_TIER = (input) => {
+  if (input === undefined || input === null) return ''
+  if (input < 1) return ' [$]'
+  if (input <= 10) return ' [$$]'
+  return ' [$$$]'
+}
+
+// Use canonical cost for the tier badge so all providers of the same model
+// show the same tier (e.g. github-copilot $0 subscription shows [$$] not [$])
+const COST_TIER_DISPLAY = (cost, canonicalCost) =>
+  COST_TIER(canonicalCost !== undefined ? canonicalCost : cost)
+
+function formatPrice(price) {
+  if (price === undefined || price === null) return '?'
+  if (price === 0) return '$0 (subscription)'
+  return `$${price}/M`
+}
+
+function buildDisplayModels(rawModels) {
+  return rawModels.map(m => {
+    const priceStr = formatPrice(m.cost)
+    const canonicalNote = m.canonicalCost !== undefined
+      ? ` · official price: ${formatPrice(m.canonicalCost)}/M`
+      : ''
+    return {
+      ...m,
+      label: `${m.name}${COST_TIER_DISPLAY(m.cost, m.canonicalCost)} — ${m.id}`,
+      description: `${priceStr}${canonicalNote} · context: ${m.context ? (m.context / 1000) + 'k' : '?'}`,
+    }
+  })
+}
+
+async function pickModel(message, models) {
+  return await search({
+    message,
+    source: (input) => {
+      const q = (input || '').toLowerCase()
+      const filtered = q
+        ? models.filter(m =>
+            m.label.toLowerCase().includes(q) ||
+            m.id.toLowerCase().includes(q)
+          )
+        : models
+      return filtered.slice(0, 50).map(m => ({
+        name: m.label,
+        value: m.id,
+        description: m.description,
+      }))
+    },
+  })
+}
+
+async function writeModelToAgent(agentFile, modelId) {
+  const content = await fse.readFile(agentFile, 'utf-8')
+  const updated = content.replace(
+    /^(---\n[\s\S]*?)\n---/m,
+    `$1\nmodel: ${modelId}\n---`
+  )
+  await fse.writeFile(agentFile, updated, 'utf-8')
+}
+
+export async function chooseModels() {
+  header('Step 8, Choose models')
+
+  info('Fetching available models from models.dev...')
+  const { models: rawModels, source } = await fetchModels()
+
+  if (!rawModels) {
+    warn('Could not fetch models (offline and no cache). Skipping model selection.')
+    warn('Set models later in .agents/agents/<name>.md and .opencode/opencode.json')
+    return
+  }
+
+  if (source === 'stale-cache') {
+    warn('Network unavailable — using cached model list (may be outdated).')
+  } else if (source === 'cache') {
+    info('Using cached model list (refreshes weekly).')
+  }
+
+  const models = buildDisplayModels(rawModels)
+  success(`${models.length} models available`)
+  console.log()
+  info('Cost indicators: [$] cheap  [$$] mid  [$$$] expensive')
+  info('Type to search. Change selections later in .agents/agents/ and .opencode/opencode.json')
+  console.log()
+
+  // Plan model
+  info('PLAN model — used by the main agent for proposals, specs, architecture decisions.')
+  info('Pick something capable with strong reasoning.')
+  const planModel = await pickModel('Plan model:', models)
+  console.log()
+
+  // Build model
+  info('BUILD model — used by front-engineer, back-engineer, infra-engineer, quality-engineer, security-auditor.')
+  info('Pick something capable for implementation work.')
+  const buildModel = await pickModel('Build model:', models)
+  console.log()
+
+  // Fast model
+  info('FAST model — used by devops-manager for reading issues, classifying PR comments.')
+  info('Pick something fast and cheap — no heavy reasoning needed.')
+  const fastModel = await pickModel('Fast model:', models)
+  console.log()
+
+  // Write build model to builder agents
+  const buildAgents = ['front-engineer', 'back-engineer', 'infra-engineer', 'quality-engineer', 'security-auditor']
+  const agentsDir = path.join(process.cwd(), '.agents', 'agents')
+  for (const name of buildAgents) {
+    const file = path.join(agentsDir, `${name}.md`)
+    if (await fse.pathExists(file)) {
+      await writeModelToAgent(file, buildModel)
+      success(`${name} → ${buildModel}`)
+    }
+  }
+
+  // Write fast model to devops-manager
+  const devopsFile = path.join(agentsDir, 'devops-manager.md')
+  if (await fse.pathExists(devopsFile)) {
+    await writeModelToAgent(devopsFile, fastModel)
+    success(`devops-manager → ${fastModel}`)
+  }
+
+  // Write plan model to opencode.json
+  const opencodeJsonPath = path.join(process.cwd(), '.opencode', 'opencode.json')
+  if (await fse.pathExists(opencodeJsonPath)) {
+    const config = await fse.readJson(opencodeJsonPath)
+    config.model = planModel
+    await fse.writeJson(opencodeJsonPath, config, { spaces: 2 })
+    success(`plan model → ${planModel} (written to .opencode/opencode.json)`)
+  }
+
+  console.log()
+  warn('Make sure you have API access to the selected models.')
+  warn('Change them anytime in .agents/agents/<name>.md and .opencode/opencode.json')
+}

package/src/steps/choose-platform.js

@@ -0,0 +1,22 @@
+import { select } from '@inquirer/prompts'
+import fse from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { header, success } from '../utils/exec.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const PLATFORMS_PRESET_PATH = path.resolve(__dirname, '../presets/platforms.json')
+
+const platformsPreset = await fse.readJson(PLATFORMS_PRESET_PATH)
+
+export async function choosePlatform() {
+  header('Step 3, Version control platform')
+
+  const platform = await select({
+    message: 'Which platform are you using?',
+    choices: platformsPreset.map(p => ({ name: p.name, value: p.value })),
+  })
+
+  success(`Platform: ${platform === 'github' ? 'GitHub' : 'Azure DevOps'}`)
+  return platform
+}