opencode-onboard 0.3.3 → 0.4.1

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 { error, header, info, loading, success, warn } from '../utils/exec.js'
+import { fileURLToPath } from 'url'
+import { error, header, info, loading, success, warn } from '../../utils/exec.js'
 
-const PLUGIN = '@slkiser/opencode-quota@latest'
+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')
     })

package/src/utils/copy.js

@@ -1,7 +1,7 @@
 import fse from 'fs-extra'
 import path from 'path'
 
-// Folders never copied (skills handled separately by chooseSkillsProvider, .bootstrap is internal tooling)
+// Folders never copied (skills handled separately by installSkills, .bootstrap is internal tooling)
 // These are excluded from the general content copy, they are installed separately
 // by initOpenspec after openspec init runs, so our versions win over the generated ones.
 const ALWAYS_EXCLUDE = ['.bootstrap', 'skills', 'node_modules']
@@ -29,7 +29,7 @@ export async function copyContent(contentDir, destDir, platform, ctx = {}) {
     filter: (src) => {
       const rel = path.relative(contentDir, src)
       const parts = rel.split(path.sep)
-      if (parts.some(part => ALWAYS_EXCLUDE.some(pattern => part.includes(pattern)))) return false
+      if (parts.some(part => ALWAYS_EXCLUDE.includes(part))) return false
       if (OPENSPEC_APPLY_FILES.some(f => rel === f)) return false
       if (ctx.hasDesign && rel === 'DESIGN.md') return false
       if (ctx.hasArchitecture && rel === 'ARCHITECTURE.md') return false
@@ -38,29 +38,9 @@ export async function copyContent(contentDir, destDir, platform, ctx = {}) {
   })
 }
 
-/**
- * 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',
-  '.opencode',
-  '.agents'
-]
-
-export async function findAiFiles(dir) {
+export async function findAiFiles(dir, files) {
   const found = []
-  for (const file of AI_FILES) {
+  for (const file of files) {
     const fullPath = path.join(dir, file)
     if (await fse.pathExists(fullPath)) {
       found.push(fullPath)

package/src/utils/exec-spinner.js

@@ -0,0 +1,47 @@
+import chalk from 'chalk'
+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
+
+export function appendLine(line) {
+  currentStepLines.push(line);
+}
+
+export function stopSpinner() {
+  if (stepSpinner) {
+    stepSpinner.stop();
+    stepSpinner = null;
+  }
+}
+
+export function startSpinner(text = 'working...') {
+  stopSpinner();
+  stepSpinner = ora({ text: chalk.dim(text), color: 'red' }).start();
+}
+
+export function redraw() {
+  if (process.stdout.isTTY) 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');
+  }
+}
+
+export function rotateStep() {
+  previousSteps.push(currentStepLines);
+  if (previousSteps.length > 2) previousSteps.shift();
+  currentStepLines = [];
+}