opencode-onboard 0.0.1 → 0.0.5

package/src/index.js

@@ -1,2 +1,68 @@
 #!/usr/bin/env node
-console.log('opencode-onboard — coming soon');
+import chalk from 'chalk'
+import { checkEnv } from './steps/check-env.js'
+import { cleanAiFiles } from './steps/clean-ai-files.js'
+import { choosePlatform } from './steps/choose-platform.js'
+import { copyContentStep } from './steps/copy-content.js'
+import { chooseSkillsProvider } from './steps/choose-skills-provider.js'
+import { initOpenspec } from './steps/init-openspec.js'
+import { installBrowser } from './steps/install-browser.js'
+import { checkRtk } from './steps/check-rtk.js'
+import { checkPlatform } from './steps/check-platform.js'
+
+console.log()
+console.log(chalk.bold('┌─────────────────────────────────────┐'))
+console.log(chalk.bold('│        opencode-onboard             │'))
+console.log(chalk.bold('│  Prepare your codebase for AI agents│'))
+console.log(chalk.bold('└─────────────────────────────────────┘'))
+console.log()
+
+try {
+  // 1. Check Node + npm/pnpm
+  await checkEnv()
+
+  // 2. Clean existing AI config files
+  await cleanAiFiles()
+
+  // 3. Choose platform
+  const platform = await choosePlatform()
+
+  // 4. Copy content filtered by platform
+  await copyContentStep(platform)
+
+  // 5. Choose skills provider
+  await chooseSkillsProvider()
+
+  // 6. Init OpenSpec
+  await initOpenspec()
+
+  // 7. Install opencode-browser
+  await installBrowser()
+
+  // 8. Check rtk
+  await checkRtk()
+
+  // 9. Check platform CLI (az or gh)
+  await checkPlatform(platform)
+
+  // Done
+  console.log()
+  console.log(chalk.bold.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'))
+  console.log(chalk.bold.green('  Onboarding complete!'))
+  console.log(chalk.bold.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'))
+  console.log()
+  console.log('  Next step:')
+  console.log(chalk.cyan('  Open OpenCode in this project and type: ') + chalk.bold('"init"'))
+  console.log()
+  console.log('  OpenCode will generate ARCHITECTURE.md and DESIGN.md')
+  console.log('  from your actual codebase, then activate the agent team.')
+  console.log()
+} catch (err) {
+  if (err.name === 'ExitPromptError') {
+    console.log()
+    console.log(chalk.yellow('Cancelled.'))
+  } else {
+    console.error(chalk.red('\nUnexpected error:'), err.message)
+    process.exit(1)
+  }
+}

package/src/presets/platforms.json

@@ -0,0 +1,10 @@
+[
+  {
+    "value": "github",
+    "name": "GitHub"
+  },
+  {
+    "value": "azure",
+    "name": "Azure DevOps"
+  }
+]

package/src/presets/skills-providers.json

@@ -0,0 +1,14 @@
+[
+  {
+    "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__/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__/choose-team.test.js

@@ -0,0 +1,105 @@
+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')
+  })
+})

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

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+vi.mock('../../utils/exec.js', () => ({
+  header: vi.fn(),
+  success: vi.fn(),
+  warn: vi.fn(),
+  info: vi.fn(),
+}))
+
+vi.mock('../../utils/copy.js', () => ({
+  findAiFiles: vi.fn(),
+}))
+
+vi.mock('fs-extra', () => ({
+  default: { remove: vi.fn() },
+}))
+
+vi.mock('@inquirer/prompts', () => ({
+  confirm: vi.fn(),
+}))
+
+import { findAiFiles } from '../../utils/copy.js'
+import { success, warn } from '../../utils/exec.js'
+import fse from 'fs-extra'
+import { confirm } from '@inquirer/prompts'
+import { cleanAiFiles } from '../clean-ai-files.js'
+
+describe('cleanAiFiles()', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('prints success when no AI files are found', async () => {
+    findAiFiles.mockResolvedValue([])
+
+    await cleanAiFiles()
+
+    expect(success).toHaveBeenCalledWith('No existing AI config files found')
+    expect(confirm).not.toHaveBeenCalled()
+  })
+
+  it('deletes files when user confirms', async () => {
+    findAiFiles.mockResolvedValue(['/proj/AGENTS.md', '/proj/CLAUDE.md'])
+    confirm.mockResolvedValue(true)
+
+    await cleanAiFiles()
+
+    expect(fse.remove).toHaveBeenCalledWith('/proj/AGENTS.md')
+    expect(fse.remove).toHaveBeenCalledWith('/proj/CLAUDE.md')
+    expect(success).toHaveBeenCalledWith('Removed existing AI config files')
+  })
+
+  it('skips deletion when user declines', async () => {
+    findAiFiles.mockResolvedValue(['/proj/AGENTS.md'])
+    confirm.mockResolvedValue(false)
+
+    await cleanAiFiles()
+
+    expect(fse.remove).not.toHaveBeenCalled()
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining('Skipped'))
+  })
+})

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 9, 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 9, 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'])
+  }
+}