pantheon-opencode 1.5.0-beta.1 → 1.5.0-beta.3

package/scripts/probe-pantheon-cost.mjs

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+/**
+ * Offline/ambiental probe for pantheon_cost.
+ *
+ * The probe never reads or writes a user's real database. Without --fixture it
+ * reports AMBIENTAL because a real dependency/database is intentionally not
+ * exercised. With --fixture it imports the installed command and creates a
+ * temporary synthetic opencode database. A missing fixture runtime is also
+ * AMBIENTAL rather than a false PASS.
+ */
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const requestedVersion = valueFor('--version')
+const jsonOutput = process.argv.includes('--json')
+const fixtureMode = process.argv.includes('--fixture')
+
+function valueFor(name) {
+  const index = process.argv.indexOf(name)
+  return index >= 0 ? process.argv[index + 1] : undefined
+}
+
+function emit(status, detail, checks = []) {
+  const result = { status, version: requestedVersion, detail, checks }
+  if (jsonOutput) process.stdout.write(JSON.stringify(result))
+  else process.stdout.write(`${status}: ${detail}\n`)
+  if (status === 'FAIL') process.exitCode = 1
+}
+
+function ambiental(detail) {
+  emit('AMBIENTAL', detail)
+}
+
+function setEnvironment(values) {
+  const previous = new Map()
+  for (const [key, value] of Object.entries(values)) {
+    previous.set(key, process.env[key])
+    if (value === undefined) delete process.env[key]
+    else process.env[key] = value
+  }
+  return () => {
+    for (const [key, value] of previous) {
+      if (value === undefined) delete process.env[key]
+      else process.env[key] = value
+    }
+  }
+}
+
+function createSyntheticDb(DatabaseSync, path, rows) {
+  const db = new DatabaseSync(path)
+  db.exec('CREATE TABLE message (data TEXT NOT NULL, time_created INTEGER NOT NULL)')
+  const insert = db.prepare('INSERT INTO message (data, time_created) VALUES (?, ?)')
+  for (const data of rows) insert.run(JSON.stringify(data), Date.now())
+  db.close()
+}
+
+function createIncompatibleDb(DatabaseSync, path) {
+  const db = new DatabaseSync(path)
+  db.exec('CREATE TABLE not_message (value TEXT NOT NULL)')
+  db.close()
+}
+
+function requireOutput(output, fragment, label) {
+  if (!output.includes(fragment)) throw new Error(`${label}: missing ${fragment}`)
+}
+
+function assertTokensOnly(output, expectedRows, total) {
+  requireOutput(output, 'Tokens In | Tokens Out | Tokens Total', 'tokens-only header')
+  for (const row of expectedRows) {
+    requireOutput(
+      output,
+      `| ${row.agent} | ${row.phase} | ${row.input} | ${row.output} | ${row.total} |`,
+      'token row',
+    )
+  }
+  requireOutput(
+    output,
+    `| **Total** | — | **${total.input}** | **${total.output}** | **${total.total}** |`,
+    'token total',
+  )
+  if (/Cost \(USD\)|costUsd|\$\d|\bUSD\b/i.test(output)) {
+    throw new Error('tokens-only output contains a monetary value')
+  }
+}
+
+async function main() {
+  if (requestedVersion !== 'v1' && requestedVersion !== 'v2') {
+    emit('FAIL', 'usage: --version v1|v2 [--fixture] [--json]')
+    return
+  }
+
+  if (!fixtureMode) {
+    ambiental(
+      'real pantheon_cost dependency/database not exercised; use --fixture for synthetic checks',
+    )
+    return
+  }
+
+  const source = new URL('../src/pantheon/cost-command.ts', import.meta.url)
+  if (!existsSync(source)) {
+    ambiental(
+      'pantheon_cost dependency is unavailable: installed package lacks src/pantheon/cost-command.ts',
+    )
+    return
+  }
+
+  let DatabaseSync
+  let createCostCommand
+  try {
+    ;({ DatabaseSync } = await import('node:sqlite'))
+    ;({ createCostCommand } = await import(source.href))
+  } catch (error) {
+    ambiental(
+      `pantheon_cost fixture runtime unavailable: ${error instanceof Error ? error.message : String(error)}`,
+    )
+    return
+  }
+
+  const root = mkdtempSync(join(tmpdir(), 'pantheon-cost-probe-'))
+  const dataHome = join(root, 'data')
+  const opencodeDir = join(dataHome, 'opencode')
+  const selectedDb = join(opencodeDir, requestedVersion === 'v2' ? 'opencode-v2.db' : 'opencode.db')
+  const otherDb = join(root, 'other.db')
+  const envDb = join(root, 'env.db')
+  const explicitDb = join(root, 'explicit.db')
+  const incompatibleDb = join(root, 'incompatible.db')
+  const checks = []
+
+  try {
+    mkdirSync(opencodeDir, { recursive: true })
+    // These rows intentionally include a monetary-looking field to prove it is
+    // ignored; only input/output/total tokens may appear in the report.
+    const selectedRows =
+      requestedVersion === 'v2'
+        ? [
+            {
+              role: 'assistant',
+              agent: 'aphrodite',
+              phase: 'plan',
+              cost: 999.99,
+              tokens: { input: 7, output: 8 },
+            },
+            {
+              role: 'assistant',
+              agent: 'aphrodite',
+              phase: 'plan',
+              cost: 999.99,
+              tokens: { input: 1, output: 2 },
+            },
+            {
+              role: 'assistant',
+              agent: 'zeus',
+              phase: 'audit',
+              cost: 999.99,
+              tokens: { input: 4, output: 6 },
+            },
+          ]
+        : [
+            {
+              role: 'assistant',
+              agent: 'hermes',
+              phase: 'plan',
+              cost: 999.99,
+              tokens: { input: 10, output: 20 },
+            },
+            {
+              role: 'assistant',
+              agent: 'hermes',
+              phase: 'plan',
+              cost: 999.99,
+              tokens: { input: 3, output: 4 },
+            },
+            {
+              role: 'assistant',
+              agent: 'athena',
+              phase: 'review',
+              cost: 999.99,
+              tokens: { input: 2, output: 5 },
+            },
+          ]
+    createSyntheticDb(DatabaseSync, selectedDb, selectedRows)
+    createSyntheticDb(DatabaseSync, otherDb, [
+      {
+        role: 'assistant',
+        agent: 'wrong-version',
+        phase: 'other',
+        tokens: { input: 90, output: 90 },
+      },
+    ])
+    createSyntheticDb(DatabaseSync, envDb, [
+      { role: 'assistant', agent: 'env-agent', phase: 'override', tokens: { input: 1, output: 2 } },
+    ])
+    createSyntheticDb(DatabaseSync, explicitDb, [
+      {
+        role: 'assistant',
+        agent: 'explicit-agent',
+        phase: 'explicit',
+        tokens: { input: 9, output: 1 },
+      },
+    ])
+    createIncompatibleDb(DatabaseSync, incompatibleDb)
+
+    const restore = setEnvironment({
+      XDG_DATA_HOME: dataHome,
+      PANTHEON_OPENCODE_VERSION: requestedVersion,
+      PANTHEON_COST_DB: undefined,
+    })
+    try {
+      const selectedOutput = await createCostCommand().pantheon_cost.execute(
+        {},
+        { sessionID: 'cost-probe' },
+      )
+      assertTokensOnly(
+        selectedOutput,
+        requestedVersion === 'v2'
+          ? [
+              { agent: 'aphrodite', phase: 'plan', input: 8, output: 10, total: 18 },
+              { agent: 'zeus', phase: 'audit', input: 4, output: 6, total: 10 },
+            ]
+          : [
+              { agent: 'hermes', phase: 'plan', input: 13, output: 24, total: 37 },
+              { agent: 'athena', phase: 'review', input: 2, output: 5, total: 7 },
+            ],
+        requestedVersion === 'v2'
+          ? { input: 12, output: 16, total: 28 }
+          : { input: 15, output: 29, total: 44 },
+      )
+      checks.push('version-selected DB: PASS')
+    } finally {
+      restore()
+    }
+
+    const envRestore = setEnvironment({
+      XDG_DATA_HOME: dataHome,
+      PANTHEON_OPENCODE_VERSION: requestedVersion,
+      PANTHEON_COST_DB: envDb,
+    })
+    try {
+      const output = await createCostCommand().pantheon_cost.execute(
+        {},
+        { sessionID: 'cost-probe' },
+      )
+      requireOutput(output, '| env-agent | override | 1 | 2 | 3 |', 'PANTHEON_COST_DB')
+      if (output.includes('wrong-version') || output.includes('env-agent') === false) {
+        throw new Error('PANTHEON_COST_DB did not override the version-selected database')
+      }
+      checks.push('PANTHEON_COST_DB override: PASS')
+    } finally {
+      envRestore()
+    }
+
+    const explicitRestore = setEnvironment({
+      XDG_DATA_HOME: dataHome,
+      PANTHEON_OPENCODE_VERSION: requestedVersion,
+      PANTHEON_COST_DB: envDb,
+    })
+    try {
+      const output = await createCostCommand({ dbPath: explicitDb }).pantheon_cost.execute(
+        {},
+        { sessionID: 'cost-probe' },
+      )
+      requireOutput(output, '| explicit-agent | explicit | 9 | 1 | 10 |', 'explicit dbPath')
+      if (output.includes('env-agent')) throw new Error('explicit dbPath did not take precedence')
+      checks.push('explicit dbPath precedence: PASS')
+    } finally {
+      explicitRestore()
+    }
+
+    const missingRestore = setEnvironment({
+      XDG_DATA_HOME: join(root, 'missing-data'),
+      PANTHEON_OPENCODE_VERSION: requestedVersion,
+      PANTHEON_COST_DB: undefined,
+    })
+    try {
+      const output = await createCostCommand().pantheon_cost.execute(
+        {},
+        { sessionID: 'cost-probe' },
+      )
+      requireOutput(output, 'not found', 'missing DB')
+      requireOutput(
+        output,
+        requestedVersion === 'v2' ? 'opencode-v2.db' : 'opencode.db',
+        'selected missing DB path',
+      )
+      checks.push('missing DB: PASS')
+    } finally {
+      missingRestore()
+    }
+
+    const incompatibleOutput = await createCostCommand({
+      dbPath: incompatibleDb,
+    }).pantheon_cost.execute({}, { sessionID: 'cost-probe' })
+    requireOutput(incompatibleOutput, 'incompatible opencode.db schema', 'incompatible schema')
+    checks.push('incompatible schema: PASS')
+    emit('PASS', 'offline synthetic DB checks passed; no real DB was read', checks)
+  } catch (error) {
+    emit('FAIL', error instanceof Error ? error.message : String(error), checks)
+  } finally {
+    rmSync(root, { recursive: true, force: true })
+  }
+}
+
+await main()

package/scripts/release-beta-version.mjs

@@ -1,80 +1,81 @@
 #!/usr/bin/env node
-/** Compute and optionally apply the beta version for a release PR. */
+/**
+ * release-beta-version.mjs — beta version helpers.
+ *
+ * The beta version is committed in the manifests (package.json) and never
+ * computed at release time. `nextBetaVersion` advances the committed version:
+ *
+ *   X.Y.Z-beta.N  ->  X.Y.Z-beta.(N+1)     (stay on the current beta line)
+ *   X.Y.Z         ->  X.Y.(Z+1)-beta.1     (start a fresh beta line)
+ *
+ * `applyBetaVersion` writes an already-decided beta version into every
+ * manifest and is retained for recovery tooling. The legacy PR+SHA scheme
+ * (`X.Y.Z-beta.<pr>.<sha7>`) is accepted by validation for backward
+ * compatibility only; it is no longer generated.
+ */
 
-import { readFileSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
+import {
+  SEMVER_PATTERN,
+  validateInventory,
+  writeInventoryVersion,
+} from './manifest-inventory.mjs'
 
-export const MANIFESTS = [
-  { file: 'package.json', kind: 'json' },
-  { file: 'pyproject.toml', kind: 'toml' },
-  { file: 'plugin.json', kind: 'json' },
-  { file: 'src/plugins/tui/package.json', kind: 'json' },
-]
-
-const STABLE = /^(\d+)\.(\d+)\.(\d+)$/
+const STABLE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/
+// Current committed sequential beta line.
+const BETA_LINE = /^(\d+\.\d+\.\d+)-beta\.(\d+)$/
+// Legacy PR+SHA beta scheme, accepted for recovery only.
+const LEGACY_BETA =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)-beta\.[1-9]\d*\.[0-9a-f]{7}$/
+const BETA_RELEASE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)-beta\.[1-9]\d*$/
 
 export function nextStableVersion(latest, intent = 'patch') {
-  const match = STABLE.exec(String(latest))
-  if (!match) throw new Error(`npm latest is not a stable semver: "${latest}"`)
-  const [major, minor, patch] = match.slice(1).map(Number)
+  const match = STABLE.exec(String(latest).trim())
+  if (!match) throw new Error(`latest is not a stable semver: "${latest}"`)
   if (!['patch', 'minor', 'major'].includes(intent)) {
     throw new Error(`release intent must be patch, minor, or major: "${intent}"`)
   }
+  const [major, minor, patch] = match.slice(1).map(Number)
   if (intent === 'major') return `${major + 1}.0.0`
   if (intent === 'minor') return `${major}.${minor + 1}.0`
   return `${major}.${minor}.${patch + 1}`
 }
 
-export function betaVersion(latest, intent, pr, sha) {
-  if (!/^\d+$/.test(String(pr)) || Number(pr) < 1) throw new Error(`invalid PR number: "${pr}"`)
-  const shortSha = String(sha).slice(0, 7)
-  if (!/^[0-9a-f]{7,}$/i.test(shortSha)) throw new Error(`invalid commit SHA: "${sha}"`)
-  return `${nextStableVersion(latest, intent)}-beta.${pr}.${shortSha}`
-}
+/**
+ * Next beta version derived from the committed manifest version.
+ *
+ * @param {string} current committed version (e.g. "1.5.0-beta.2")
+ * @returns {string} the next sequential beta (e.g. "1.5.0-beta.3")
+ */
+export function nextBetaVersion(current) {
+  const value = String(current).trim()
+  const line = BETA_LINE.exec(value)
+  if (line) return `${line[1]}-beta.${Number(line[2]) + 1}`
 
-function writeVersion(root, { file, kind }, version) {
-  const path = join(root, file)
-  const raw = readFileSync(path, 'utf8')
-  if (kind === 'toml') {
-    const updated = raw.replace(/^(version\s*=\s*")[^"]+("\s*)$/m, `$1${version}$2`)
-    if (updated === raw) throw new Error(`no version field in ${file}`)
-    writeFileSync(path, updated)
-    return
-  }
-  const content = JSON.parse(raw)
-  content.version = version
-  writeFileSync(path, `${JSON.stringify(content, null, 2)}\n`)
-}
+  const stable = STABLE.exec(value)
+  if (stable) return `${nextStableVersion(value, 'patch')}-beta.1`
 
-export function applyBetaVersion(root, version) {
-  for (const manifest of MANIFESTS) writeVersion(root, manifest, version)
-  // Keep npm's lockfile metadata consistent without changing dependency data.
-  const lockPath = join(root, 'package-lock.json')
-  const lock = JSON.parse(readFileSync(lockPath, 'utf8'))
-  lock.version = version
-  if (lock.packages?.['']) lock.packages[''].version = version
-  writeFileSync(lockPath, `${JSON.stringify(lock, null, 2)}\n`)
+  // Any other prerelease (e.g. 1.5.0-rc.1): beta the next patch of its base.
+  const base = /^(\d+\.\d+\.\d+)-[0-9A-Za-z.-]+$/.exec(value)
+  if (!base) throw new Error(`cannot derive a beta version from: "${current}"`)
+  return `${nextStableVersion(base[1], 'patch')}-beta.1`
 }
 
-const args = new Map(
-  process.argv.slice(2).map((arg) => {
-    const [key, ...value] = arg.split('=')
-    return [key.replace(/^--/, ''), value.join('=')]
-  }),
-)
-
-if (args.has('latest')) {
-  try {
-    const version = betaVersion(
-      args.get('latest'),
-      args.get('intent') || 'patch',
-      args.get('pr'),
-      args.get('sha'),
+function validateReleaseVersion(version) {
+  if (typeof version !== 'string' || !SEMVER_PATTERN.test(version)) {
+    throw new Error(`invalid release semver: "${version}"`)
+  }
+  if (!BETA_RELEASE.test(version) && !LEGACY_BETA.test(version)) {
+    throw new Error(
+      `release version must be <base>-beta.<N> or legacy <base>-beta.<pr>.<7-char-sha>: "${version}"`,
     )
-    if (args.has('apply')) applyBetaVersion(process.cwd(), version)
-    console.log(version)
-  } catch (error) {
-    console.error(`release-beta-version: ${error.message}`)
-    process.exit(1)
   }
 }
+
+/** Preflight all six entries, then update metadata only. */
+export function applyBetaVersion(root, version) {
+  validateReleaseVersion(version)
+  const inventory = validateInventory(root, { allowVersionDivergence: true })
+  writeInventoryVersion(inventory, version)
+  const after = validateInventory(root)
+  if (after.sourceVersion !== version) throw new Error('beta version post-write validation failed')
+}

package/scripts/sync-tui.mjs

@@ -124,8 +124,7 @@ try {
   // Source: TUI plugin inside the installed package
   const tuiSrcDir = join(ROOT, 'src', 'plugins', 'tui')
   if (!existsSync(tuiSrcDir)) {
-    // Source not found (shouldn't happen in a proper install)
-    process.exit(0)
+    throw new Error(`TUI plugin source not found: ${tuiSrcDir}`)
   }
 
   // Compare versions before copy
@@ -135,28 +134,8 @@ try {
   // Copy fresh files
   const { created } = copyPluginFiles(tuiSrcDir, tuiCopyDir)
 
-  // Refresh dependencies in the copy. npm install is only allowed when the
-  // operator explicitly opts into the non-deterministic legacy fallback.
-  try {
-    execSync('npm ci --omit=dev --no-audit --no-fund', { cwd: tuiCopyDir, stdio: 'pipe' })
-  } catch (err) {
-    if (process.env.PANTHEON_ALLOW_NPM_INSTALL_FALLBACK === '1') {
-      console.warn(`⚠️  npm ci failed; explicit fallback enabled: ${err.message}`)
-      try {
-        execSync('npm install --omit=dev --no-audit --no-fund --package-lock=false', {
-          cwd: tuiCopyDir,
-          stdio: 'pipe',
-        })
-      } catch (fallbackError) {
-        console.warn(`⚠️  TUI dependency refresh skipped: ${fallbackError.message}`)
-      }
-    } else {
-      console.warn(
-        `⚠️  TUI dependency refresh skipped after npm ci failure. Set ` +
-          `PANTHEON_ALLOW_NPM_INSTALL_FALLBACK=1 to explicitly allow npm install: ${err.message}`,
-      )
-    }
-  }
+  // Lockfile installation is the only accepted dependency path.
+  execSync('npm ci --omit=dev --no-audit --no-fund', { cwd: tuiCopyDir, stdio: 'pipe' })
 
   // Log result
   if (installedVersion && sourceVersion && installedVersion === sourceVersion && created === 0) {
@@ -167,7 +146,6 @@ try {
     )
   }
 } catch (err) {
-  // Postinstall scripts must never break npm install
-  console.warn(`⚠️  TUI sync skipped: ${err.message}`)
-  process.exit(0)
+  console.error(`❌ TUI sync failed: ${err.message}`)
+  process.exitCode = 1
 }