opencode-onboard 0.4.3 → 0.4.4

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

@@ -1,117 +1,117 @@
-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', () => ({
-  success: vi.fn(),
-}))
-
-import { success } from '../../utils/exec.js'
-import { writeModelToAgent, writeModelsToConfigs } from './write.js'
-
-describe('writeModelToAgent()', () => {
-  let tmpDir
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'models-write-test-'))
-  })
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true })
-  })
-
-  it('adds model field to agent file frontmatter', async () => {
-    const filePath = path.join(tmpDir, 'test-agent.md')
-    const original = `---
-name: Test Agent
-description: A test agent
----
-
-# Test Agent`
-    fs.writeFileSync(filePath, original, 'utf-8')
-
-    await writeModelToAgent(filePath, 'anthropic/claude-3-sonnet')
-
-    const updated = fs.readFileSync(filePath, 'utf-8')
-    expect(updated).toContain('model: anthropic/claude-3-sonnet')
-  })
-
-  it('preserves existing frontmatter fields', async () => {
-    const filePath = path.join(tmpDir, 'test-agent.md')
-    const original = `---
-name: Test Agent
-description: A test agent
-custom_field: custom_value
----
-
-# Test Agent`
-    fs.writeFileSync(filePath, original, 'utf-8')
-
-    await writeModelToAgent(filePath, 'test/model')
-
-    const updated = fs.readFileSync(filePath, 'utf-8')
-    expect(updated).toContain('name: Test Agent')
-    expect(updated).toContain('description: A test agent')
-    expect(updated).toContain('custom_field: custom_value')
-    expect(updated).toContain('model: test/model')
-  })
-})
-
-describe('writeModelsToConfigs()', () => {
-  let tmpDir, agentsDir, opencodeJsonPath, ensembleJsonPath, originalCwd
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    originalCwd = process.cwd()
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'models-config-test-'))
-    agentsDir = path.join(tmpDir, '.agents', 'agents')
-    fs.mkdirSync(agentsDir, { recursive: true })
-    opencodeJsonPath = path.join(tmpDir, '.opencode', 'opencode.json')
-    ensembleJsonPath = path.join(tmpDir, '.opencode', 'ensemble.json')
-    fs.mkdirSync(path.dirname(opencodeJsonPath), { recursive: true })
-    process.chdir(tmpDir)
-  })
-
-  afterEach(() => {
-    process.chdir(originalCwd)
-    fs.rmSync(tmpDir, { recursive: true, force: true })
-  })
-
-  it('writes build model to agent files', async () => {
-    fs.writeFileSync(path.join(agentsDir, 'back-engineer.md'), '---\nname: Back\n---', 'utf-8')
-    fs.writeFileSync(path.join(agentsDir, 'front-engineer.md'), '---\nname: Front\n---', 'utf-8')
-
-    await writeModelsToConfigs({
-      planModel: 'plan-model',
-      buildModel: 'build-model',
-      fastModel: 'fast-model',
-      agentsDir,
-      preset: {
-        roles: {
-          build: { agents: ['back-engineer'] },
-          fast: { agents: ['front-engineer'] },
-        },
-      },
-    })
-
-    expect(success).toHaveBeenCalledWith('back-engineer → build-model')
-    expect(success).toHaveBeenCalledWith('front-engineer → fast-model')
-  })
-
-  it('reports success when writing configs', async () => {
-    const agentFile = path.join(agentsDir, 'back-engineer.md')
-    fs.writeFileSync(agentFile, '---\nname: Back\n---', 'utf-8')
-
-    await writeModelsToConfigs({
-      planModel: 'plan-model',
-      buildModel: 'build-model',
-      fastModel: 'fast-model',
-      agentsDir,
-      preset: { roles: { build: { agents: ['back-engineer'] }, fast: { agents: [] } } },
-    })
-
-    expect(success).toHaveBeenCalled()
-  })
-})
+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', () => ({
+  success: vi.fn(),
+}))
+
+import { success } from '../../utils/exec.js'
+import { writeModelToAgent, writeModelsToConfigs } from './write.js'
+
+describe('writeModelToAgent()', () => {
+  let tmpDir
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'models-write-test-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('adds model field to agent file frontmatter', async () => {
+    const filePath = path.join(tmpDir, 'test-agent.md')
+    const original = `---
+name: Test Agent
+description: A test agent
+---
+
+# Test Agent`
+    fs.writeFileSync(filePath, original, 'utf-8')
+
+    await writeModelToAgent(filePath, 'anthropic/claude-3-sonnet')
+
+    const updated = fs.readFileSync(filePath, 'utf-8')
+    expect(updated).toContain('model: anthropic/claude-3-sonnet')
+  })
+
+  it('preserves existing frontmatter fields', async () => {
+    const filePath = path.join(tmpDir, 'test-agent.md')
+    const original = `---
+name: Test Agent
+description: A test agent
+custom_field: custom_value
+---
+
+# Test Agent`
+    fs.writeFileSync(filePath, original, 'utf-8')
+
+    await writeModelToAgent(filePath, 'test/model')
+
+    const updated = fs.readFileSync(filePath, 'utf-8')
+    expect(updated).toContain('name: Test Agent')
+    expect(updated).toContain('description: A test agent')
+    expect(updated).toContain('custom_field: custom_value')
+    expect(updated).toContain('model: test/model')
+  })
+})
+
+describe('writeModelsToConfigs()', () => {
+  let tmpDir, agentsDir, opencodeJsonPath, originalCwd
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    originalCwd = process.cwd()
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'models-config-test-'))
+    agentsDir = path.join(tmpDir, '.agents', 'agents')
+    fs.mkdirSync(agentsDir, { recursive: true })
+    opencodeJsonPath = path.join(tmpDir, '.opencode', 'opencode.json')
+    path.join(tmpDir, '.opencode', 'ensemble.json')
+    fs.mkdirSync(path.dirname(opencodeJsonPath), { recursive: true })
+    process.chdir(tmpDir)
+  })
+
+  afterEach(() => {
+    process.chdir(originalCwd)
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('writes build model to agent files', async () => {
+    fs.writeFileSync(path.join(agentsDir, 'back-engineer.md'), '---\nname: Back\n---', 'utf-8')
+    fs.writeFileSync(path.join(agentsDir, 'front-engineer.md'), '---\nname: Front\n---', 'utf-8')
+
+    await writeModelsToConfigs({
+      planModel: 'plan-model',
+      buildModel: 'build-model',
+      fastModel: 'fast-model',
+      agentsDir,
+      preset: {
+        roles: {
+          build: { agents: ['back-engineer'] },
+          fast: { agents: ['front-engineer'] },
+        },
+      },
+    })
+
+    expect(success).toHaveBeenCalledWith('back-engineer → build-model')
+    expect(success).toHaveBeenCalledWith('front-engineer → fast-model')
+  })
+
+  it('reports success when writing configs', async () => {
+    const agentFile = path.join(agentsDir, 'back-engineer.md')
+    fs.writeFileSync(agentFile, '---\nname: Back\n---', 'utf-8')
+
+    await writeModelsToConfigs({
+      planModel: 'plan-model',
+      buildModel: 'build-model',
+      fastModel: 'fast-model',
+      agentsDir,
+      preset: { roles: { build: { agents: ['back-engineer'] }, fast: { agents: [] } } },
+    })
+
+    expect(success).toHaveBeenCalled()
+  })
+})

package/src/steps/openspec/ensemble.test.js

@@ -1,79 +1,79 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import fs from 'node:fs'
-import path from 'node:path'
-import os from 'node:os'
-import { patchApplyFile, APPLY_TARGETS } from './ensemble.js'
-
-describe('patchApplyFile()', () => {
-  let tmpDir
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'openspec-test-'))
-  })
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true })
-  })
-
-  it('returns ok:false when file does not exist', async () => {
-    const result = await patchApplyFile(path.join(tmpDir, 'missing.md'))
-
-    expect(result).toEqual({ ok: false, reason: 'missing-file' })
-  })
-
-  it('returns ok:false when Step 6 is not found', async () => {
-    const filePath = path.join(tmpDir, 'opsx-apply.md')
-    fs.writeFileSync(filePath, 'Some other content without Step 6', 'utf-8')
-
-    const result = await patchApplyFile(filePath)
-
-    expect(result).toEqual({ ok: false, reason: 'missing-step-6' })
-  })
-
-  it('patches file with ENSEMBLE_SECTION when Step 6 found', async () => {
-    const filePath = path.join(tmpDir, 'opsx-apply.md')
-    const original = `Some header
-
-6. **Implement**
-   Old implementation here.
-
-**Fluid Workflow Integration**
-   Fluid section content.
-`
-    fs.writeFileSync(filePath, original, 'utf-8')
-
-    const result = await patchApplyFile(filePath)
-
-    expect(result.ok).toBe(true)
-    const patched = fs.readFileSync(filePath, 'utf-8')
-    expect(patched).toContain('**Implement via ensemble team**')
-    expect(patched).toContain('6. **Implement via ensemble team**')
-    expect(patched).toContain('**Fluid Workflow Integration**')
-  })
-
-  it('removes original Step 6 content before patching', async () => {
-    const filePath = path.join(tmpDir, 'SKILL.md')
-    const original = `Steps:
-
-6. **Implement**
-   Do things directly.
-
-7. **Quality check**
-`
-    fs.writeFileSync(filePath, original, 'utf-8')
-
-    await patchApplyFile(filePath)
-
-    const patched = fs.readFileSync(filePath, 'utf-8')
-    expect(patched).not.toContain('Do things directly.')
-    expect(patched).toContain('NEVER implement tasks directly')
-  })
-})
-
-describe('APPLY_TARGETS', () => {
-  it('contains expected OpenSpec apply file paths', () => {
-    expect(APPLY_TARGETS).toHaveLength(2)
-    expect(APPLY_TARGETS).toContain(path.join('.opencode', 'commands', 'opsx-apply.md'))
-    expect(APPLY_TARGETS).toContain(path.join('.opencode', 'skills', 'openspec-apply-change', 'SKILL.md'))
-  })
-})
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { patchApplyFile, APPLY_TARGETS } from './ensemble.js'
+
+describe('patchApplyFile()', () => {
+  let tmpDir
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'openspec-test-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('returns ok:false when file does not exist', async () => {
+    const result = await patchApplyFile(path.join(tmpDir, 'missing.md'))
+
+    expect(result).toEqual({ ok: false, reason: 'missing-file' })
+  })
+
+  it('returns ok:false when Step 6 is not found', async () => {
+    const filePath = path.join(tmpDir, 'opsx-apply.md')
+    fs.writeFileSync(filePath, 'Some other content without Step 6', 'utf-8')
+
+    const result = await patchApplyFile(filePath)
+
+    expect(result).toEqual({ ok: false, reason: 'missing-step-6' })
+  })
+
+  it('patches file with ENSEMBLE_SECTION when Step 6 found', async () => {
+    const filePath = path.join(tmpDir, 'opsx-apply.md')
+    const original = `Some header
+
+6. **Implement**
+   Old implementation here.
+
+**Fluid Workflow Integration**
+   Fluid section content.
+`
+    fs.writeFileSync(filePath, original, 'utf-8')
+
+    const result = await patchApplyFile(filePath)
+
+    expect(result.ok).toBe(true)
+    const patched = fs.readFileSync(filePath, 'utf-8')
+    expect(patched).toContain('**Implement via ensemble team**')
+    expect(patched).toContain('6. **Implement via ensemble team**')
+    expect(patched).toContain('**Fluid Workflow Integration**')
+  })
+
+  it('removes original Step 6 content before patching', async () => {
+    const filePath = path.join(tmpDir, 'SKILL.md')
+    const original = `Steps:
+
+6. **Implement**
+   Do things directly.
+
+7. **Quality check**
+`
+    fs.writeFileSync(filePath, original, 'utf-8')
+
+    await patchApplyFile(filePath)
+
+    const patched = fs.readFileSync(filePath, 'utf-8')
+    expect(patched).not.toContain('Do things directly.')
+    expect(patched).toContain('NEVER implement tasks directly')
+  })
+})
+
+describe('APPLY_TARGETS', () => {
+  it('contains expected OpenSpec apply file paths', () => {
+    expect(APPLY_TARGETS).toHaveLength(2)
+    expect(APPLY_TARGETS).toContain(path.join('.opencode', 'commands', 'opsx-apply.md'))
+    expect(APPLY_TARGETS).toContain(path.join('.opencode', 'skills', 'openspec-apply-change', 'SKILL.md'))
+  })
+})

package/src/steps/openspec/index.js

@@ -1,32 +1,121 @@
-import { execa } from 'execa'
-import path from 'node:path'
-import { error, header, success, warn } from '../../utils/exec.js'
-import { APPLY_TARGETS, patchApplyFile } from './ensemble.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}`);
-  }
-
-  for (const rel of APPLY_TARGETS) {
-    const abs = path.join(process.cwd(), rel);
-    try {
-      const res = await patchApplyFile(abs);
-      if (res.ok) success(`Patched ensemble implementation section in ${rel}`);
-      else warn(`Could not patch ${rel} (${res.reason})`);
-    } catch (err) {
-      warn(`Could not patch ${rel}: ${err.message}`);
-    }
-  }
-}
+import { execa } from "execa"
+import path from "node:path"
+import { commandExists, error, header, info, loading, success, warn} from "../../utils/exec.js"
+import { APPLY_TARGETS, patchApplyFile } from "./ensemble.js"
+
+export const openspecSteps = {
+  check,
+  install,
+  init,
+  patch,
+}
+
+export async function initOpenspec() {
+  header("Step 6, Initializing OpenSpec")
+
+  let openSpec = await openspecSteps.check()
+  if (!openSpec.available) {
+    await openspecSteps.install()
+  }
+
+  openSpec = await openspecSteps.check()
+  if (!openSpec.available) {
+    warn("OpenSpec has not been installed. It is required to create changes.")
+    return { ...openSpec, initialized: false, patched: false }
+  }
+
+  const initResult = await openspecSteps.init()
+  if (!initResult.initialized) {
+    warn(
+      "OpenSpec has not been initialized. It is required to create changes.",
+    )
+    return { ...openSpec, initialized: false, patched: false }
+  }
+
+  const patchesResult = await openspecSteps.patch()
+  return {
+    ...openSpec,
+    initialized: true,
+    patched: patchesResult.success,
+  }
+}
+
+async function install() {
+  info("Installing OpenSpec...")
+  try {
+    const result = await execa(
+      "npm",
+      ["install", "@fission-ai/openspec", "--global"],
+      {
+        cwd: process.cwd(),
+        stdio: "pipe",
+        reject: false,
+      },
+    )
+    if (result.exitCode !== 0) {
+      warn("OpenSpec install failed, check output above")
+    }
+    success("OpenSpec installed")
+  } catch (err) {
+    error(`Failed to run openspec install: ${err.message}`)
+  }  
+}
+
+async function check() {
+  loading("Checking OpenSpec...")
+
+  const available = await commandExists("openspec")
+
+  if (available) success("OpenSpec is available")
+  else warn("OpenSpec not found on PATH.")
+
+  return { available }
+}
+
+async function init() {
+  loading("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) {
+      throw new Error(
+        `init failed with exit code ${result.exitCode}, check output above`,
+      )
+    }
+  } catch (err) {
+    error(`Failed to run openspec init: ${err.message}`)
+    return { initialized: false }
+  }
+
+  success("OpenSpec initialized")
+  return { initialized: true }
+}
+
+async function patch() {
+  loading("Patching OpenSpec ensemble implementation...")
+
+  const patched = []
+
+  for (const rel of APPLY_TARGETS) {
+    const abs = path.join(process.cwd(), rel)
+    try {
+      const res = await patchApplyFile(abs)
+      if (res.ok) {
+        patched.push(rel)
+        success(`Patched ensemble implementation section in ${rel}`)
+      } else warn(`Could not patch ${rel} (${res.reason})`)
+    } catch (err) {
+      warn(`Could not patch ${rel}: ${err.message}`)
+    }
+  }
+
+  return { success: patched.length === APPLY_TARGETS.length, patched }
+}

package/src/steps/openspec/index.test.js

@@ -0,0 +1,63 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+vi.mock("execa")
+vi.mock("../../utils/exec.js")
+vi.mock("./ensemble.js")
+
+import { execa } from "execa"
+import { commandExists } from "../../utils/exec.js"
+import { patchApplyFile } from "./ensemble.js"
+import { initOpenspec } from "./index.js"
+
+const patchSuccess = () => patchApplyFile.mockResolvedValue({ ok: true })
+const installFails = () => execa.mockResolvedValueOnce({ exitCode: 1 })
+const installSuccess = () => execa.mockResolvedValueOnce({ exitCode: 0 })
+const initSuccess = () => execa.mockResolvedValueOnce({ exitCode: 0 })
+const initFails = () => execa.mockResolvedValueOnce({ exitCode: 1 })
+const checkFails = () => commandExists.mockResolvedValueOnce(false)
+const checkSuccess = () => commandExists.mockResolvedValueOnce(true)
+
+describe("initOpenspec()", () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it("installs, initializes, and patches when openspec is initially unavailable", async () => {
+    checkFails()
+    checkSuccess()
+    installSuccess()
+    initSuccess()
+    patchSuccess()
+
+    const result = await initOpenspec()
+
+    expect(result.available).toBe(true)
+    expect(result.initialized).toBe(true)
+    expect(result.patched).toBe(true)
+  })
+
+  it("fails if openspec remains unavailable after install", async () => {
+    checkFails()
+    checkFails()
+    installFails()
+
+    const result = await initOpenspec()
+
+    expect(result.available).toBe(false)
+    expect(result.initialized).toBe(false)
+    expect(result.patched).toBe(false)
+  })
+
+  it("fails if openspec init command exits non-zero", async () => {
+    checkFails()
+    checkSuccess()
+    installSuccess()
+    initFails()
+
+    const result = await initOpenspec()
+
+    expect(result.available).toBe(true)
+    expect(result.initialized).toBe(false)
+    expect(result.patched).toBe(false)
+  })
+})

package/src/steps/optimization/caveman.js

@@ -1,29 +1,34 @@
-import { execa } from 'execa'
-import { header, success, warn, error, loading, info } from '../../utils/exec.js'
-
-export async function installCaveman(options = {}) {
-  if (!options.skipHeader) header('Installing caveman')
-
-  loading('installing caveman...')
-
-  try {
-    info('Installing caveman via npx skills')
-    const result = await execa('npx', ['skills', 'add', 'JuliusBrussee/caveman/caveman', '-a', 'opencode', '--yes'], {
-      reject: false,
-      timeout: 600000,
-      stdio: 'pipe',
-    })
-
-    if (result.exitCode === 0) {
-      success('caveman installed')
-      return { optedIn: true, installed: true }
-    }
-
-    if (result.stderr?.trim()) warn(result.stderr.trim().split('\n').slice(-3).join('\n'))
-    warn('caveman install exited with non-zero code')
-    return { optedIn: true, installed: false }
-  } catch (err) {
-    error(`Failed to install caveman: ${err.message}`)
-    return { optedIn: true, installed: false }
-  }
-}
+import { execa } from 'execa'
+import { header, success, warn, error, loading, info } from '../../utils/exec.js'
+
+export async function installCaveman(options = {}) {
+  if (!options.skipHeader) header('Installing caveman')
+
+  loading('installing caveman...')
+
+  const isGlobal = options.installScope === 'global'
+  const skillsArgs = isGlobal
+    ? ['skills', 'add', 'JuliusBrussee/caveman/caveman', '-a', 'opencode', '--yes', '-g']
+    : ['skills', 'add', 'JuliusBrussee/caveman/caveman', '-a', 'opencode', '--yes']
+
+  try {
+    info('Installing caveman via npx skills')
+    const result = await execa('npx', skillsArgs, {
+      reject: false,
+      timeout: 600000,
+      stdio: 'pipe',
+    })
+
+    if (result.exitCode === 0) {
+      success('caveman installed')
+      return { optedIn: true, installed: true }
+    }
+
+    if (result.stderr?.trim()) warn(result.stderr.trim().split('\n').slice(-3).join('\n'))
+    warn('caveman install exited with non-zero code')
+    return { optedIn: true, installed: false }
+  } catch (err) {
+    error(`Failed to install caveman: ${err.message}`)
+    return { optedIn: true, installed: false }
+  }
+}