opencode-onboard 0.0.1 → 0.1.0

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

@@ -0,0 +1,75 @@
+import { select } from '@inquirer/prompts'
+import fse from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { execa } from 'execa'
+import { header, info, success, warn } from '../utils/exec.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const CONTENT_SKILLS_DIR = path.resolve(__dirname, '../../content/.agents/skills')
+
+async function installObSkills() {
+  const destSkillsDir = path.join(process.cwd(), '.agents', '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}`)
+  }
+}
+
+export async function chooseSkillsProvider() {
+  header('Step 7, Installing skills')
+
+  // ob-skills are always installed — mandatory
+  info('Installing built-in ob-skills...')
+  await installObSkills()
+  console.log()
+
+  info('Skills provide platform and tech-specific knowledge to your agents.')
+  info('Agents detect and load skills automatically — you never need to specify them.')
+  info('You can add more skills on top of the built-in ones.')
+  console.log()
+
+  const selected = await select({
+    message: 'Add additional skills from:',
+    choices: [
+      {
+        name: 'npx skills (vercel-labs/skills)',
+        value: 'npx-skills',
+        description: 'Install skills from the vercel-labs community skills registry',
+      },
+      {
+        name: 'None — built-in skills are enough',
+        value: 'none',
+      },
+    ],
+  })
+
+  if (selected === 'none') {
+    return
+  }
+
+  if (selected === 'npx-skills') {
+    info('Running npx skills...')
+    console.log()
+    try {
+      await execa('npx', ['skills'], {
+        cwd: process.cwd(),
+        stdio: 'inherit',
+        reject: false,
+      })
+    } catch (err) {
+      warn(`npx skills failed: ${err.message}`)
+    }
+  }
+}

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, prompt, 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 .agents contents except skills/ (preserve user skills)
+  const agentsDir = path.join(cwd, '.agents')
+  const agentsEntries = []
+  if (await fse.pathExists(agentsDir)) {
+    const entries = await fse.readdir(agentsDir)
+    for (const entry of entries) {
+      if (entry !== 'skills') {
+        agentsEntries.push(path.join(agentsDir, entry))
+      }
+    }
+  }
+
+  const allFiles = [...found, ...agentsEntries]
+
+  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()
+  prompt('Press Enter to remove them all (your .agents/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 5, 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,57 @@
+import { execa } from 'execa'
+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 10, Installing opencode-browser')
+
+  try {
+    const child = execa('npx', ['@different-ai/opencode-browser', 'install'], {
+      cwd: os.homedir(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+      reject: false,
+    })
+
+    const pendingTriggers = [...AUTO_ANSWERS]
+    let show = false
+
+    child.stdout.on('data', (chunk) => {
+      const text = chunk.toString()
+
+      // 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
+
+      if (show) process.stdout.write(chunk)
+
+      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
+        }
+      }
+    })
+
+    child.stderr.on('data', (chunk) => process.stderr.write(chunk))
+
+    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,110 @@
+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('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,108 @@
+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: { hex: () => (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(), stop: 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() clears screen and writes output', () => {
+      vi.spyOn(process.stdout, 'write').mockImplementation(() => {})
+      vi.spyOn(console, 'clear').mockImplementation(() => {})
+      header('Test Header')
+      expect(process.stdout.write).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 (skills handled separately by chooseSkillsProvider, .bootstrap is internal 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,161 @@
+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 }
+ */
+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()
+}