opencode-onboard 0.3.1 → 0.4.1

package/src/steps/optimization/index.js

@@ -0,0 +1,101 @@
+import { checkbox, confirm } from '@inquirer/prompts'
+import fse from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { code, commandExists, header, info, loading, success, warn } from '../../utils/exec.js'
+import { installQuota } from './quota.js'
+import { installCaveman } from './caveman.js'
+import { enableCavemanGuidance } from './caveman-guidance.js'
+import { configureObGlobal } from './global.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const OPTIMIZATION_PRESET_PATH = path.resolve(__dirname, '../../presets/optimization.json')
+const optimizationPreset = await fse.readJson(OPTIMIZATION_PRESET_PATH)
+
+export async function checkRtk(options = {}) {
+  if (!options.skipHeader) header('Checking rtk')
+
+  let shouldCheck = true
+  if (!options.skipPrompt) {
+    info('Recommended: install and verify rtk for safer agent CLI command execution.')
+    shouldCheck = await confirm({
+      message: 'Check rtk now?',
+      default: true,
+    })
+  }
+
+  if (!shouldCheck) {
+    warn('Skipped rtk check (you can install it later)')
+    return { optedIn: false, checked: false, available: false }
+  }
+
+  loading('checking rtk...')
+
+  const available = await commandExists('rtk')
+
+  if (available) {
+    success('rtk is available')
+    return { optedIn: true, checked: true, available: true }
+  }
+
+  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'])
+  return { optedIn: true, checked: true, available: false }
+}
+
+export async function tokenOptimizationStep(options = {}) {
+  header('Step 8, Token optimization tools')
+
+  const defaultSelected = optimizationPreset.choices
+    .filter(choice => choice.checked)
+    .map(choice => choice.value)
+  let selected = defaultSelected
+
+  if (!options.skipPrompt && process.stdin.isTTY) {
+    info(optimizationPreset.info)
+    const timeoutMs = optimizationPreset.timeoutMs
+    const choice = await Promise.race([
+      checkbox({
+        message: optimizationPreset.message,
+        choices: optimizationPreset.choices,
+      }),
+      new Promise(resolve => setTimeout(() => resolve(defaultSelected), timeoutMs)),
+    ])
+    selected = Array.isArray(choice) ? choice : defaultSelected
+  }
+
+  loading('applying token optimization selections...')
+
+  const has = value => selected.includes(value)
+
+  const rtk = has('rtk')
+    ? await checkRtk({ skipHeader: true, skipPrompt: true })
+    : { optedIn: false, checked: false, available: false }
+
+  const quota = has('quota')
+    ? await installQuota({ skipHeader: true, skipPrompt: true })
+    : { optedIn: false, installed: false }
+
+  const caveman = has('caveman')
+    ? await installCaveman({
+      skipHeader: true,
+      skipPrompt: true,
+    })
+    : { optedIn: false, installed: false }
+
+  const cavemanGuidance = has('caveman')
+    ? await enableCavemanGuidance(caveman)
+    : { enabled: false }
+
+  const obGlobal = await configureObGlobal(options.ctx || {}, { rtk, quota, caveman, cavemanGuidance })
+
+  if (selected.length === 0) warn('No token optimization tools selected')
+  else success('Token optimization step completed')
+
+  return { rtk, quota, caveman, cavemanGuidance, obGlobal }
+}

package/src/steps/{__tests__/token-optimization.test.js → optimization/optimization.test.js}

@@ -2,9 +2,12 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 vi.mock('@inquirer/prompts', () => ({
   checkbox: vi.fn(),
+  confirm: vi.fn(),
 }))
 
 vi.mock('../../utils/exec.js', () => ({
+  code: vi.fn(),
+  commandExists: vi.fn(),
   header: vi.fn(),
   info: vi.fn(),
   loading: vi.fn(),
@@ -12,29 +15,18 @@ vi.mock('../../utils/exec.js', () => ({
   warn: vi.fn(),
 }))
 
-vi.mock('../check-rtk.js', () => ({
-  checkRtk: vi.fn(),
-}))
-
-vi.mock('../install-quota.js', () => ({
-  installQuota: vi.fn(),
-}))
-
-vi.mock('../install-caveman.js', () => ({
-  installCaveman: vi.fn(),
-}))
-
-vi.mock('../enable-caveman-guidance.js', () => ({
-  enableCavemanGuidance: vi.fn(),
-}))
+vi.mock('./quota.js', () => ({ installQuota: vi.fn() }))
+vi.mock('./caveman.js', () => ({ installCaveman: vi.fn() }))
+vi.mock('./caveman-guidance.js', () => ({ enableCavemanGuidance: vi.fn() }))
+vi.mock('./global.js', () => ({ configureObGlobal: vi.fn() }))
 
 import { checkbox } from '@inquirer/prompts'
-import { warn } from '../../utils/exec.js'
-import { checkRtk } from '../check-rtk.js'
-import { installQuota } from '../install-quota.js'
-import { installCaveman } from '../install-caveman.js'
-import { enableCavemanGuidance } from '../enable-caveman-guidance.js'
-import { tokenOptimizationStep } from '../token-optimization.js'
+import { commandExists, warn } from '../../utils/exec.js'
+import { installQuota } from './quota.js'
+import { installCaveman } from './caveman.js'
+import { enableCavemanGuidance } from './caveman-guidance.js'
+import { configureObGlobal } from './global.js'
+import { tokenOptimizationStep } from './index.js'
 
 describe('tokenOptimizationStep()', () => {
   beforeEach(() => {
@@ -43,17 +35,19 @@ describe('tokenOptimizationStep()', () => {
 
   it('runs all optimizations by default selection', async () => {
     checkbox.mockResolvedValue(['rtk', 'quota', 'caveman'])
-    checkRtk.mockResolvedValue({ optedIn: true, checked: true, available: true })
+    commandExists.mockResolvedValue(true)
     installQuota.mockResolvedValue({ optedIn: true, installed: true })
     installCaveman.mockResolvedValue({ optedIn: true, installed: true })
     enableCavemanGuidance.mockResolvedValue({ enabled: true })
+    configureObGlobal.mockResolvedValue({ configured: true })
 
     const result = await tokenOptimizationStep()
 
-    expect(checkRtk).toHaveBeenCalledWith({ skipHeader: true, skipPrompt: true })
+    expect(commandExists).toHaveBeenCalledWith('rtk')
     expect(installQuota).toHaveBeenCalledWith({ skipHeader: true, skipPrompt: true })
     expect(installCaveman).toHaveBeenCalledWith({ skipHeader: true, skipPrompt: true })
     expect(enableCavemanGuidance).toHaveBeenCalledWith({ optedIn: true, installed: true })
+    expect(configureObGlobal).toHaveBeenCalled()
     expect(result.rtk.available).toBe(true)
     expect(result.quota.installed).toBe(true)
     expect(result.caveman.installed).toBe(true)
@@ -65,10 +59,11 @@ describe('tokenOptimizationStep()', () => {
 
     const result = await tokenOptimizationStep()
 
-    expect(checkRtk).not.toHaveBeenCalled()
+    expect(commandExists).not.toHaveBeenCalled()
     expect(installQuota).not.toHaveBeenCalled()
     expect(installCaveman).not.toHaveBeenCalled()
     expect(enableCavemanGuidance).not.toHaveBeenCalled()
+    expect(configureObGlobal).toHaveBeenCalled()
     expect(warn).toHaveBeenCalledWith('No token optimization tools selected')
     expect(result.rtk.optedIn).toBe(false)
     expect(result.quota.optedIn).toBe(false)

package/src/steps/{install-quota.js → optimization/quota.js}

@@ -1,9 +1,13 @@
 import { confirm } from '@inquirer/prompts'
 import fse from 'fs-extra'
 import path from 'node:path'
-import { header, success, warn, error, loading, info } from '../utils/exec.js'
+import { fileURLToPath } from 'url'
+import { error, header, info, loading, success, warn } from '../../utils/exec.js'
 
-const PLUGIN = '@slkiser/opencode-quota'
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const QUOTA_PRESET_PATH = path.resolve(__dirname, '../../presets/quota.json')
+const quotaPreset = await fse.readJson(QUOTA_PRESET_PATH)
+const PLUGIN = quotaPreset.plugin
 
 function ensurePlugin(config) {
   if (!Array.isArray(config.plugin)) config.plugin = []
@@ -19,11 +23,11 @@ export async function installQuota(options = {}) {
 
   let shouldInstall = true
   if (!options.skipPrompt && process.stdin.isTTY) {
-    const timeoutMs = 20000
+    const timeoutMs = quotaPreset.prompt.timeoutMs
     const choice = await Promise.race([
       confirm({
-        message: 'Install opencode-quota with recommended defaults?',
-        default: true,
+        message: quotaPreset.prompt.message,
+        default: quotaPreset.prompt.default,
       }),
       new Promise(resolve => setTimeout(() => resolve(true), timeoutMs)),
     ])
@@ -63,11 +67,9 @@ export async function installQuota(options = {}) {
       ? await fse.readJson(quotaPath)
       : {}
 
-    // Keep installer semantics append-only: add defaults only when missing.
-    addIfMissing(quotaConfig, 'enabledProviders', 'auto')
-    addIfMissing(quotaConfig, 'formatStyle', 'singleWindow')
-    addIfMissing(quotaConfig, 'percentDisplayMode', 'used')
-    addIfMissing(quotaConfig, 'showSessionTokens', true)
+    for (const [key, value] of Object.entries(quotaPreset.defaults)) {
+      addIfMissing(quotaConfig, key, value)
+    }
 
     await fse.ensureDir(quotaDir)
     await fse.writeJson(quotaPath, quotaConfig, { spaces: 2 })

package/src/steps/platform/index.js

@@ -0,0 +1,81 @@
+import { select } from '@inquirer/prompts'
+import { execa } from 'execa'
+import fse from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { code, commandExists, header, info, success, warn } 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 checkPlatform(platform) {
+  const preset = platformsPreset.find(p => p.value === platform) || platformsPreset[0]
+  await checkPlatformCli(preset)
+}
+
+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'}`)
+  await checkPlatform(platform)
+  return platform
+}
+
+async function checkPlatformCli(platformPreset) {
+  const { cli } = platformPreset
+  header(`Step 4, Checking ${platformPreset.name} CLI`)
+
+  const hasCli = await commandExists(cli.command)
+  if (!hasCli) {
+    warn(`${cli.displayName} not found.`)
+    info(`Install from: ${cli.installUrl}`)
+    if (cli.authCheck?.commands?.length) {
+      console.log()
+      info('After installing, authenticate with:')
+      code(cli.authCheck.commands)
+    }
+    return
+  }
+  success(`${cli.displayName} available`)
+
+  if (cli.authCheck) await runAuthCheck(cli)
+  if (cli.extensionCheck) await runExtensionCheck(cli)
+}
+
+async function runAuthCheck(cli) {
+  try {
+    const result = await execa(cli.command, cli.authCheck.args, { reject: false })
+    if (result.exitCode === 0) {
+      success(`${cli.displayName} authenticated`)
+    } else {
+      warn(cli.authCheck.notAuthenticatedMessage)
+      code(cli.authCheck.commands)
+    }
+  } catch {
+    warn(`Could not check ${cli.command} auth status.`)
+  }
+}
+
+async function runExtensionCheck(cli) {
+  try {
+    const result = await execa(cli.command, cli.extensionCheck.args, { reject: false })
+    const hasExtension = result.stdout && result.stdout.includes(cli.extensionCheck.expectedOutput)
+
+    if (hasExtension) {
+      success(`${cli.extensionCheck.expectedOutput} extension installed`)
+    } else {
+      warn(cli.extensionCheck.missingMessage)
+      code(cli.extensionCheck.commands)
+    }
+  } catch {
+    warn(cli.extensionCheck.errorMessage)
+    code(cli.extensionCheck.commands)
+  }
+}

package/src/steps/platform/platform.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+vi.mock('../../utils/exec.js', () => ({
+  code: vi.fn(),
+  commandExists: vi.fn(),
+  header: vi.fn(),
+  info: vi.fn(),
+  success: vi.fn(),
+  warn: vi.fn(),
+}))
+
+vi.mock('@inquirer/prompts', () => ({
+  select: vi.fn(),
+}))
+
+vi.mock('execa', () => ({
+  execa: vi.fn(),
+}))
+
+import { select } from '@inquirer/prompts'
+import { execa } from 'execa'
+import { commandExists, success, warn } from '../../utils/exec.js'
+import { checkPlatform, choosePlatform } from './index.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')
+  })
+
+  describe('checkPlatform()', () => {
+    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/{choose-source-scope.js → source/index.js}

@@ -1,7 +1,12 @@
 import { checkbox, select } from '@inquirer/prompts'
 import fse from 'fs-extra'
 import path from 'path'
-import { header, info, success, warn } from '../utils/exec.js'
+import { fileURLToPath } from 'url'
+import { header, info, success, warn } from '../../utils/exec.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const SOURCE_PRESET_PATH = path.resolve(__dirname, '../../presets/source.json')
+const sourcePreset = await fse.readJson(SOURCE_PRESET_PATH)
 
 async function listParentFolders(cwd) {
   const parent = path.resolve(cwd, '..')
@@ -26,26 +31,15 @@ async function listParentFolders(cwd) {
 }
 
 export async function chooseSourceScope() {
-  header('Step 2, Source code scope')
+  header('Step 1, Source code scope')
 
   const cwd = process.cwd()
   info('Choose where agents should read source code from during init analysis.')
 
   const mode = await select({
-    message: 'Source code location:',
-    default: 'current',
-    choices: [
-      {
-        name: 'Current folder (default)',
-        value: 'current',
-        description: 'Use this repository only',
-      },
-      {
-        name: 'Select folders in parent (../)',
-        value: 'parent',
-        description: 'Use when this repo only contains agent config',
-      },
-    ],
+    message: sourcePreset.message,
+    default: sourcePreset.default,
+    choices: sourcePreset.choices,
   })
 
   if (mode === 'current') {
@@ -61,7 +55,7 @@ export async function chooseSourceScope() {
   }
 
   const selected = await checkbox({
-    message: 'Select source folders from parent directory:',
+    message: sourcePreset.parentSelectionMessage,
     choices: parentFolders.map(d => ({
       name: `../${d.name}`,
       value: d.abs,

package/src/steps/source/source.test.js

@@ -0,0 +1,89 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+vi.mock('../../utils/exec.js', () => ({
+  header: vi.fn(),
+  info: vi.fn(),
+  success: vi.fn(),
+  warn: vi.fn(),
+}))
+
+vi.mock('@inquirer/prompts', () => ({
+  select: vi.fn(),
+  checkbox: vi.fn(),
+}))
+
+vi.mock('fs-extra', () => ({
+  default: {
+    readJson: vi.fn().mockResolvedValue({
+      message: 'Select source scope',
+      default: 'current',
+      choices: [
+        { name: 'Current folder', value: 'current' },
+        { name: 'Parent folder', value: 'parent' },
+      ],
+      parentSelectionMessage: 'Select sibling folders',
+    }),
+    readdir: vi.fn(),
+    stat: vi.fn(),
+  },
+}))
+
+import { select, checkbox } from '@inquirer/prompts'
+import fse from 'fs-extra'
+import { chooseSourceScope } from './index.js'
+
+describe('chooseSourceScope()', () => {
+  let tmpDir
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'source-test-'))
+    process.chdir(tmpDir)
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('returns current folder when user selects current mode', async () => {
+    select.mockResolvedValue('current')
+
+    const result = await chooseSourceScope()
+
+    expect(result.sourceMode).toBe('current')
+    expect(result.sourceRoots).toContain(tmpDir)
+  })
+
+  it('lists parent folders when user selects parent mode', async () => {
+    select.mockResolvedValue('parent')
+    const parentDir = path.dirname(tmpDir)
+    const siblingDir = path.join(parentDir, 'sibling-project')
+    fs.mkdirSync(siblingDir)
+    fse.readdir.mockResolvedValue(['sibling-project'])
+
+    await chooseSourceScope()
+
+    expect(checkbox).toHaveBeenCalled()
+  })
+
+  it('falls back to current when no siblings found', async () => {
+    select.mockResolvedValue('parent')
+    fse.readdir.mockResolvedValue([])
+
+    const result = await chooseSourceScope()
+
+    expect(result.sourceMode).toBe('current')
+  })
+
+  it('falls back to current when no folders selected', async () => {
+    select.mockResolvedValue('parent')
+    checkbox.mockResolvedValue([])
+
+    const result = await chooseSourceScope()
+
+    expect(result.sourceMode).toBe('current')
+  })
+})

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

@@ -7,6 +7,13 @@ import fse from 'fs-extra'
 import { copyContent, findAiFiles } from '../copy.js'
 
 const tmpDir = () => fse.mkdtempSync(path.join(os.tmpdir(), 'ob-test-'))
+const aiFiles = [
+  'AGENTS.md',
+  'CLAUDE.md',
+  '.cursorrules',
+  '.clinerules',
+  '.github/copilot-instructions.md',
+]
 
 describe('copy utils', () => {
   describe('findAiFiles()', () => {
@@ -21,20 +28,20 @@ describe('copy utils', () => {
     })
 
     it('returns empty array when no AI files exist', async () => {
-      const found = await findAiFiles(dir)
+      const found = await findAiFiles(dir, aiFiles)
       expect(found).toEqual([])
     })
 
     it('detects AGENTS.md', async () => {
       await fse.writeFile(path.join(dir, 'AGENTS.md'), '# agents')
-      const found = await findAiFiles(dir)
+      const found = await findAiFiles(dir, aiFiles)
       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)
+      const found = await findAiFiles(dir, aiFiles)
       expect(found).toHaveLength(1)
       expect(found[0]).toContain('CLAUDE.md')
     })
@@ -43,7 +50,7 @@ describe('copy utils', () => {
       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)
+      const found = await findAiFiles(dir, aiFiles)
       expect(found).toHaveLength(3)
     })
 
@@ -51,7 +58,7 @@ describe('copy utils', () => {
       const ghDir = path.join(dir, '.github')
       await fse.ensureDir(ghDir)
       await fse.writeFile(path.join(ghDir, 'copilot-instructions.md'), '')
-      const found = await findAiFiles(dir)
+      const found = await findAiFiles(dir, aiFiles)
       expect(found).toHaveLength(1)
       expect(found[0]).toContain('copilot-instructions.md')
     })