opencode-onboard 0.3.3 → 0.4.2

package/src/steps/{clean-ai-files.js → clean/index.js}

@@ -1,43 +1,34 @@
+import { checkbox } from '@inquirer/prompts'
 import fse from 'fs-extra'
 import path from 'path'
-import { findAiFiles } from '../utils/copy.js'
-import { header, info, success, warn } from '../utils/exec.js'
+import { fileURLToPath } from 'url'
+import { findAiFiles } from '../../utils/copy.js'
+import { header, info, success, warn } from '../../utils/exec.js'
 
-// Files/dirs that are valuable pre-existing work, never removed
-const PRESERVE = ['DESIGN.md', 'ARCHITECTURE.md', 'openspec']
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const CLEAN_PRESET_PATH = path.resolve(__dirname, '../../presets/clean.json')
+const cleanPreset = await fse.readJson(CLEAN_PRESET_PATH)
 
-/**
- * Enumerate immediate children of a directory.
- * Skips 'skills' to preserve user-installed skills.
- */
-async function childrenExcludingSkills(dir) {
+async function childrenExcludingPreserved(dir) {
   const results = []
   if (!await fse.pathExists(dir)) return results
   const entries = await fse.readdir(dir)
   for (const entry of entries) {
-    if (entry === 'skills') continue
+    if (cleanPreset.preserveSubfolders.includes(entry)) continue
     results.push(path.join(dir, entry))
   }
   return results
 }
 
-/**
- * Returns true if the file exists and has real content (not empty, not a prompt template).
- * Prompt templates contain a specific marker written by the onboard CLI.
- */
 async function isPopulated(filePath) {
   if (!await fse.pathExists(filePath)) return false
   const content = await fse.readFile(filePath, 'utf-8')
   const trimmed = content.trim()
   if (!trimmed) return false
-  // DESIGN.md and ARCHITECTURE.md shipped as prompt templates contain this marker
   if (trimmed.startsWith('<!-- onboard-prompt')) return false
   return true
 }
 
-/**
- * Returns true if openspec/ exists and has at least one change or archive entry.
- */
 async function hasOpenspecHistory(cwd) {
   const changesDir = path.join(cwd, 'openspec', 'changes')
   const archiveDir = path.join(cwd, 'openspec', 'archive')
@@ -53,11 +44,9 @@ async function hasOpenspecHistory(cwd) {
 }
 
 export async function cleanAiFiles() {
-  header('Step 3, Existing AI config files')
+  header('Step 2, Existing AI config files')
 
   const cwd = process.cwd()
-
-  // Detect what should be preserved before touching anything
   const ctx = {
     hasDesign: await isPopulated(path.join(cwd, 'DESIGN.md')),
     hasArchitecture: await isPopulated(path.join(cwd, 'ARCHITECTURE.md')),
@@ -68,22 +57,19 @@ export async function cleanAiFiles() {
   if (ctx.hasArchitecture) info('ARCHITECTURE.md exists and is populated, keeping it')
   if (ctx.hasOpenspec) info('openspec/ history exists, keeping it')
 
-  // Build the list of files to remove
-  const flatFiles = await findAiFiles(cwd)
-  const dirTargets = ['.opencode', '.agents']
+  const flatFiles = await findAiFiles(cwd, cleanPreset.detectFiles)
+  const dirTargets = cleanPreset.directoryTargets
   const dirEntries = []
   for (const dirName of dirTargets) {
     const dirPath = path.join(cwd, dirName)
-    const children = await childrenExcludingSkills(dirPath)
+    const children = await childrenExcludingPreserved(dirPath)
     dirEntries.push(...children)
   }
 
-  // Remove directory targets themselves from flat list (handled via children)
-  // Also remove any preserved entries
   const filteredFlat = flatFiles.filter(f => {
     const rel = path.relative(cwd, f)
     if (dirTargets.includes(rel)) return false
-    if (PRESERVE.some(p => rel === p || rel.startsWith(p + path.sep))) return false
+    if (cleanPreset.preserve.some(p => rel === p || rel.startsWith(p + path.sep))) return false
     return true
   })
 
@@ -94,8 +80,24 @@ export async function cleanAiFiles() {
     return ctx
   }
 
-  warn('Removing existing AI config files:')
-  for (const f of allToRemove) {
+  const choices = allToRemove.map(f => ({
+    name: path.relative(cwd, f).replace(/\\/g, '/'),
+    value: f,
+    checked: true,
+  }))
+
+  const selected = await checkbox({
+    message: cleanPreset.selectionMessage,
+    choices,
+  })
+
+  if (!selected || selected.length === 0) {
+    success('No AI config files selected for removal')
+    return ctx
+  }
+
+  warn('Removing selected AI config files:')
+  for (const f of selected) {
     info('  ' + f.replace(cwd + path.sep, ''))
     await fse.remove(f)
   }

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,99 @@
+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, originalCwd
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'metadata-test-'))
+    originalCwd = process.cwd()
+    process.chdir(tmpDir)
+  })
+
+  afterEach(() => {
+    process.chdir(originalCwd)
+    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[1]
+    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[1]
+    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[1]
+    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[1]
+    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,75 @@
+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('?')
+    expect(result[0].label).not.toContain('[')
+  })
+
+  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('preserves input order (sorting is done upstream by parseModels)', () => {
+    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('expensive/model')
+    expect(result[1].id).toBe('cheap/model')
+    expect(result[2].id).toBe('mid/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 };
+}