pantheon-opencode 1.5.2 → 1.6.0-beta.2

package/scripts/install/config-migration.mjs

@@ -116,7 +116,7 @@ const PROVIDER_RENAME_REVERSE = Object.fromEntries(
  * V2 shape:
  *   { package: "aisdk:ai-sdk-openai", settings: { baseURL: "...", apiKey: "..." }, models: { ... } }
  */
-function convertProviderV1toV2(name, config) {
+function convertProviderV1toV2(_name, config) {
   const result = { ...config }
 
   // npm → package (with aisdk: prefix)
@@ -171,7 +171,7 @@ function convertProviderV1toV2(name, config) {
 /**
  * Convert a single V2 provider config back to V1.
  */
-function convertProviderV2toV1(name, config) {
+function convertProviderV2toV1(_name, config) {
   const result = { ...config }
 
   // package → npm (strip aisdk: prefix)
@@ -304,6 +304,114 @@ const V2_TO_V1_RENAMES = Object.fromEntries(
   Object.entries(V1_TO_V2_RENAMES).map(([k, v]) => [v, k]),
 )
 
+/**
+ * Agent fields owned by the framework. Mirrors the exported MANAGED_FIELDS in
+ * install/opencode.mjs plus `source`, which the installer writes next to them.
+ * The migration runs before that merge, so it has to apply the same precedence
+ * itself when both `agent` and `agents` coexist: these come from the V1 block,
+ * every other field stays the user's.
+ *
+ * `permissions` is the V2 name — the converter renames the V1 `permission`
+ * block before the merge runs.
+ *
+ * `description` is deliberately absent, and this list is deliberately narrower
+ * than what the installer writes. The installer writes a description only when
+ * it creates an agent (install/opencode.mjs, the new-agent branch); on an agent
+ * that already exists it leaves the value alone, under its own comment "Existing
+ * agent fields belong to the user". So a description is framework-owned for a
+ * NEW agent and user-owned for an EXISTING one. Listing it here would make the
+ * migration stricter than the installer and would overwrite a description the
+ * installer deliberately preserves. mergeManagedAgents carries the value across
+ * instead, so it survives the merge without being treated as framework-owned.
+ *
+ * KNOWN DEBT: the installer still writes the V1 spelling `permission`, while V2
+ * reads `permissions`. An agent that goes through this merge can therefore end
+ * up carrying both keys, with `permission` left as dead weight that nothing
+ * reads. Tracked for the next slice; not fixed here, because picking a winner
+ * changes what an install writes.
+ */
+export const MANAGED_AGENT_FIELDS = Object.freeze([
+  'source',
+  'temperature',
+  'color',
+  'permissions',
+  'mode',
+  'hidden',
+  'disable_model_invocation',
+])
+
+/**
+ * Compare this module's managed-agent list against the installer's.
+ *
+ * The two merge paths have to agree: the migration reimplements the installer's
+ * merge because it runs before it. A field present on only one side is silent
+ * divergence — either the migration overwrites a field the installer leaves
+ * alone, or it stops mirroring one the installer now writes. Both directions
+ * matter, so the result is reported as a pair of differences rather than a
+ * boolean.
+ *
+ * Names are compared after the converter's renames, because that is the
+ * spelling the merge actually sees.
+ *
+ * @param {string[]} installerFields - MANAGED_FIELDS as exported by install/opencode.mjs
+ * @returns {{ onlyInMigration: string[], onlyInInstaller: string[] }}
+ */
+export function managedAgentFieldDrift(installerFields) {
+  const toV2Name = (field) => V1_TO_V2_RENAMES[field] ?? field
+  const migration = new Set(MANAGED_AGENT_FIELDS.map(toV2Name))
+  const installer = new Set(installerFields.map(toV2Name))
+  return {
+    onlyInMigration: [...migration].filter((f) => !installer.has(f)).sort(),
+    onlyInInstaller: [...installer].filter((f) => !migration.has(f)).sort(),
+  }
+}
+
+/** @returns {boolean} true for a plain name→config map (not null/array) */
+function isAgentMap(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+/**
+ * Merge the converted V1 `agent` block into an existing V2 `agents` base.
+ *
+ * Agents present in both are merged field by field: the base is kept, keys the
+ * base does not have are filled in from the V1 block, and MANAGED_AGENT_FIELDS
+ * are overwritten by the V1 values. Agents present in only one block are taken
+ * as they are — a union, not a replacement.
+ *
+ * Filling the gaps matters, and it is not description-specific: any key present
+ * only in the V1 block used to vanish here — `model`, `provider` and `mcp` too.
+ * `description` is the visible case, because the installer never writes one for
+ * an existing agent, so the V1 block is the only place that value can come from
+ * and the agent lost it on every install, permanently. Filling gaps can never
+ * destroy a base value; on conflict the base still wins, as before.
+ *
+ * @param {object} base - existing V2 `agents` map
+ * @param {object} managed - converted V1 `agent` map
+ * @returns {object} merged map
+ */
+function mergeManagedAgents(base, managed) {
+  const merged = { ...base }
+
+  for (const [name, agentConfig] of Object.entries(managed)) {
+    const existing = merged[name]
+    if (!isAgentMap(existing) || !isAgentMap(agentConfig)) {
+      merged[name] = agentConfig
+      continue
+    }
+    const entry = { ...existing }
+    for (const [field, value] of Object.entries(agentConfig)) {
+      if (!(field in entry)) entry[field] = value
+    }
+    for (const field of MANAGED_AGENT_FIELDS) {
+      if (field in agentConfig) entry[field] = agentConfig[field]
+    }
+    merged[name] = entry
+  }
+
+  return merged
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -333,7 +441,20 @@ export function migrateV1toV2(config) {
         }
         agents[agentName] = ac
       }
-      result.agents = agents
+      // An `agents` (V2) block may already exist — the installed opencode.json
+      // carries both, in either key order. Renaming onto it with a plain
+      // replace dropped the whole managed merge, so merge instead.
+      const base = result.agents
+      result.agents = isAgentMap(base) ? mergeManagedAgents(base, agents) : agents
+    } else if (key === 'agents') {
+      // V2 block: it is the base. The singular `agent` key may already have
+      // been converted above, in which case merge the two.
+      const managed = result.agents
+      if (isAgentMap(value)) {
+        result.agents = isAgentMap(managed) ? mergeManagedAgents(value, managed) : value
+      } else if (!isAgentMap(managed)) {
+        result.agents = value
+      }
     } else if (key === 'provider' && typeof value === 'object' && value !== null) {
       const providers = {}
       for (const [provName, provConfig] of Object.entries(value)) {

package/scripts/install/health-check.mjs

@@ -182,25 +182,12 @@ export function healthCheck(target, { dryRun = false, pythonTarget = target } =
       results.failed.push({ check: 'mcp-sdk', detail: 'NOT INSTALLED — all MCP servers will fail' })
     }
   }
-  // Check 4: chromadb importable
-  if (python) {
-    const result = spawnSync(
-      python,
-      ['-c', 'from fastembed import TextEmbedding; print(TextEmbedding.__module__)'],
-      { stdio: 'pipe' },
-    )
-    if (result.status === 0) {
-      results.passed.push({
-        check: 'chromadb',
-        detail: result.stdout.toString().trim(),
-      })
-    } else {
-      results.warnings.push({
-        check: 'chromadb',
-        detail: 'NOT INSTALLED — semantic search will fail',
-      })
-    }
-  }
+  // Check 4: the memory server's only search backend is the stdlib's own
+  // SQLite FTS5 (check 5 below). The former "chromadb importable" probe
+  // imported fastembed, which the vector pipeline removal deleted, so it
+  // warned "semantic search will fail" on every install. Removed rather than
+  // repointed: check 5 already asserts the capability that matters, and a
+  // second sqlite3 import probe would tell us nothing new.
 
   // Check 5: SQLite FTS5 available
   if (python) {

package/scripts/install/interactive.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { emitKeypressEvents } from 'node:readline'
-import { colors, icons } from './cli-ui.mjs'
+import { colors } from './cli-ui.mjs'
 
 const cursorHide = () => process.stdout.write('\x1b[?25l')
 const cursorShow = () => process.stdout.write('\x1b[?25h')
@@ -95,7 +95,7 @@ export async function promptMultiSelect(
     const lineCount = lines.length
     if (previousLineCount > 0) cursorUp(previousLineCount)
     clearDown()
-    process.stdout.write(lines.join('\n') + '\n')
+    process.stdout.write(`${lines.join('\n')}\n`)
     previousLineCount = lineCount
   }
 
@@ -122,7 +122,7 @@ export async function promptMultiSelect(
       reject(new Error('Canceled'))
     }
 
-    function handler(str, key) {
+    function handler(_str, key) {
       if (!key) return
       if ((key.ctrl && key.name === 'c') || key.name === 'escape') {
         cancel()
@@ -184,7 +184,7 @@ export async function promptConfirm(message, { default: def = true } = {}) {
       reject(new Error('Canceled'))
     }
 
-    function handler(str, key) {
+    function handler(_str, key) {
       if (!key) return
       if ((key.ctrl && key.name === 'c') || key.name === 'escape') {
         cancel()
@@ -263,7 +263,7 @@ export async function promptList(options, { title = '' } = {}) {
     const lineCount = lines.length
     if (previousLineCount > 0) cursorUp(previousLineCount)
     clearDown()
-    process.stdout.write(lines.join('\n') + '\n')
+    process.stdout.write(`${lines.join('\n')}\n`)
     previousLineCount = lineCount
   }
 
@@ -290,7 +290,7 @@ export async function promptList(options, { title = '' } = {}) {
       reject(new Error('Canceled'))
     }
 
-    function handler(str, key) {
+    function handler(_str, key) {
       if (!key) return
       if ((key.ctrl && key.name === 'c') || key.name === 'escape') {
         cancel()

package/scripts/install/migrate.mjs

@@ -332,7 +332,7 @@ function main() {
   if (list) {
     const history = listAppliedMigrations(target)
     if (!history.currentVersion) {
-      console.log('  \u2139\uFE0F  No install state found in: ' + target)
+      console.log(`  \u2139\uFE0F  No install state found in: ${target}`)
       return
     }
     console.log(`  Current version: ${history.currentVersion}`)

package/scripts/install/opencode.mjs

@@ -61,6 +61,33 @@ const COMPONENT_NAMES = [
   'runtime',
 ]
 
+/**
+ * Per-agent fields owned by the framework: for an agent that already exists in
+ * the target config these are overwritten from the canonical source, and for a
+ * new agent they are the seed. Everything else on an existing entry is the
+ * user's and is left alone.
+ *
+ * `source` is written right next to these (for both new and existing agents) but
+ * is kept out of the loop so it can also be set independently — the migration in
+ * config-migration.mjs mirrors this list plus `source`, and tests assert the two
+ * stay equal as sets.
+ *
+ * KNOWN DEBT: `permission` is the V1 spelling. V2 reads `permissions`, so an
+ * agent can carry both keys after an install and the V1 one becomes dead weight.
+ * Tracked for the next slice; changing it here would change what an install
+ * writes.
+ *
+ * @type {readonly string[]}
+ */
+export const MANAGED_FIELDS = Object.freeze([
+  'temperature',
+  'color',
+  'permission',
+  'mode',
+  'hidden',
+  'disable_model_invocation',
+])
+
 function deepClone(value) {
   return JSON.parse(JSON.stringify(value))
 }
@@ -836,7 +863,6 @@ export async function installOpenCode(
       if (fm.mode) agent.mode = fm.mode
       if (fm.hidden) agent.hidden = fm.hidden
       if (fm.temperature !== undefined) agent.temperature = fm.temperature
-      if (fm.steps !== undefined) agent.steps = fm.steps
       // Support both hyphen (YAML) and underscore (JSON) key variants
       if (fm['disable-model-invocation'] !== undefined)
         agent.disable_model_invocation = fm['disable-model-invocation']
@@ -855,15 +881,6 @@ export async function installOpenCode(
 
   const canonicalAgentConfig = readAgentConfigFromCanonical()
   const agentSources = getAgentSources(agentPrefix)
-  const MANAGED_FIELDS = [
-    'steps',
-    'temperature',
-    'color',
-    'permission',
-    'mode',
-    'hidden',
-    'disable_model_invocation',
-  ]
 
   if (config.agent === undefined) config.agent = {}
 
@@ -1222,6 +1239,22 @@ export async function installOpenCode(
   if (version === 'v2') {
     info(S.v2Migrating)
     configToWrite = migrateV1toV2(config)
+
+    // Pantheon no longer sets a step ceiling. Any `steps` sitting on a managed
+    // agent was written by an earlier install and never chosen by the user —
+    // the merge above is additive by design (no delete path), so drop it here
+    // and let the host default apply. This runs after the migration because
+    // migrateV1toV2 copies the V1 `agent` block across verbatim (including any
+    // stale `steps`), which is exactly how the value reappears in V2.
+    // User-defined agents are out of scope and keep their value; the V1
+    // singular `agent` block is deliberately untouched (V1 is retiring).
+    const v2Agents = configToWrite.agents
+    if (v2Agents && typeof v2Agents === 'object' && !Array.isArray(v2Agents)) {
+      for (const name of Object.keys(canonicalAgentConfig)) {
+        const entry = v2Agents[name]
+        if (entry && typeof entry === 'object' && !Array.isArray(entry)) delete entry.steps
+      }
+    }
   }
 
   const configContent = `${JSON.stringify(configToWrite, null, 2)}\n`