@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/shared/merge-categories.ts

@@ -1,18 +0,0 @@
-import type { CategoriesConfig, CategoryConfig } from "../config/schema"
-import { DEFAULT_CATEGORIES } from "../tools/delegate-task/constants"
-
-/**
- * Merge default and user categories, filtering out disabled ones.
- * Single source of truth for category merging across the codebase.
- */
-export function mergeCategories(
-  userCategories?: CategoriesConfig,
-): Record<string, CategoryConfig> {
-  const merged = userCategories
-    ? { ...DEFAULT_CATEGORIES, ...userCategories }
-    : { ...DEFAULT_CATEGORIES }
-
-  return Object.fromEntries(
-    Object.entries(merged).filter(([, config]) => !config.disable),
-  )
-}

package/src/shared/migrate-legacy-config-file.ts

@@ -1,66 +0,0 @@
-import { existsSync, readFileSync, renameSync, rmSync } from "node:fs"
-import { join, dirname, basename } from "node:path"
-
-import { log } from "./logger"
-import { CONFIG_BASENAME, LEGACY_CONFIG_BASENAME } from "./plugin-identity"
-import { writeFileAtomically } from "./write-file-atomically"
-
-function buildCanonicalPath(legacyPath: string): string {
-  const dir = dirname(legacyPath)
-  const ext = basename(legacyPath).includes(".jsonc") ? ".jsonc" : ".json"
-  return join(dir, `${CONFIG_BASENAME}${ext}`)
-}
-
-function archiveLegacyConfigFile(legacyPath: string): boolean {
-  const backupPath = `${legacyPath}.bak`
-
-  try {
-    renameSync(legacyPath, backupPath)
-    log("[migrateLegacyConfigFile] Legacy config was migrated and renamed to backup. Update the canonical file only.", {
-      legacyPath,
-      backupPath,
-    })
-    return true
-  } catch (renameError) {
-    try {
-      rmSync(legacyPath)
-      log("[migrateLegacyConfigFile] Legacy config was migrated and removed after backup rename failed. Update the canonical file only.", {
-        legacyPath,
-        backupPath,
-        renameError,
-      })
-      return true
-    } catch (removeError) {
-      log("[migrateLegacyConfigFile] WARNING: canonical config was written but the legacy file still exists and will be ignored. Remove or rename it manually.", {
-        legacyPath,
-        backupPath,
-        renameError,
-        removeError,
-      })
-      return false
-    }
-  }
-}
-
-export function migrateLegacyConfigFile(legacyPath: string): boolean {
-  if (!existsSync(legacyPath)) return false
-  if (!basename(legacyPath).startsWith(LEGACY_CONFIG_BASENAME)) return false
-
-  const canonicalPath = buildCanonicalPath(legacyPath)
-  if (existsSync(canonicalPath)) return false
-
-  try {
-    const content = readFileSync(legacyPath, "utf-8")
-    writeFileAtomically(canonicalPath, content)
-    const archivedLegacyConfig = archiveLegacyConfigFile(legacyPath)
-    log("[migrateLegacyConfigFile] Migrated legacy config to canonical path", {
-      from: legacyPath,
-      to: canonicalPath,
-      archivedLegacyConfig,
-    })
-    return true
-  } catch (error) {
-    log("[migrateLegacyConfigFile] Failed to migrate legacy config file", { legacyPath, error })
-    return false
-  }
-}

package/src/shared/migrate-legacy-plugin-entry.ts

@@ -1,75 +0,0 @@
-import { closeSync, existsSync, fsyncSync, openSync, readFileSync, renameSync, writeFileSync } from "node:fs"
-
-import { applyEdits, modify } from "jsonc-parser"
-
-import { parseJsoncSafe } from "./jsonc-parser"
-import { log } from "./logger"
-import { LEGACY_PLUGIN_NAME, PLUGIN_NAME } from "./plugin-identity"
-import { isCanonicalEntry, isLegacyEntry, toCanonicalEntry } from "./plugin-entry-migrator"
-
-interface OpenCodeConfig {
-  plugin?: string[]
-}
-
-function normalizePluginEntries(entries: string[]): string[] {
-  const hasCanonical = entries.some(isCanonicalEntry)
-
-  if (hasCanonical) {
-    return entries.filter((entry) => !isLegacyEntry(entry))
-  }
-
-  return entries.map((entry) => (isLegacyEntry(entry) ? toCanonicalEntry(entry) : entry))
-}
-
-function updateJsoncPluginArray(content: string, pluginEntries: string[]): string | null {
-  const edits = modify(content, ["plugin"], pluginEntries, {
-    formattingOptions: {
-      insertSpaces: true,
-      tabSize: 2,
-      eol: "\n",
-    },
-    getInsertionIndex: () => 0,
-  })
-
-  if (edits.length === 0) return null
-  return applyEdits(content, edits)
-}
-
-export function migrateLegacyPluginEntry(configPath: string): boolean {
-  if (!existsSync(configPath)) return false
-
-  try {
-    const content = readFileSync(configPath, "utf-8")
-    if (!content.includes(LEGACY_PLUGIN_NAME)) return false
-
-    const parseResult = parseJsoncSafe<OpenCodeConfig>(content)
-    const pluginEntries = parseResult.data?.plugin
-    if (!pluginEntries || !pluginEntries.some(isLegacyEntry)) return false
-
-    const updatedPluginEntries = normalizePluginEntries(pluginEntries)
-    const updated = configPath.endsWith(".jsonc")
-      ? updateJsoncPluginArray(content, updatedPluginEntries)
-      : JSON.stringify({ ...(parseResult.data as OpenCodeConfig), plugin: updatedPluginEntries }, null, 2) + "\n"
-    if (!updated || updated === content) return false
-
-    const tempPath = `${configPath}.tmp`
-    writeFileSync(tempPath, updated, "utf-8")
-    const tempFileDescriptor = openSync(tempPath, "r")
-    try {
-      fsyncSync(tempFileDescriptor)
-    } finally {
-      closeSync(tempFileDescriptor)
-    }
-
-    renameSync(tempPath, configPath)
-    log("[migrateLegacyPluginEntry] Auto-migrated opencode.json plugin entry", {
-      configPath,
-      from: LEGACY_PLUGIN_NAME,
-      to: PLUGIN_NAME,
-    })
-    return true
-  } catch (error) {
-    log("[migrateLegacyPluginEntry] Failed to migrate opencode.json", { configPath, error })
-    return false
-  }
-}

package/src/shared/migration/agent-category.ts

@@ -1,60 +0,0 @@
-/**
- * @deprecated LEGACY MIGRATION ONLY
- *
- * This map exists solely for migrating old configs that used hardcoded model strings.
- * It maps legacy model strings to semantic category names, allowing users to migrate
- * from explicit model configs to category-based configs.
- *
- * DO NOT add new entries here. New agents should use:
- * - Category-based config (preferred): { category: "unspecified-high" }
- * - Or inherit from OpenCode's config.model
- *
- * This map will be removed in a future major version once migration period ends.
- */
-export const MODEL_TO_CATEGORY_MAP: Record<string, string> = {
-  "google/gemini-3.1-pro": "visual-engineering",
-  "google/gemini-3-flash": "writing",
-  "openai/gpt-5.4": "ultrabrain",
-  "anthropic/claude-haiku-4-5": "quick",
-  "anthropic/claude-opus-4-6": "unspecified-high",
-  "anthropic/claude-sonnet-4-6": "unspecified-low",
-}
-
-export function migrateAgentConfigToCategory(config: Record<string, unknown>): {
-  migrated: Record<string, unknown>
-  changed: boolean
-} {
-  const { model, ...rest } = config
-  if (typeof model !== "string") {
-    return { migrated: config, changed: false }
-  }
-
-  const category = MODEL_TO_CATEGORY_MAP[model]
-  if (!category) {
-    return { migrated: config, changed: false }
-  }
-
-  return {
-    migrated: { category, ...rest },
-    changed: true,
-  }
-}
-
-export function shouldDeleteAgentConfig(
-  config: Record<string, unknown>,
-  category: string
-): boolean {
-  const { DEFAULT_CATEGORIES } = require("../../tools/delegate-task/constants")
-  const defaults = DEFAULT_CATEGORIES[category]
-  if (!defaults) return false
-
-  const keys = Object.keys(config).filter((k) => k !== "category")
-  if (keys.length === 0) return true
-
-  for (const key of keys) {
-    if (config[key] !== (defaults as Record<string, unknown>)[key]) {
-      return false
-    }
-  }
-  return true
-}

package/src/shared/migration/agent-names.ts

@@ -1,108 +0,0 @@
-export const AGENT_NAME_MAP: Record<string, string> = {
-  // Bob variants (subsumes General, Zoe, Build)
-  omo: "bob",
-  bob: "bob",
-  "bob (ultraworker)": "bob",
-  "bob - ultraworker": "bob",
-  general: "bob",
-  zoe: "bob",
-  build: "bob",
-
-  // Coder variants
-  coder: "coder",
-  "coder (deep agent)": "coder",
-  "coder - deep agent": "coder",
-
-  // Strategist variants (subsumes pre-plan/logician/athena)
-  "omo-plan": "strategist",
-  "planner-bob": "strategist",
-  strategist: "strategist",
-  "strategist - plan builder": "strategist",
-  "strategist (plan builder)": "strategist",
-  "pre-plan": "strategist",
-  "plan-consultant": "strategist",
-  "pre-plan - plan consultant": "strategist",
-  "pre-plan (plan consultant)": "strategist",
-  logician: "strategist",
-  athena: "strategist",
-  "athena-junior": "strategist",
-
-  // Critic remains explicit and canonical
-  critic: "critic",
-  "critic - plan critic": "critic",
-  "critic (plan critic)": "critic",
-  "quality-guardian": "critic",
-  "quality guardian - verifier": "critic",
-  "code-reviewer": "critic",
-  "systematic-debugger": "critic",
-
-  // Guard variants
-  "orchestrator-bob": "guard",
-  guard: "guard",
-  "guard (plan executor)": "guard",
-  "guard - plan executor": "guard",
-
-  // Researcher variants (subsumes Librarian, Explore)
-  librarian: "researcher",
-  explore: "researcher",
-  researcher: "researcher",
-  "researcher - codebase explorer": "researcher",
-
-  // Platform Manager variants (subsumes Ledger, Bootstrapper, Initializer, Mindmodel)
-  "ledger-creator": "platform-manager",
-  "bootstrapper": "platform-manager",
-  "project-initializer": "platform-manager",
-  "mindmodel": "platform-manager",
-  "platform-manager": "platform-manager",
-  manager: "platform-manager",
-  "platform manager - utility": "platform-manager",
-
-  // SubAgent
-  subagent: "coder",
-  sub: "coder",
-
-  // Designer
-  designer: "designer",
-
-  // Writer/copywriter aliases are handled by Brainstormer.
-  writer: "brainstormer",
-  copywriter: "brainstormer",
-  "content-writer": "brainstormer",
-  "content writer": "brainstormer",
-  "website-writer": "brainstormer",
-
-  // Multimodal / Vision
-  ui: "multimodal",
-  vision: "multimodal",
-  multimodal: "multimodal",
-}
-
-export const BUILTIN_AGENT_NAMES = new Set([
-  "bob",
-  "coder",
-  "strategist",
-  "critic",
-  "designer",
-  "researcher",
-  "multimodal",
-  "platform-manager",
-  "guard",
-  "brainstormer",
-])
-
-export function migrateAgentNames(
-  agents: Record<string, unknown>
-): { migrated: Record<string, unknown>; changed: boolean } {
-  const migrated: Record<string, unknown> = {}
-  let changed = false
-
-  for (const [key, value] of Object.entries(agents)) {
-    const newKey = AGENT_NAME_MAP[key.toLowerCase()] ?? AGENT_NAME_MAP[key] ?? key
-    if (newKey !== key) {
-      changed = true
-    }
-    migrated[newKey] = value
-  }
-
-  return { migrated, changed }
-}

package/src/shared/migration/config-migration.ts

@@ -1,210 +0,0 @@
-import * as fs from "node:fs"
-import { log } from "../logger"
-import { writeFileAtomically } from "../write-file-atomically"
-import { AGENT_NAME_MAP, migrateAgentNames } from "./agent-names"
-import { migrateHookNames } from "./hook-names"
-import { migrateModelVersions } from "./model-versions"
-import { readAppliedMigrations, writeAppliedMigrations } from "./migrations-sidecar"
-
-export function migrateConfigFile(
-  configPath: string,
-  rawConfig: Record<string, unknown>
-): boolean {
-  const copy = JSON.parse(JSON.stringify(rawConfig)) as Record<string, unknown>
-  let needsWrite = false
-
-  // Load previously applied migrations from BOTH the legacy in-config
-  // `_migrations` field AND the external sidecar file. The sidecar is the
-  // new source of truth because users were editing the config file to
-  // revert auto-migrated values and accidentally dropping the `_migrations`
-  // field in the process, which produced an infinite migration loop on
-  // every startup (#3263). Reading from both sources keeps old configs
-  // that still carry `_migrations` working without a forced reset.
-  const sidecarMigrations = readAppliedMigrations(configPath)
-  const inConfigMigrations = Array.isArray(copy._migrations)
-    ? new Set(copy._migrations as string[])
-    : new Set<string>()
-  const existingMigrations = new Set<string>([
-    ...sidecarMigrations,
-    ...inConfigMigrations,
-  ])
-  const hadLegacyInConfigMigrations = inConfigMigrations.size > 0
-  const allNewMigrations: string[] = []
-
-  if (copy.agents && typeof copy.agents === "object") {
-    const { migrated, changed } = migrateAgentNames(copy.agents as Record<string, unknown>)
-    if (changed) {
-      copy.agents = migrated
-      needsWrite = true
-    }
-  }
-
-  // Migrate model versions in agents (skip already-applied migrations)
-  if (copy.agents && typeof copy.agents === "object") {
-    const { migrated, changed, newMigrations } = migrateModelVersions(
-      copy.agents as Record<string, unknown>,
-      existingMigrations
-    )
-    if (changed) {
-      copy.agents = migrated
-      needsWrite = true
-      log("Migrated model versions in agents config")
-    }
-    allNewMigrations.push(...newMigrations)
-  }
-
-  // Migrate model versions in categories (skip already-applied migrations)
-  if (copy.categories && typeof copy.categories === "object") {
-    const { migrated, changed, newMigrations } = migrateModelVersions(
-      copy.categories as Record<string, unknown>,
-      existingMigrations
-    )
-    if (changed) {
-      copy.categories = migrated
-      needsWrite = true
-      log("Migrated model versions in categories config")
-    }
-    allNewMigrations.push(...newMigrations)
-  }
-
-  // Record newly applied migrations. We persist the full set (existing +
-  // new) to the external sidecar file and strip the legacy `_migrations`
-  // field from the config body on its way out, so users stop having to
-  // think about a field that never should have been in their config in
-  // the first place. The in-memory `rawConfig` never re-exposes
-  // `_migrations` to downstream schema validation.
-  const newMigrationsToRecord = allNewMigrations.filter(mKey => !existingMigrations.has(mKey))
-  const fullMigrationSet = new Set<string>([
-    ...existingMigrations,
-    ...newMigrationsToRecord,
-  ])
-  const shouldWriteSidecar = newMigrationsToRecord.length > 0 || hadLegacyInConfigMigrations
-  if (newMigrationsToRecord.length > 0) {
-    needsWrite = true
-  }
-  if (hadLegacyInConfigMigrations) {
-    // Migrating state out of the config body is itself a config write.
-    needsWrite = true
-  }
-  if (shouldWriteSidecar) {
-    // Keep `_migrations` in the first config write so a later sidecar failure
-    // does not strand the config with migrated state missing from disk.
-    ;(copy as Record<string, unknown>)._migrations = Array.from(fullMigrationSet)
-    needsWrite = true
-  }
-
-  if (copy.omo_agent) {
-    copy.bob_agent = copy.omo_agent
-    delete copy.omo_agent
-    needsWrite = true
-  }
-
-  if (copy.experimental && typeof copy.experimental === "object") {
-    const experimental = copy.experimental as Record<string, unknown>
-    if ("hashline_edit" in experimental) {
-      if (copy.hashline_edit === undefined) {
-        copy.hashline_edit = experimental.hashline_edit
-      }
-      delete experimental.hashline_edit
-      if (Object.keys(experimental).length === 0) {
-        delete copy.experimental
-      }
-      needsWrite = true
-    }
-  }
-
-  if (copy.disabled_agents && Array.isArray(copy.disabled_agents)) {
-    const migrated: string[] = []
-    let changed = false
-    for (const agent of copy.disabled_agents as string[]) {
-      const newAgent = AGENT_NAME_MAP[agent.toLowerCase()] ?? AGENT_NAME_MAP[agent] ?? agent
-      if (newAgent !== agent) {
-        changed = true
-      }
-      migrated.push(newAgent)
-    }
-    if (changed) {
-      copy.disabled_agents = migrated
-      needsWrite = true
-    }
-  }
-
-  if (copy.disabled_hooks && Array.isArray(copy.disabled_hooks)) {
-    const { migrated, changed, removed } = migrateHookNames(copy.disabled_hooks as string[])
-    if (changed) {
-      copy.disabled_hooks = migrated
-      needsWrite = true
-    }
-    if (removed.length > 0) {
-      log(
-        `Removed obsolete hooks from disabled_hooks: ${removed.join(", ")} (these hooks no longer exist in v3.0.0)`
-      )
-    }
-  }
-
-  if (needsWrite) {
-    let finalConfig = JSON.parse(JSON.stringify(copy)) as Record<string, unknown>
-    const newContent = JSON.stringify(finalConfig, null, 2) + "\n"
-
-    // Compare with existing file content to skip backup when unchanged.
-    // The config may still need an in-memory migration even if the file
-    // content is identical (e.g. removing a deleted hook from disabled_hooks
-    // results in content that was already written by a prior migration).
-    let existingContent: string | undefined
-    try {
-      existingContent = fs.readFileSync(configPath, "utf-8")
-    } catch {
-      // File may not exist yet
-    }
-    const contentChanged = existingContent !== newContent
-
-    const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
-    const backupPath = `${configPath}.bak.${timestamp}`
-    let backupSucceeded = false
-    if (contentChanged) {
-      try {
-        fs.copyFileSync(configPath, backupPath)
-        backupSucceeded = true
-      } catch {
-        backupSucceeded = false
-      }
-    }
-
-    let writeSucceeded = false
-    try {
-      writeFileAtomically(configPath, newContent)
-      writeSucceeded = true
-    } catch (err) {
-      log(`Failed to write migrated config to ${configPath}:`, err)
-    }
-
-    if (writeSucceeded && shouldWriteSidecar) {
-      const sidecarWriteSucceeded = writeAppliedMigrations(configPath, fullMigrationSet)
-      if (sidecarWriteSucceeded && "_migrations" in finalConfig) {
-        const configWithoutLegacyMigrations = JSON.parse(JSON.stringify(finalConfig)) as Record<string, unknown>
-        delete configWithoutLegacyMigrations._migrations
-        try {
-          writeFileAtomically(configPath, JSON.stringify(configWithoutLegacyMigrations, null, 2) + "\n")
-          finalConfig = configWithoutLegacyMigrations
-        } catch (err) {
-          log(`Failed to remove legacy _migrations fallback from ${configPath}:`, err)
-        }
-      }
-    }
-
-    for (const key of Object.keys(rawConfig)) {
-      delete rawConfig[key]
-    }
-    Object.assign(rawConfig, finalConfig)
-
-    if (writeSucceeded) {
-      const backupMessage = backupSucceeded ? ` (backup: ${backupPath})` : ""
-      log(`Migrated config file: ${configPath}${backupMessage}`)
-    } else {
-      const backupMessage = backupSucceeded ? ` (backup: ${backupPath})` : ""
-      log(`Applied migrated config in-memory for: ${configPath}${backupMessage}`)
-    }
-  }
-
-  return needsWrite
-}

package/src/shared/migration/hook-names.ts

@@ -1,40 +0,0 @@
-// Migration map: old hook names → new hook names (for backward compatibility)
-// null means the hook was removed and should be filtered out from disabled_hooks
-export const HOOK_NAME_MAP: Record<string, string | null> = {
-  // Legacy names (backward compatibility)
-  "anthropic-auto-compact": "anthropic-context-window-limit-recovery",
-  "bob-orchestrator": "guard",
-
-  "bob-gpt-coder-reminder": null,
-
-  // Removed hooks (v3.0.0) - will be filtered out and user warned
-  "empty-message-sanitizer": null,
-  "delegate-task-english-directive": null,
-  "gpt-permission-continuation": null,
-}
-
-export function migrateHookNames(
-  hooks: string[]
-): { migrated: string[]; changed: boolean; removed: string[] } {
-  const migrated: string[] = []
-  const removed: string[] = []
-  let changed = false
-
-  for (const hook of hooks) {
-    const mapping = HOOK_NAME_MAP[hook]
-
-    if (mapping === null) {
-      removed.push(hook)
-      changed = true
-      continue
-    }
-
-    const newHook = mapping ?? hook
-    if (newHook !== hook) {
-      changed = true
-    }
-    migrated.push(newHook)
-  }
-
-  return { migrated, changed, removed }
-}

package/src/shared/migration/migrations-sidecar.ts

@@ -1,92 +0,0 @@
-import * as fs from "node:fs"
-import * as path from "node:path"
-import { log } from "../logger"
-import { writeFileAtomically } from "../write-file-atomically"
-
-/**
- * Sidecar state file that tracks applied config migrations outside the user's
- * config file.
- *
- * Why this exists (#3263): users who revert an auto-migrated value (e.g.
- * `gpt-5.4` → `gpt-5.3-codex`) and then delete the `_migrations` field from
- * their config would fall into an infinite migration loop — every startup
- * re-applied the migration because there was no memory of the previous
- * application. The sidecar remembers applied migrations even when the user
- * scrubs the config, and only "resets" when the user explicitly deletes both
- * the config and the sidecar.
- *
- * The sidecar lives next to the config file as
- * `<configFileName>.migrations.json`. One sidecar per config file. The file
- * format is a flat JSON object:
- *
- *     {
- *       "appliedMigrations": [
- *         "model-version:openai/gpt-5.3-codex->openai/gpt-5.4",
- *         "model-version:anthropic/claude-opus-4-5->anthropic/claude-opus-4-6"
- *       ]
- *     }
- */
-
-export interface MigrationsSidecar {
-  appliedMigrations: string[]
-}
-
-export function getSidecarPath(configPath: string): string {
-  return `${configPath}.migrations.json`
-}
-
-/**
- * Read the set of applied migration keys from the sidecar next to
- * `configPath`. Returns an empty set on any read or parse failure so the
- * caller can still trust the return value and safely fall back to the
- * config's `_migrations` field.
- */
-export function readAppliedMigrations(configPath: string): Set<string> {
-  const sidecarPath = getSidecarPath(configPath)
-  try {
-    if (!fs.existsSync(sidecarPath)) {
-      return new Set()
-    }
-    const content = fs.readFileSync(sidecarPath, "utf-8")
-    const parsed = JSON.parse(content) as unknown
-    if (
-      parsed &&
-      typeof parsed === "object" &&
-      !Array.isArray(parsed) &&
-      Array.isArray((parsed as MigrationsSidecar).appliedMigrations)
-    ) {
-      return new Set((parsed as MigrationsSidecar).appliedMigrations.filter((m): m is string => typeof m === "string"))
-    }
-    return new Set()
-  } catch (err) {
-    log(`[migration] Failed to read migrations sidecar at ${sidecarPath}`, err)
-    return new Set()
-  }
-}
-
-/**
- * Persist the given set of applied migration keys to the sidecar next to
- * `configPath`. The sidecar is written atomically. Returns true on success,
- * false if the write failed (the caller can still proceed — the next
- * startup will re-run the migration, which is idempotent by design).
- */
-export function writeAppliedMigrations(configPath: string, migrations: Set<string>): boolean {
-  const sidecarPath = getSidecarPath(configPath)
-  const body: MigrationsSidecar = {
-    appliedMigrations: Array.from(migrations).sort(),
-  }
-  try {
-    // Ensure the parent directory exists in case the config file was created
-    // out-of-band. We intentionally do NOT create the sidecar when the migration
-    // set is empty — there is nothing to remember.
-    const parentDir = path.dirname(sidecarPath)
-    if (!fs.existsSync(parentDir)) {
-      fs.mkdirSync(parentDir, { recursive: true })
-    }
-    writeFileAtomically(sidecarPath, JSON.stringify(body, null, 2) + "\n")
-    return true
-  } catch (err) {
-    log(`[migration] Failed to write migrations sidecar at ${sidecarPath}`, err)
-    return false
-  }
-}