opencode-onboard 0.0.1 → 0.0.5

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 8, 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-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
+}

package/src/steps/choose-skills-provider.js

@@ -0,0 +1,56 @@
+import { select } from '@inquirer/prompts'
+import fse from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { header, info, success, warn } from '../utils/exec.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const SKILLS_PROVIDERS_PATH = path.resolve(__dirname, '../presets/skills-providers.json')
+const CONTENT_SKILLS_DIR = path.resolve(__dirname, '../../content/.opencode/skills')
+
+const providers = await fse.readJson(SKILLS_PROVIDERS_PATH)
+
+export async function chooseSkillsProvider() {
+  header('Step 5, Choose your skills provider')
+
+  info('Skills provide platform and tech-specific knowledge to your agents.')
+  info('Agents detect and load skills automatically, you never need to specify them.')
+  console.log()
+
+  const selected = await select({
+    message: 'Install skills from:',
+    choices: providers.map(p => ({
+      name: `${p.label}${p.description ? `\n    ${p.description}` : ''}`,
+      value: p.value,
+    })),
+  })
+
+  if (selected === 'none') {
+    warn('No skills installed. Add skills to .opencode/skills/ manually.')
+    return null
+  }
+
+  if (selected === 'ob-skills') {
+    const destSkillsDir = path.join(process.cwd(), '.opencode', 'skills')
+    await fse.ensureDir(destSkillsDir)
+
+    const skills = await fse.readdir(CONTENT_SKILLS_DIR)
+    for (const skill of skills) {
+      const src = path.join(CONTENT_SKILLS_DIR, skill)
+      const dest = path.join(destSkillsDir, skill)
+      const stat = await fse.stat(src)
+      if (!stat.isDirectory()) continue
+      if (await fse.pathExists(dest)) {
+        info(`${skill} already exists, skipping`)
+        continue
+      }
+      await fse.copy(src, dest)
+      success(`Installed skill: ${skill}`)
+    }
+    return selected
+  }
+
+  // Custom provider, future: support npx <package> or git URL
+  warn(`Custom provider "${selected}" not yet supported. Add skills to .opencode/skills/ manually.`)
+  return null
+}

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

@@ -0,0 +1,51 @@
+import fse from 'fs-extra'
+import path from 'path'
+import { findAiFiles } from '../utils/copy.js'
+import { header, info, success, warn } from '../utils/exec.js'
+
+export async function cleanAiFiles() {
+  header('Step 2, Existing AI config files')
+
+  const cwd = process.cwd()
+  const found = await findAiFiles(cwd)
+
+  // Also find .opencode contents except skills/ (preserve user skills)
+  const opencodeDir = path.join(cwd, '.opencode')
+  const opencodeEntries = []
+  if (await fse.pathExists(opencodeDir)) {
+    const entries = await fse.readdir(opencodeDir)
+    for (const entry of entries) {
+      if (entry !== 'skills') {
+        opencodeEntries.push(path.join(opencodeDir, entry))
+      }
+    }
+  }
+
+  const allFiles = [...found, ...opencodeEntries]
+
+  if (allFiles.length === 0) {
+    success('No existing AI config files found')
+    return
+  }
+
+  warn('Found the following AI config files:')
+  for (const f of allFiles) {
+    info(f.replace(cwd, '.'))
+  }
+  console.log()
+  info('Press Enter to remove them all (your .opencode/skills/ will be kept)')
+  console.log()
+
+  await new Promise(resolve => {
+    process.stdin.resume()
+    process.stdin.once('data', () => {
+      process.stdin.pause()
+      resolve()
+    })
+  })
+
+  for (const f of allFiles) {
+    await fse.remove(f)
+  }
+  success('Removed existing AI config files')
+}

package/src/steps/copy-content.js

@@ -0,0 +1,21 @@
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { copyContent } from '../utils/copy.js'
+import { error, header, success } from '../utils/exec.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const CONTENT_DIR = path.resolve(__dirname, '../../content')
+
+export async function copyContentStep(platform) {
+  header('Step 4, Copying opencode-onboard files')
+
+  const dest = process.cwd()
+
+  try {
+    await copyContent(CONTENT_DIR, dest, platform)
+    success('Files copied to project root')
+  } catch (err) {
+    error(`Failed to copy content: ${err.message}`)
+    process.exit(1)
+  }
+}

package/src/steps/init-openspec.js

@@ -0,0 +1,22 @@
+import { execa } from 'execa'
+import { error, header, success, warn } from '../utils/exec.js'
+
+export async function initOpenspec() {
+  header('Step 6, Initializing OpenSpec')
+
+  try {
+    const result = await execa('npx', ['@fission-ai/openspec', 'init', '--tools', 'opencode', '--force'], {
+      cwd: process.cwd(),
+      stdio: 'pipe',
+      reject: false,
+    })
+
+    if (result.exitCode === 0) {
+      success('OpenSpec initialized')
+    } else {
+      warn('OpenSpec init exited with non-zero code, check output above')
+    }
+  } catch (err) {
+    error(`Failed to run openspec init: ${err.message}`)
+  }
+}

package/src/steps/install-browser.js

@@ -0,0 +1,65 @@
+import { execa } from 'execa'
+import { error, header, success, warn } from '../utils/exec.js'
+import os from 'os'
+
+export async function installBrowser() {
+  header('Step 7, Installing opencode-browser')
+
+  try {
+    const child = execa('npx', ['@different-ai/opencode-browser', 'install'], {
+      cwd: os.homedir(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+      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
+
+    child.stdout.on('data', (chunk) => {
+      const text = chunk.toString()
+
+      if (showOutput) {
+        process.stdout.write(chunk)
+      }
+
+      // 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
+      }
+
+      // 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')
+          pendingTriggers.splice(i, 1)
+          break
+        }
+      }
+    })
+
+    const result = await child
+
+    if (result.exitCode === 0) {
+      success('opencode-browser installed')
+    } else {
+      warn('opencode-browser install exited with non-zero code')
+    }
+  } catch (err) {
+    error(`Failed to install opencode-browser: ${err.message}`)
+  }
+}

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

@@ -0,0 +1,132 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import path from 'path'
+import os from 'os'
+import fse from 'fs-extra'
+
+// Use real fs-extra for file system tests (temp dirs)
+import { copyContent, findAiFiles } from '../copy.js'
+
+const tmpDir = () => fse.mkdtempSync(path.join(os.tmpdir(), 'ob-test-'))
+
+describe('copy utils', () => {
+  describe('findAiFiles()', () => {
+    let dir
+
+    beforeEach(() => {
+      dir = tmpDir()
+    })
+
+    afterEach(async () => {
+      await fse.remove(dir)
+    })
+
+    it('returns empty array when no AI files exist', async () => {
+      const found = await findAiFiles(dir)
+      expect(found).toEqual([])
+    })
+
+    it('detects AGENTS.md', async () => {
+      await fse.writeFile(path.join(dir, 'AGENTS.md'), '# agents')
+      const found = await findAiFiles(dir)
+      expect(found).toHaveLength(1)
+      expect(found[0]).toContain('AGENTS.md')
+    })
+
+    it('detects CLAUDE.md', async () => {
+      await fse.writeFile(path.join(dir, 'CLAUDE.md'), '# claude')
+      const found = await findAiFiles(dir)
+      expect(found).toHaveLength(1)
+      expect(found[0]).toContain('CLAUDE.md')
+    })
+
+    it('detects multiple AI files at once', async () => {
+      await fse.writeFile(path.join(dir, 'AGENTS.md'), '')
+      await fse.writeFile(path.join(dir, '.cursorrules'), '')
+      await fse.writeFile(path.join(dir, '.clinerules'), '')
+      const found = await findAiFiles(dir)
+      expect(found).toHaveLength(3)
+    })
+
+    it('detects nested copilot-instructions.md', async () => {
+      const ghDir = path.join(dir, '.github')
+      await fse.ensureDir(ghDir)
+      await fse.writeFile(path.join(ghDir, 'copilot-instructions.md'), '')
+      const found = await findAiFiles(dir)
+      expect(found).toHaveLength(1)
+      expect(found[0]).toContain('copilot-instructions.md')
+    })
+  })
+
+  describe('copyContent()', () => {
+    let src, dest
+
+    beforeEach(async () => {
+      src = tmpDir()
+      dest = tmpDir()
+    })
+
+    afterEach(async () => {
+      await fse.remove(src)
+      await fse.remove(dest)
+    })
+
+    it('copies files that match neither platform exclusion', async () => {
+      await fse.writeFile(path.join(src, 'AGENTS.md'), '# agents')
+      await copyContent(src, dest, 'github')
+      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')
+
+      await copyContent(src, dest, 'github')
+
+      expect(await fse.pathExists(path.join(dest, '.bootstrap', 'secret.md'))).toBe(false)
+    })
+
+    it('does not overwrite existing files', async () => {
+      await fse.writeFile(path.join(src, 'AGENTS.md'), 'new content')
+      await fse.writeFile(path.join(dest, 'AGENTS.md'), 'original content')
+
+      await copyContent(src, dest, 'github')
+
+      const content = await fse.readFile(path.join(dest, 'AGENTS.md'), 'utf-8')
+      expect(content).toBe('original content')
+    })
+
+    it('copies github-specific files when platform is github', async () => {
+      await fse.writeFile(path.join(src, 'agent-gh.md'), 'github agent')
+      await copyContent(src, dest, 'github')
+      expect(await fse.pathExists(path.join(dest, 'agent-gh.md'))).toBe(true)
+    })
+
+    it('copies azure-specific files when platform is azure', async () => {
+      await fse.writeFile(path.join(src, 'agent-az.md'), 'azure agent')
+      await copyContent(src, dest, 'azure')
+      expect(await fse.pathExists(path.join(dest, 'agent-az.md'))).toBe(true)
+    })
+  })
+})

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

@@ -0,0 +1,106 @@
+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 },
+    green: (s) => s,
+    yellow: (s) => s,
+    red: (s) => s,
+    dim: (s) => s,
+    bgGray: { white: (s) => s },
+  },
+}))
+
+// Mock ora spinner
+vi.mock('ora', () => ({
+  default: () => ({ start: () => ({ succeed: vi.fn(), fail: vi.fn() }) }),
+}))
+
+// Mock execa
+vi.mock('execa', () => ({
+  execa: vi.fn(),
+}))
+
+import { execa } from 'execa'
+import { run, commandExists, header, success, warn, error, info, code } from '../exec.js'
+
+describe('exec utils', () => {
+  beforeEach(() => {
+    vi.spyOn(console, 'log').mockImplementation(() => {})
+  })
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('run()', () => {
+    it('returns success=true when exitCode is 0', async () => {
+      execa.mockResolvedValue({ exitCode: 0, stdout: 'ok', stderr: '' })
+      const result = await run('node', ['--version'])
+      expect(result).toEqual({ success: true, stdout: 'ok', stderr: '' })
+    })
+
+    it('returns success=false when exitCode is non-zero', async () => {
+      execa.mockResolvedValue({ exitCode: 1, stdout: '', stderr: 'error' })
+      const result = await run('node', ['--bad-flag'])
+      expect(result).toEqual({ success: false, stdout: '', stderr: 'error' })
+    })
+
+    it('returns success=false when execa throws', async () => {
+      execa.mockRejectedValue(new Error('spawn ENOENT'))
+      const result = await run('nonexistent-command', [])
+      expect(result.success).toBe(false)
+      expect(result.stderr).toBe('spawn ENOENT')
+    })
+  })
+
+  describe('commandExists()', () => {
+    it('returns true when command exits with code 0', async () => {
+      execa.mockResolvedValue({ exitCode: 0 })
+      expect(await commandExists('node')).toBe(true)
+    })
+
+    it('returns false when command exits with non-zero code', async () => {
+      execa.mockResolvedValue({ exitCode: 1 })
+      expect(await commandExists('badcmd')).toBe(false)
+    })
+
+    it('returns false when execa throws (command not found)', async () => {
+      execa.mockRejectedValue(new Error('spawn ENOENT'))
+      expect(await commandExists('no-such-binary')).toBe(false)
+    })
+  })
+
+  describe('console helpers', () => {
+    it('header() calls console.log', () => {
+      header('Test Header')
+      expect(console.log).toHaveBeenCalled()
+    })
+
+    it('success() calls console.log with text', () => {
+      success('all good')
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('all good'))
+    })
+
+    it('warn() calls console.log with text', () => {
+      warn('watch out')
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('watch out'))
+    })
+
+    it('error() calls console.log with text', () => {
+      error('something broke')
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('something broke'))
+    })
+
+    it('info() calls console.log with text', () => {
+      info('just info')
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('just info'))
+    })
+
+    it('code() calls console.log for each line', () => {
+      code(['line one', 'line two'])
+      // 2 lines + 2 blank lines surrounding them
+      expect(console.log).toHaveBeenCalledTimes(4)
+    })
+  })
+})

package/src/utils/copy.js

@@ -0,0 +1,54 @@
+import fse from 'fs-extra'
+import path from 'path'
+
+// Folders never copied (internal bootstrap tooling)
+const ALWAYS_EXCLUDE = ['.bootstrap', 'skills']
+
+/**
+ * Copy content/ directory to destination, excluding skills (handled separately by chooseSkillsProvider)
+ * and internal bootstrap tooling.
+ * @param {string} contentDir - absolute path to content/
+ * @param {string} destDir - absolute path to destination (project root)
+ * @param {'azure'|'github'} platform
+ */
+export async function copyContent(contentDir, destDir, platform) {
+  await fse.copy(contentDir, destDir, {
+    overwrite: false,
+    filter: (src) => {
+      const rel = path.relative(contentDir, src)
+      const parts = rel.split(path.sep)
+      return !parts.some(part =>
+        ALWAYS_EXCLUDE.some(pattern => part.includes(pattern))
+      )
+    },
+  })
+}
+
+/**
+ * Scan a directory for known AI config files.
+ * Returns array of absolute paths found.
+ */
+const AI_FILES = [
+  'AGENTS.md',
+  'CLAUDE.md',
+  'ARCHITECTURE.md',
+  'DESIGN.md',
+  '.cursorrules',
+  '.clinerules',
+  '.windsurfrules',
+  '.github/copilot-instructions.md',
+  'copilot-instructions.md',
+  '.aider.conf.yml',
+  '.aider',
+]
+
+export async function findAiFiles(dir) {
+  const found = []
+  for (const file of AI_FILES) {
+    const fullPath = path.join(dir, file)
+    if (await fse.pathExists(fullPath)) {
+      found.push(fullPath)
+    }
+  }
+  return found
+}

package/src/utils/exec.js

@@ -0,0 +1,84 @@
+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()
+}