opencode-onboard 0.3.3 → 0.4.1

package/src/steps/copy/agents.js

@@ -0,0 +1,106 @@
+import fse from 'fs-extra'
+import path from 'path'
+import { info, success } from '../../utils/exec.js'
+
+const STEP1_HEADING = '### Step 1, Archive project history into OpenSpec'
+const STEP2_HEADING = '### Step 2, Generate DESIGN.md'
+const STEP3_HEADING = '### Step 3, Generate ARCHITECTURE.md'
+
+const STEP1_CONFIRM_LINE = '- Project history archived in openspec'
+const STEP2_CONFIRM_LINE = '- DESIGN.md generated'
+const STEP3_CONFIRM_LINE = '- ARCHITECTURE.md generated'
+
+function removeStepBlock(content, heading) {
+  const lines = content.split('\n')
+  const start = lines.findIndex(l => l.trim() === heading.trim())
+  if (start === -1) return content
+
+  let end = -1
+  for (let i = start + 1; i < lines.length; i++) {
+    if (lines[i].trim() === '---') { end = i; break }
+  }
+
+  if (end === -1) return content
+
+  const removeFrom = start > 0 && lines[start - 1].trim() === '' ? start - 1 : start
+  lines.splice(removeFrom, end - removeFrom + 1)
+  return lines.join('\n')
+}
+
+function removeConfirmLine(content, line) {
+  return content.split('\n').filter(l => l.trim() !== line.trim()).join('\n')
+}
+
+function renumberSteps(content) {
+  let counter = 0
+  return content.replace(/^### Step \d+,/gm, () => `### Step ${++counter},`)
+}
+
+const PLATFORM_SKILLS_START = '<!-- OB-PLATFORM-SKILLS-START -->'
+const PLATFORM_SKILLS_END = '<!-- OB-PLATFORM-SKILLS-END -->'
+
+function buildPlatformSkillsSection(platform) {
+  if (platform === 'azure') {
+    return [
+      '- Selected platform: `azure` (from onboarding platform step).',
+      '- Load Azure DevOps skills: `ob-userstory-az`, `ob-pullrequest-az`.',
+      '- Use URL-based platform inference only if onboarding metadata is missing or ambiguous.',
+    ].join('\n')
+  }
+
+  return [
+    '- Selected platform: `github` (from onboarding platform step).',
+    '- Load GitHub skills: `ob-userstory-gh`, `ob-pullrequest-gh`.',
+    '- Use URL-based platform inference only if onboarding metadata is missing or ambiguous.',
+  ].join('\n')
+}
+
+function replaceBetween(content, start, end, replacement) {
+  if (!content.includes(start) || !content.includes(end)) return content
+  const pattern = new RegExp(`${start}[\\s\\S]*?${end}`)
+  return content.replace(pattern, `${start}\n${replacement.trim()}\n${end}`)
+}
+
+export async function patchAgentsMd(ctx) {
+  const agentsMdPath = path.join(process.cwd(), 'AGENTS.md')
+  if (!await fse.pathExists(agentsMdPath)) return
+
+  let content = await fse.readFile(agentsMdPath, 'utf-8')
+  const patches = []
+
+  if (ctx.hasOpenspec) {
+    content = removeStepBlock(content, STEP1_HEADING)
+    content = removeConfirmLine(content, STEP1_CONFIRM_LINE)
+    patches.push('Step 1 (openspec history) removed, openspec/ already exists')
+  }
+
+  if (ctx.hasDesign) {
+    content = removeStepBlock(content, STEP2_HEADING)
+    content = removeConfirmLine(content, STEP2_CONFIRM_LINE)
+    patches.push('Step 2 (DESIGN.md) removed, DESIGN.md already exists')
+  }
+
+  if (ctx.hasArchitecture) {
+    content = removeStepBlock(content, STEP3_HEADING)
+    content = removeConfirmLine(content, STEP3_CONFIRM_LINE)
+    patches.push('Step 3 (ARCHITECTURE.md) removed, ARCHITECTURE.md already exists')
+  }
+
+  if (patches.length > 0) {
+    content = renumberSteps(content)
+    await fse.writeFile(agentsMdPath, content, 'utf-8')
+    for (const msg of patches) info(msg)
+    success('AGENTS.md patched for existing project state')
+  }
+}
+
+export async function patchDevopsManagerMd(platform) {
+  const devopsPath = path.join(process.cwd(), '.agents', 'agents', 'devops-manager.md')
+  if (!await fse.pathExists(devopsPath)) return
+
+  const resolved = platform === 'azure' ? 'azure' : 'github'
+  let content = await fse.readFile(devopsPath, 'utf-8')
+  content = replaceBetween(content, PLATFORM_SKILLS_START, PLATFORM_SKILLS_END, buildPlatformSkillsSection(resolved))
+  await fse.writeFile(devopsPath, `${content.replace(/\s*$/, '')}\n`, 'utf-8')
+  success(`devops-manager.md patched for platform: ${resolved}`)
+}

package/src/steps/{__tests__/copy-content.test.js → copy/copy.test.js}

@@ -10,9 +10,18 @@ vi.mock('../../utils/copy.js', () => ({
   copyContent: vi.fn(),
 }))
 
+vi.mock('./agents.js', () => ({
+  patchAgentsMd: vi.fn(),
+  patchDevopsManagerMd: vi.fn(),
+}))
+
+vi.mock('./skills.js', () => ({
+  installSkills: vi.fn(),
+}))
+
 import { copyContent } from '../../utils/copy.js'
 import { success, error } from '../../utils/exec.js'
-import { copyContentStep } from '../copy-content.js'
+import { copyContentStep } from './index.js'
 
 describe('copyContentStep()', () => {
   const originalExit = process.exit

package/src/steps/copy/index.js

@@ -0,0 +1,33 @@
+import fse from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { copyContent } from '../../utils/copy.js'
+import { error, header, success } from '../../utils/exec.js'
+import { patchAgentsMd, patchDevopsManagerMd } from './agents.js'
+import { installSkills } from './skills.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const CONTENT_DIR = path.resolve(__dirname, '../../../content')
+
+export async function copyContentStep(platform, ctx = {}) {
+  header('Step 5, Copying opencode-onboard files')
+
+  const dest = process.cwd()
+
+  try {
+    await copyContent(CONTENT_DIR, dest, platform, ctx)
+    const rootsFile = path.join(dest, '.agents', 'source-roots.json')
+    await fse.ensureDir(path.dirname(rootsFile))
+    await fse.writeJson(rootsFile, {
+      mode: ctx.sourceMode || 'current',
+      roots: ctx.sourceRoots || [dest],
+    }, { spaces: 2 })
+    await patchDevopsManagerMd(platform)
+    await patchAgentsMd(ctx)
+    await installSkills()
+    success('Files copied to project root')
+  } catch (err) {
+    error(`Failed to copy content: ${err.message}`)
+    process.exit(1)
+  }
+}

package/src/steps/copy/skills.js

@@ -0,0 +1,55 @@
+import { execa } from 'execa'
+import fse from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { 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')
+const CONTENT_SKILLS_LOCK = path.resolve(__dirname, '../../../content/skills-lock.json')
+
+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 installSkills() {
+  info('Installing built-in ob-skills...')
+  await installObSkills()
+  console.log()
+
+  if (await fse.pathExists(CONTENT_SKILLS_LOCK)) {
+    const destLock = path.join(process.cwd(), 'skills-lock.json')
+    if (await fse.pathExists(destLock)) {
+      info('skills-lock.json already exists, skipping')
+    } else {
+      await fse.copy(CONTENT_SKILLS_LOCK, destLock)
+      success('Installed skills-lock.json')
+    }
+  }
+
+  info('Installing npx skills from skills-lock.json...')
+  try {
+    await execa('npx', ['skills'], {
+      cwd: process.cwd(),
+      stdio: 'inherit',
+      reject: false,
+    })
+  } catch (err) {
+    warn(`npx skills failed: ${err.message}`)
+  }
+}

package/src/steps/{write-onboard-config.js → metadata/index.js}

@@ -2,10 +2,10 @@ import { execa } from 'execa'
 import fse from 'fs-extra'
 import path from 'path'
 import { createRequire } from 'node:module'
-import { header, success, warn } from '../utils/exec.js'
+import { header, success, warn } from '../../utils/exec.js'
 
 const require = createRequire(import.meta.url)
-const { version: onboardVersion } = require('../../package.json')
+const { version: onboardVersion } = require('../../../package.json')
 
 async function detectOpencodeVersion() {
   try {
@@ -19,7 +19,7 @@ async function detectOpencodeVersion() {
 }
 
 export async function writeOnboardConfig(data) {
-  header('Step 12, Writing onboarding metadata')
+  header('Step 10, Writing onboarding metadata')
 
   const opencodeVersion = await detectOpencodeVersion()
   const target = path.join(process.cwd(), '.opencode', 'opencode-onboard.json')

package/src/steps/metadata/metadata.test.js

@@ -0,0 +1,96 @@
+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(),
+  success: vi.fn(),
+  warn: vi.fn(),
+}))
+
+vi.mock('execa', () => ({
+  execa: vi.fn(),
+}))
+
+vi.mock('fs-extra', () => ({
+  default: {
+    ensureDir: vi.fn().mockResolvedValue(undefined),
+    writeJson: vi.fn().mockResolvedValue(undefined),
+  },
+}))
+
+import { execa } from 'execa'
+import fse from 'fs-extra'
+import { writeOnboardConfig } from './index.js'
+
+describe('writeOnboardConfig()', () => {
+  let tmpDir
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'metadata-test-'))
+    process.chdir(tmpDir)
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('writes JSON file with all wizard selections', async () => {
+    execa.mockResolvedValue({ exitCode: 0, stdout: '1.2.3', stderr: '' })
+
+    await writeOnboardConfig({
+      platform: 'github',
+      sourceMode: 'current',
+      sourceRoots: ['/test/path'],
+      hasDesign: true,
+      hasArchitecture: false,
+      hasOpenspec: true,
+      additionalSkillsProvider: 'npx-skills',
+      planModel: 'plan-model',
+      buildModel: 'build-model',
+      fastModel: 'fast-model',
+      optionalTools: ['rtk'],
+      cavemanGuidance: true,
+    })
+
+    expect(fse.ensureDir).toHaveBeenCalled()
+    expect(fse.writeJson).toHaveBeenCalled()
+    const call = fse.writeJson.mock.calls[0]
+    const payload = call[0]
+    expect(payload.schema).toBe(1)
+    expect(payload.wizard.platform).toBe('github')
+    expect(payload.wizard.models.build).toBe('build-model')
+    expect(payload.wizard.optionalTools).toEqual(['rtk'])
+  })
+
+  it('detects opencode version from CLI', async () => {
+    execa.mockResolvedValue({ exitCode: 0, stdout: '2.0.0', stderr: '' })
+
+    await writeOnboardConfig({ platform: 'github', sourceMode: 'current', sourceRoots: [] })
+
+    const call = fse.writeJson.mock.calls[0]
+    const payload = call[0]
+    expect(payload.opencodeVersion).toBe('2.0.0')
+  })
+
+  it('handles missing opencode gracefully', async () => {
+    execa.mockResolvedValue({ exitCode: 1, stdout: '', stderr: '' })
+
+    await writeOnboardConfig({ platform: 'github', sourceMode: 'current', sourceRoots: [] })
+
+    const call = fse.writeJson.mock.calls[0]
+    const payload = call[0]
+    expect(payload.opencodeVersion).toBe(null)
+  })
+
+  it('includes note field', async () => {
+    execa.mockResolvedValue({ exitCode: 0, stdout: '1', stderr: '' })
+
+    await writeOnboardConfig({ platform: 'github', sourceMode: 'current', sourceRoots: [] })
+
+    const call = fse.writeJson.mock.calls[0]
+    const payload = call[0]
+    expect(payload.note).toContain('Informational file only')
+  })
+})

package/src/steps/models/format.js

@@ -0,0 +1,60 @@
+import { search } from '@inquirer/prompts'
+import fse from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const MODELS_PRESET_PATH = path.resolve(__dirname, '../../presets/models.json');
+const modelsPreset = await fse.readJson(MODELS_PRESET_PATH);
+
+function costTier(input) {
+  if (input === undefined || input === null) return '';
+  const tier = modelsPreset.costTiers.find(t => t.max === undefined || input <= t.max);
+  return tier ? ` ${tier.label}` : '';
+}
+
+function costTierDisplay(cost, canonicalCost) {
+  return costTier(canonicalCost !== undefined ? canonicalCost : cost);
+}
+
+function formatPrice(price) {
+  if (price === undefined || price === null) return '?';
+  if (price === 0) return '$0 (subscription)';
+  return `$${price}/M`;
+}
+
+export function buildDisplayModels(rawModels) {
+  return rawModels.map(m => {
+    const priceStr = formatPrice(m.cost);
+    const canonicalNote = m.canonicalCost !== undefined
+      ? ` · official price: ${formatPrice(m.canonicalCost)}/M`
+      : '';
+    return {
+      ...m,
+      label: `${m.name}${costTierDisplay(m.cost, m.canonicalCost)}, ${m.id}`,
+      description: `${priceStr}${canonicalNote} · context: ${m.context ? (m.context / 1000) + 'k' : '?'}`,
+    };
+  });
+}
+
+export async function pickModel(message, models) {
+  return await search({
+    message,
+    source: (input) => {
+      const q = (input || '').toLowerCase();
+      const filtered = q
+        ? models.filter(m =>
+            m.label.toLowerCase().includes(q) ||
+            m.id.toLowerCase().includes(q)
+          )
+        : models;
+      return filtered.slice(0, 50).map(m => ({
+        name: m.label,
+        value: m.id,
+        description: m.description,
+      }));
+    },
+  });
+}
+
+export { modelsPreset };

package/src/steps/models/format.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest'
+import { buildDisplayModels } from './format.js'
+
+describe('buildDisplayModels()', () => {
+  it('adds cost tier label for cheap models', () => {
+    const raw = [{ id: 'anthropic/claude-3-5-sonnet-20241022', name: 'Claude 3.5 Sonnet', cost: 3, context: 200000 }]
+
+    const result = buildDisplayModels(raw)
+
+    expect(result[0].label).toContain('[$]')
+  })
+
+  it('adds cost tier label for mid-range models', () => {
+    const raw = [{ id: 'anthropic/claude-3-opus-20240229', name: 'Claude 3 Opus', cost: 15, context: 200000 }]
+
+    const result = buildDisplayModels(raw)
+
+    expect(result[0].label).toContain('[$$]')
+  })
+
+  it('adds cost tier label for expensive models', () => {
+    const raw = [{ id: 'openai/gpt-4-turbo', name: 'GPT-4 Turbo', cost: 30, context: 128000 }]
+
+    const result = buildDisplayModels(raw)
+
+    expect(result[0].label).toContain('[$$$]')
+  })
+
+  it('shows canonical cost note when provider cost differs', () => {
+    const raw = [{ id: 'github-copilot/claude-3-5-sonnet', name: 'Claude 3.5 Sonnet', cost: 0, canonicalCost: 3, context: 200000 }]
+
+    const result = buildDisplayModels(raw)
+
+    expect(result[0].description).toContain('official price: $3/M')
+  })
+
+  it('formats context in thousands', () => {
+    const raw = [{ id: 'test/model', name: 'Test', cost: 1, context: 128000 }]
+
+    const result = buildDisplayModels(raw)
+
+    expect(result[0].description).toContain('context: 128k')
+  })
+
+  it('handles missing cost as ?', () => {
+    const raw = [{ id: 'test/model', name: 'Test', context: 1000 }]
+
+    const result = buildDisplayModels(raw)
+
+    expect(result[0].description).toContain('cost: ?')
+  })
+
+  it('handles $0 subscription pricing', () => {
+    const raw = [{ id: 'test/model', name: 'Test', cost: 0, context: 1000 }]
+
+    const result = buildDisplayModels(raw)
+
+    expect(result[0].description).toContain('$0 (subscription)')
+  })
+
+  it('sorts models by cost ascending', () => {
+    const raw = [
+      { id: 'expensive/model', name: 'Expensive', cost: 100, context: 1000 },
+      { id: 'cheap/model', name: 'Cheap', cost: 1, context: 1000 },
+      { id: 'mid/model', name: 'Mid', cost: 10, context: 1000 },
+    ]
+
+    const result = buildDisplayModels(raw)
+
+    expect(result[0].id).toBe('cheap/model')
+    expect(result[1].id).toBe('mid/model')
+    expect(result[2].id).toBe('expensive/model')
+  })
+})

package/src/steps/models/index.js

@@ -0,0 +1,52 @@
+import path from 'path'
+import { header, info, success, warn } from '../../utils/exec.js'
+import { fetchModels } from '../../utils/models-cache.js'
+import { buildDisplayModels, modelsPreset, pickModel } from './format.js'
+import { writeModelsToConfigs } from './write.js'
+
+export async function chooseModels() {
+  header('Step 7, Choose models');
+
+  info('Fetching available models from models.dev...');
+  const { models: rawModels, source } = await fetchModels();
+
+  if (!rawModels) {
+    warn('Could not fetch models (offline and no cache). Skipping model selection.');
+    warn('Set models later in .agents/agents/<name>.md and .opencode/opencode.json');
+    return;
+  }
+
+  if (source === 'stale-cache') {
+    warn('Network unavailable, using cached model list (may be outdated).');
+  } else if (source === 'cache') {
+    info('Using cached model list (refreshes weekly).');
+  }
+
+  const models = buildDisplayModels(rawModels);
+  success(`${models.length} models available`);
+  console.log();
+  info('Cost indicators: [$] cheap  [$$] mid  [$$$] expensive');
+  info('Type to search. Change selections later in .agents/agents/ and .opencode/opencode.json');
+  console.log();
+
+  for (const line of modelsPreset.roles.plan.info) info(line);
+  const planModel = await pickModel(modelsPreset.roles.plan.prompt, models);
+  console.log();
+
+  for (const line of modelsPreset.roles.build.info) info(line);
+  const buildModel = await pickModel(modelsPreset.roles.build.prompt, models);
+  console.log();
+
+  for (const line of modelsPreset.roles.fast.info) info(line);
+  const fastModel = await pickModel(modelsPreset.roles.fast.prompt, models);
+  console.log();
+
+  const agentsDir = path.join(process.cwd(), '.agents', 'agents');
+  await writeModelsToConfigs({ planModel, buildModel, fastModel, agentsDir, preset: modelsPreset });
+
+  console.log();
+  warn('Make sure you have API access to the selected models.');
+  warn('Change them anytime in .agents/agents/<name>.md and .opencode/opencode.json');
+
+  return { planModel, buildModel, fastModel };
+}

package/src/steps/models/write.js

@@ -0,0 +1,54 @@
+import fse from 'fs-extra'
+import path from 'path'
+import { success } from '../../utils/exec.js'
+
+export async function writeModelToAgent(agentFile, modelId) {
+  const content = await fse.readFile(agentFile, 'utf-8');
+  const updated = content.replace(
+    /^(---\n[\s\S]*?)\n---/m,
+    `$1\nmodel: ${modelId}\n---`
+  );
+  await fse.writeFile(agentFile, updated, 'utf-8');
+}
+
+export async function writeModelsToConfigs({ planModel, buildModel, fastModel, agentsDir, preset }) {
+  for (const name of preset.roles.build.agents) {
+    const file = path.join(agentsDir, `${name}.md`);
+    if (await fse.pathExists(file)) {
+      await writeModelToAgent(file, buildModel);
+      success(`${name} → ${buildModel}`);
+    }
+  }
+
+  for (const name of preset.roles.fast.agents) {
+    const file = path.join(agentsDir, `${name}.md`);
+    if (await fse.pathExists(file)) {
+      await writeModelToAgent(file, fastModel);
+      success(`${name} → ${fastModel}`);
+    }
+  }
+
+  const opencodeJsonPath = path.join(process.cwd(), '.opencode', 'opencode.json');
+  if (await fse.pathExists(opencodeJsonPath)) {
+    const config = await fse.readJson(opencodeJsonPath);
+    config.model = buildModel;
+    await fse.writeJson(opencodeJsonPath, config, { spaces: 2 });
+    success(`default model -> ${buildModel} (written to .opencode/opencode.json)`);
+  }
+
+  const ensembleJsonPath = path.join(process.cwd(), '.opencode', 'ensemble.json');
+  if (await fse.pathExists(ensembleJsonPath)) {
+    const ensemble = await fse.readJson(ensembleJsonPath);
+    delete ensemble.defaultModel;
+    ensemble.modelsByAgent = {
+      ...ensemble.modelsByAgent,
+      plan: planModel,
+      build: buildModel,
+      explore: fastModel,
+    };
+    await fse.writeJson(ensembleJsonPath, ensemble, { spaces: 2 });
+    success(`plan model -> ${planModel} (written to .opencode/ensemble.json)`);
+    success(`build model -> ${buildModel} (written to .opencode/ensemble.json)`);
+    success(`fast model -> ${fastModel} (written to .opencode/ensemble.json)`);
+  }
+}