pantheon-opencode 1.1.1-beta.3 → 1.1.1-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pantheon-opencode",
-  "version": "1.1.1-beta.3",
+  "version": "1.1.1-beta.4",
   "description": "Multi-agent orchestration for OpenCode — 14 specialized agents, TDD, Themis review gates.",
   "publishConfig": {
     "access": "public",

package/scripts/install/cli-ui.mjs

@@ -0,0 +1,160 @@
+export const icons = {
+  success: '\u2705',
+  warning: '\u26a0\ufe0f ',
+  error: '\u274c',
+  info: '\u2139\ufe0f ',
+  progress: '\u23f3',
+  done: '\u2705',
+  arrow: '\u2192',
+  bullet: '\u2022',
+  star: '\u2b50',
+  wrench: '\U0001f527',
+  rocket: '\U0001f680',
+  package: '\U0001f4e6',
+  gear: '\u2699\ufe0f',
+}
+
+export const colors = {
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+}
+
+let _quiet = false
+let _dryRun = false
+
+export function configure(opts = {}) {
+  if (opts.quiet !== undefined) _quiet = opts.quiet
+  if (opts.dryRun !== undefined) _dryRun = opts.dryRun
+}
+
+function tag(msg) {
+  return _dryRun ? `[DRY-RUN] ${msg}` : msg
+}
+
+function tty() {
+  return process.stdout.isTTY
+}
+
+export function section(title) {
+  if (_quiet) return
+  const width = Math.min(process.stdout.columns || 60, 72)
+  const text = `\u2500\u2500 ${title} `
+  const line = text + '\u2500'.repeat(Math.max(0, width - text.length + 1))
+  console.log(tag(line))
+}
+
+export function step(message) {
+  const text = tag(`${icons.progress} ${message}...`)
+  if (!_quiet) process.stdout.write(text)
+  return (ok = true) => {
+    const icon = ok ? icons.success : icons.error
+    const doneText = tag(`${icon} ${message}`)
+    if (_quiet && !ok) {
+      console.warn(doneText)
+    } else if (!_quiet) {
+      process.stdout.write(`\r${doneText}\n`)
+    }
+  }
+}
+
+export function success(message) {
+  console.log(tag(`${icons.success} ${message}`))
+}
+
+export function warning(message) {
+  console.warn(tag(`${icons.warning}${message}`))
+}
+
+export function error(message) {
+  console.error(tag(`${icons.error} ${message}`))
+}
+
+export function info(message) {
+  if (_quiet) return
+  console.log(tag(`${icons.info}${message}`))
+}
+
+export function bullet(text, indent = 0) {
+  if (_quiet) return
+  const pad = '  '.repeat(indent)
+  console.log(tag(`${pad}${icons.bullet} ${text}`))
+}
+
+export function summaryTable(items) {
+  if (_quiet || items.length === 0) return
+
+  const nameWidth = Math.max(...items.map((i) => i.name.length), 15)
+  const statusWidth = Math.max(...items.map((i) => String(i.status).length), 8)
+
+  const top = `\u250c${'\u2500'.repeat(nameWidth + 2)}\u252c${'\u2500'.repeat(statusWidth + 2)}\u2510`
+  const sep = `\u251c${'\u2500'.repeat(nameWidth + 2)}\u253c${'\u2500'.repeat(statusWidth + 2)}\u2524`
+  const bot = `\u2514${'\u2500'.repeat(nameWidth + 2)}\u2534${'\u2500'.repeat(statusWidth + 2)}\u2518`
+
+  console.log(tag(top))
+  console.log(tag(`\u2502 ${'Componente'.padEnd(nameWidth)} \u2502 ${'Status'.padEnd(statusWidth)} \u2502`))
+  console.log(tag(sep))
+  for (const item of items) {
+    console.log(tag(`\u2502 ${item.name.padEnd(nameWidth)} \u2502 ${String(item.status).padEnd(statusWidth)} \u2502`))
+  }
+  console.log(tag(bot))
+}
+
+export function spinner(message) {
+  const frames = ['\u280b', '\u2819', '\u2839', '\u2838', '\u283c', '\u2834', '\u2826', '\u2827', '\u2807', '\u280f']
+  let i = 0
+  let running = true
+
+  if (tty() && !_quiet) {
+    const interval = setInterval(() => {
+      if (!running) { clearInterval(interval); return }
+      process.stdout.write(`\r${frames[i % frames.length]} ${tag(message)}...`)
+      i++
+    }, 80)
+    process.stdout.write(`\r${frames[0]} ${tag(message)}...`)
+
+    return (ok = true) => {
+      running = false
+      clearInterval(interval)
+      const icon = ok ? icons.success : icons.error
+      process.stdout.write(`\r${icon} ${tag(message)}\n`)
+    }
+  } else {
+    const text = tag(`${icons.progress} ${message}...`)
+    if (!_quiet) process.stdout.write(text)
+    return (ok = true) => {
+      const icon = ok ? icons.success : icons.error
+      const doneText = tag(`${icon} ${message}`)
+      if (_quiet && !ok) {
+        console.warn(doneText)
+      } else if (!_quiet) {
+        process.stdout.write(`\r${doneText}\n`)
+      }
+    }
+  }
+}
+
+export function printSummary(target, platforms, stats) {
+  if (_quiet) return
+
+  const line = '\u2500'.repeat(Math.min(process.stdout.columns || 60, 60))
+  console.log(tag(`${icons.rocket} OpenCode instalado em ${target}`))
+  console.log(tag(line))
+  console.log('')
+
+  if (stats) {
+    console.log(tag(`  Componentes:\t${stats.created} instalados, ${stats.skipped} pulados`))
+    if (stats.errors > 0) {
+      console.warn(tag(`  ${icons.warning}${stats.errors} erro(s) encontrados`))
+    }
+    console.log('')
+  }
+
+  console.log(tag(`  ${icons.star} Próximos passos:`))
+  console.log(tag(`    ${icons.bullet} Configure seus agentes em opencode.json`))
+  console.log(tag(`    ${icons.bullet} Adicione MCP servers em mcp.json`))
+  console.log(tag(`    ${icons.bullet} Rode 'opencode doctor' para verificar a instalação`))
+}

package/scripts/install/component.mjs

@@ -0,0 +1,24 @@
+/**
+ * component.mjs — Component resolution utilities for the OpenCode installer
+ */
+
+/** Available component identifiers */
+export const COMPONENT_NAMES = [
+  'agents',
+  'skills',
+  'instructions',
+  'prompts',
+  'commands',
+  'plugins',
+  'runtime',
+]
+
+/**
+ * Parse --components flag into a Set.
+ * @param {string|string[]} spec - Comma-separated string or array of component names
+ * @returns {Set<string>}
+ */
+export function resolveComponents(spec) {
+  if (Array.isArray(spec)) return new Set(spec)
+  return new Set(spec.split(',').map((s) => s.trim()))
+}

package/scripts/install/migrate-config.mjs

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+/**
+ * migrate-config.mjs — Standalone migration CLI with checkpoint crash recovery
+ *
+ * Runs configuration migrations with an atomic checkpoint system.
+ * If the process crashes mid-migration, the checkpoint file persists
+ * so that --resume picks up where it left off.
+ *
+ * Usage:
+ *   node scripts/install/migrate-config.mjs --from=1.1.0 --to=1.1.1 --target=~/.config/opencode
+ *   node scripts/install/migrate-config.mjs --resume --target=~/.config/opencode
+ *   node scripts/install/migrate-config.mjs --list --target=~/.config/opencode
+ *   node scripts/install/migrate-config.mjs --dry-run --from=1.1.0 --to=1.1.1
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import {
+  readState,
+  writeState,
+  createInitialState,
+  addMigrationRecord,
+  updateVersion,
+} from './state.mjs'
+import {
+  readCheckpoint,
+  writeCheckpoint,
+  advanceCheckpoint,
+  removeCheckpoint,
+  resumePendingMigration,
+  listAppliedMigrations,
+} from './migrate.mjs'
+
+// ---------------------------------------------------------------------------
+// Migration step definitions
+// Each step is an idempotent function(target, state, { dryRun }) => void
+// ---------------------------------------------------------------------------
+
+const MIGRATION_STEPS = {
+  /**
+   * migrate_state_v2: Upgrade install-state.json from schema v1 to v2.
+   * Adds schema_version field, components tracking, and migration history.
+   */
+  migrate_state_v2: (target, state, { dryRun }) => {
+    if (state.schema_version && state.schema_version >= 2) {
+      return
+    }
+    if (!dryRun) {
+      state.schema_version = 2
+      state.components = state.components || {
+        agents: { version: 1, status: 'pending' },
+        skills: { version: 1, status: 'pending' },
+        plugins: { version: 1, status: 'pending' },
+        runtime: { version: 1, status: 'pending' },
+      }
+      state.applied_migrations = state.applied_migrations || []
+      state.migration_checkpoint = null
+    }
+  },
+
+  /**
+   * update_schema: Ensure all v2 schema fields exist with defaults.
+   */
+  update_schema: (target, state, { dryRun }) => {
+    if (!dryRun) {
+      if (!state.components) {
+        state.components = {
+          agents: { version: 1, status: 'pending' },
+          skills: { version: 1, status: 'pending' },
+          plugins: { version: 1, status: 'pending' },
+          runtime: { version: 1, status: 'pending' },
+        }
+      }
+      for (const key of ['agents', 'skills', 'plugins', 'runtime']) {
+        if (!state.components[key]) {
+          state.components[key] = { version: 1, status: 'pending' }
+        }
+      }
+      state.applied_migrations = state.applied_migrations || []
+      if (state.migration_checkpoint === undefined) {
+        state.migration_checkpoint = null
+      }
+    }
+  },
+
+  /**
+   * migrate_plugins: Normalize plugin component tracking.
+   */
+  migrate_plugins: (target, state, { dryRun }) => {
+    if (!dryRun) {
+      if (!state.components) state.components = {}
+      const p = state.components.plugins || { version: 1, status: 'pending' }
+      p.version = Math.max(p.version || 0, 1)
+      state.components.plugins = p
+    }
+  },
+}
+
+// ---------------------------------------------------------------------------
+// Migration step ordering (a step runs ONLY after all predecessors complete)
+// ---------------------------------------------------------------------------
+
+const STEP_ORDER = Object.keys(MIGRATION_STEPS)
+
+/**
+ * Resolve which steps to run based on from/to version comparison.
+ * For now, runs all steps. In the future this can be gated by version.
+ * @param {string} fromVersion
+ * @param {string} toVersion
+ * @returns {string[]} Ordered list of step names
+ */
+function resolveSteps(fromVersion, toVersion) {
+  return [...STEP_ORDER]
+}
+
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+
+function parseArgs() {
+  const args = process.argv.slice(2)
+  const result = {
+    from: null,
+    to: null,
+    target: process.cwd(),
+    dryRun: false,
+    resume: false,
+    list: false,
+    help: false,
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg === '--dry-run') result.dryRun = true
+    else if (arg === '--resume') result.resume = true
+    else if (arg === '--list') result.list = true
+    else if (arg === '--help' || arg === '-h') result.help = true
+    else if (arg.startsWith('--from=')) result.from = arg.split('=', 2)[1]
+    else if (arg.startsWith('--to=')) result.to = arg.split('=', 2)[1]
+    else if (arg.startsWith('--target=')) result.target = arg.split('=', 2)[1]
+    else if (arg === '--from') result.from = args[++i]
+    else if (arg === '--to') result.to = args[++i]
+    else if (arg === '--target') result.target = args[++i]
+  }
+
+  return result
+}
+
+function showHelp() {
+  console.log(`
+migrate-config.mjs — Pantheon configuration migration CLI
+
+Usage:
+  node scripts/install/migrate-config.mjs --from=1.1.0 --to=1.1.1 --target=~/.config/opencode
+  node scripts/install/migrate-config.mjs --resume --target=~/.config/opencode
+  node scripts/install/migrate-config.mjs --list --target=~/.config/opencode
+  node scripts/install/migrate-config.mjs --dry-run --from=1.1.0 --to=1.1.1
+  node scripts/install/migrate-config.mjs --help
+
+Options:
+  --from=<version>  Source version (required for new migrations)
+  --to=<version>    Target version (required for new migrations)
+  --target=<path>   Installation directory (default: cwd)
+  --dry-run         Preview without writing
+  --resume          Resume from pending checkpoint (crash recovery)
+  --list            Show applied migration history
+  --help            Show this help
+
+Crash Recovery:
+  If the process is interrupted mid-migration, a checkpoint file is left
+  at .pantheon/.migration-checkpoint. Run with --resume to continue.
+`)
+}
+
+function main() {
+  const config = parseArgs()
+
+  if (config.help) {
+    showHelp()
+    return
+  }
+
+  // ── List mode ──
+  if (config.list) {
+    const history = listAppliedMigrations(config.target)
+    if (!history.currentVersion) {
+      console.log('  \u2139\uFE0F  No install state found in: ' + config.target)
+      return
+    }
+    console.log(`  Current version: ${history.currentVersion}`)
+    console.log(`  Previous version: ${history.previousVersion || 'N/A'}`)
+    console.log(`  Applied migrations: ${history.migrations.length}`)
+    for (const m of history.migrations) {
+      const icon =
+        m.status === 'completed'
+          ? '\u2705'
+          : m.status === 'rolled_back'
+            ? '\u{1F504}'
+            : '\u26A0\uFE0F'
+      console.log(`    ${icon} ${m.from} \u2192 ${m.to} [${m.status}] (${m.applied_at})`)
+    }
+    return
+  }
+
+  // ── Resume mode ──
+  if (config.resume) {
+    const cp = resumePendingMigration(config.target)
+    if (!cp) {
+      console.log('  \u23ED\uFE0F  No pending checkpoint found — nothing to resume')
+      return
+    }
+    config.from = cp.from
+    config.to = cp.to
+  } else {
+    if (!config.from || !config.to) {
+      console.error('\u274C --from and --to are required (or use --resume)')
+      showHelp()
+      process.exit(1)
+    }
+  }
+
+  // ── Read state ──
+  let state = readState(config.target)
+  if (!state) {
+    state = createInitialState(config.from)
+    console.log(`  \u{1F4DD} Creating new install state (v${state.schema_version})`)
+    if (!config.dryRun) writeState(config.target, state)
+  } else {
+    console.log(
+      `  \u{1F4CB} Current state: v${state.schema_version}, version ${state.pantheon_version}`,
+    )
+  }
+
+  // ── Resolve checkpoint ──
+  let cp = readCheckpoint(config.target)
+
+  if (!cp) {
+    const steps = resolveSteps(config.from, config.to)
+    cp = writeCheckpoint(config.target, config.from, config.to, steps)
+    console.log(`  \u{1F4DD} Checkpoint written: ${config.from} \u2192 ${config.to}`)
+  } else {
+    console.log(
+      `  \u{1F504} Resuming from checkpoint (${cp.steps_completed.length} steps done, ${cp.steps_pending.length} remaining)`,
+    )
+  }
+
+  // ── Run pending steps ──
+  const stepsToRun = [...cp.steps_pending]
+  let failed = false
+
+  for (const step of stepsToRun) {
+    const stepFn = MIGRATION_STEPS[step]
+    if (!stepFn) {
+      console.warn(`  \u26A0\uFE0F  Unknown migration step: ${step} — skipping`)
+      if (!config.dryRun) {
+        advanceCheckpoint(config.target, step)
+      }
+      continue
+    }
+
+    console.log(`  \u25B6\uFE0F  Running: ${step}`)
+    try {
+      stepFn(config.target, state, { dryRun: config.dryRun })
+
+      if (!config.dryRun) {
+        advanceCheckpoint(config.target, step)
+        writeState(config.target, state)
+        console.log(`  \u2705 ${step} completed`)
+      } else {
+        console.log(`  \u2705 ${step} would complete (dry-run)`)
+      }
+    } catch (err) {
+      console.error(`  \u274C ${step} failed: ${err.message}`)
+      failed = true
+      break
+    }
+  }
+
+  // ── Finalize ──
+  if (failed) {
+    console.error(`\n  \u274C Migration failed at checkpoint.`)
+    console.error(
+      `     Resume with: node scripts/install/migrate-config.mjs --resume --target=${config.target}`,
+    )
+    process.exit(1)
+  }
+
+  if (!config.dryRun) {
+    updateVersion(state, config.to)
+    addMigrationRecord(state, config.from, config.to, 'completed')
+    removeCheckpoint(config.target)
+    writeState(config.target, state)
+    console.log(
+      `\n  \u2705 Migration complete: ${config.from} \u2192 ${config.to}`,
+    )
+    console.log(
+      `     State written to: ${join(config.target, '.pantheon', 'install-state.json')}`,
+    )
+  } else {
+    console.log(
+      `\n  \u2705 Migration would complete (dry-run): ${config.from} \u2192 ${config.to}`,
+    )
+  }
+}
+
+if (process.argv[1] && import.meta.url === `file://${process.argv[1]}`) {
+  main()
+}