omo-ai 0.0.0-beta.0 → 5.0.0-0.beta.2

package/bin/lib/child-process.js

@@ -0,0 +1,18 @@
+import { spawnSync } from "node:child_process"
+
+export function propagateResult(result) {
+  if (result.error) throw result.error
+  if (result.signal) {
+    process.kill(process.pid, result.signal)
+    return
+  }
+  process.exitCode = result.status ?? 1
+}
+
+export function spawnNode(scriptPath, args, options = {}) {
+  const result = spawnSync(process.execPath, [scriptPath, ...args], {
+    stdio: "inherit",
+    ...options,
+  })
+  propagateResult(result)
+}

package/bin/lib/doctor.js

@@ -0,0 +1,87 @@
+import { existsSync, readFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+import { packageManifest, packageRoot, readJson, resolveSenpi } from "./package-paths.js"
+import { needsSetupSuggestion } from "./setup-detect.js"
+
+const artifacts = [
+  ["plugin manifest", "plugin/package.json"],
+  ["extension", "plugin/extensions/omo.js"],
+  ["lsp-daemon runtime", "plugin/runtime/lsp-daemon/dist/cli.js"],
+  ["agent-toolkit runtime", "plugin/runtime/agent-toolkit/cli.js"],
+]
+
+function pass(message) {
+  console.log(`PASS ${message}`)
+}
+
+function fail(message) {
+  console.log(`FAIL ${message}`)
+}
+
+function warnForSettings() {
+  const agentDir = process.env.SENPI_CODING_AGENT_DIR || join(homedir(), ".senpi", "agent")
+  const settingsPath = join(agentDir, "settings.json")
+  if (!existsSync(settingsPath)) return
+
+  let settings
+  try {
+    settings = JSON.parse(readFileSync(settingsPath, "utf8"))
+  } catch (error) {
+    console.log(`WARN could not parse ${settingsPath}: ${error.message}`)
+    return
+  }
+
+  const packages = Array.isArray(settings?.packages) ? settings.packages : []
+  const duplicate = packages.some((entry) => {
+    if (typeof entry === "string") return entry === "@code-yeongyu/omo-senpi"
+    return entry !== null && typeof entry === "object" && entry.source === "@code-yeongyu/omo-senpi"
+  })
+  if (duplicate) {
+    console.log("WARN duplicate @code-yeongyu/omo-senpi package entry; remove it from the packages array because omo loads the packaged extension")
+  }
+}
+
+export function runDoctor(inventory) {
+  let failed = false
+  for (const [label, artifact] of artifacts) {
+    const path = join(packageRoot, artifact)
+    if (existsSync(path)) pass(`${label}: ${artifact}`)
+    else {
+      // Report the declared posix-style artifact path so diagnostics read identically on every platform;
+      // deriving it back from the joined path yields backslashes on Windows.
+      fail(`${label}: missing ${artifact}`)
+      failed = true
+    }
+  }
+
+  let senpi
+  try {
+    senpi = resolveSenpi()
+    pass(`senpi CLI: ${senpi.cliPath}`)
+  } catch (error) {
+    fail(`senpi CLI: ${error.message}`)
+    failed = true
+  }
+
+  if (senpi) {
+    try {
+      const expected = packageManifest().dependencies["@code-yeongyu/senpi"]
+      const installed = readJson(join(senpi.packageRoot, "package.json")).version
+      if (installed === expected) pass(`senpi version ${installed}`)
+      else {
+        fail(`senpi version: expected ${expected}, found ${installed}`)
+        failed = true
+      }
+    } catch (error) {
+      fail(`senpi version: ${error.message}`)
+      failed = true
+    }
+  }
+
+  warnForSettings()
+  if (needsSetupSuggestion(inventory)) {
+    console.log("INFO senpi has no credentials; run omo setup to review sibling stores")
+  }
+  process.exitCode = failed ? 1 : 0
+}

package/bin/lib/launcher.js

@@ -0,0 +1,69 @@
+import { existsSync } from "node:fs"
+import { delimiter, join } from "node:path"
+import { spawnNode } from "./child-process.js"
+import { runDoctor } from "./doctor.js"
+import { nearestNodeBin, packageManifest, packageRoot, resolveSenpi } from "./package-paths.js"
+import { detectHarnesses, needsSetupSuggestion } from "./setup-detect.js"
+import { printSetupReport } from "./setup-report.js"
+
+const earlyCommands = new Set(["install", "remove", "list", "config", "auth", "app-server"])
+
+function senpiEnvironment(senpiRoot) {
+  const env = { ...process.env }
+  delete env.OMO_BIN
+  delete env.SENPI_BIN
+  env.OMO_AGENT_TOOLKIT_BIN = join(packageRoot, "bin", "omo-agent-toolkit.js")
+
+  const binDir = nearestNodeBin(senpiRoot)
+  if (binDir) {
+    env.PATH = env.PATH ? `${binDir}${delimiter}${env.PATH}` : binDir
+    const shim = join(binDir, process.platform === "win32" ? "senpi.cmd" : "senpi")
+    if (existsSync(shim)) env.SENPI_BIN = shim
+  }
+  return env
+}
+
+function spawnSenpi(args, withExtension) {
+  const senpi = resolveSenpi()
+  const finalArgs = withExtension
+    ? ["--extension", join(packageRoot, "plugin"), ...args]
+    : args
+  spawnNode(senpi.cliPath, finalArgs, { env: senpiEnvironment(senpi.packageRoot) })
+}
+
+function isInteractiveDefault(args) {
+  return process.stderr.isTTY === true && !args.includes("-p") && !args.includes("--print")
+}
+
+export async function runLauncher(args = process.argv.slice(2)) {
+  const command = args[0]
+  if (command === "ulw-loop") {
+    spawnNode(join(packageRoot, "plugin", "runtime", "agent-toolkit", "ulw-loop", "cli.js"), args.slice(1))
+    return
+  }
+  if (command === "doctor") {
+    runDoctor(await detectHarnesses())
+    return
+  }
+  if (command === "setup") {
+    printSetupReport(await detectHarnesses())
+    process.exitCode = 0
+    return
+  }
+  if (command === "update" && args.length === 1) {
+    console.log("omo is updated via npm: npm i -g omo-ai@beta")
+    process.exitCode = 0
+    return
+  }
+  if (earlyCommands.has(command) || command === "update") {
+    spawnSenpi(args, false)
+    return
+  }
+  if (isInteractiveDefault(args)) {
+    console.error(`omo (omo-ai beta ${packageManifest().version})`)
+    if (process.stdout.isTTY === true && needsSetupSuggestion(await detectHarnesses())) {
+      console.error("omo: sibling credentials detected; run `omo setup` to review them")
+    }
+  }
+  spawnSenpi(args, true)
+}

package/bin/lib/package-paths.js

@@ -0,0 +1,39 @@
+import { existsSync, readFileSync } from "node:fs"
+import { dirname, join, parse } from "node:path"
+import { fileURLToPath } from "node:url"
+
+export const packageRoot = fileURLToPath(new URL("../..", import.meta.url))
+
+export function readJson(path) {
+  return JSON.parse(readFileSync(path, "utf8"))
+}
+
+export function packageManifest() {
+  return readJson(join(packageRoot, "package.json"))
+}
+
+export function resolveSenpi() {
+  let indexPath
+  try {
+    indexPath = fileURLToPath(import.meta.resolve("@code-yeongyu/senpi"))
+  } catch (error) {
+    throw new Error(`could not resolve @code-yeongyu/senpi; reinstall with: npm i -g omo-ai@beta (${error.message})`)
+  }
+
+  const cliPath = join(dirname(indexPath), "cli.js")
+  if (!existsSync(cliPath)) {
+    throw new Error(`senpi CLI is missing at ${cliPath}; reinstall with: npm i -g omo-ai@beta`)
+  }
+  return { cliPath, packageRoot: dirname(dirname(indexPath)) }
+}
+
+export function nearestNodeBin(startPath) {
+  let current = startPath
+  const root = parse(current).root
+  while (true) {
+    const candidate = join(current, "node_modules", ".bin")
+    if (existsSync(candidate)) return candidate
+    if (current === root) return undefined
+    current = dirname(current)
+  }
+}

package/bin/lib/provider-map.json

@@ -0,0 +1,55 @@
+{
+  "_comment": "Derived from @code-yeongyu/senpi 2026.8.9-2. Re-derive builtin provider ids and mappings whenever that pin changes.",
+  "builtinProviderIds": [
+    "alibaba-token-plan",
+    "amazon-bedrock",
+    "ant-ling",
+    "anthropic",
+    "azure-openai-responses",
+    "cerebras",
+    "cloudflare-ai-gateway",
+    "cloudflare-workers-ai",
+    "deepseek",
+    "fireworks",
+    "github-copilot",
+    "google",
+    "google-vertex",
+    "groq",
+    "huggingface",
+    "kimi-coding",
+    "minimax",
+    "minimax-cn",
+    "mistral",
+    "moonshotai",
+    "moonshotai-cn",
+    "nvidia",
+    "ollama",
+    "openai",
+    "openai-codex",
+    "openrouter",
+    "qwen-token-plan",
+    "qwen-token-plan-cn",
+    "radius",
+    "together",
+    "vercel-ai-gateway",
+    "xai",
+    "xiaomi",
+    "xiaomi-token-plan-ams",
+    "xiaomi-token-plan-cn",
+    "xiaomi-token-plan-sgp",
+    "zai",
+    "zai-coding-cn"
+  ],
+  "excludedHostedGatewayIds": [
+    "opencode",
+    "opencode-go",
+    "zai-coding-plan"
+  ],
+  "providers": {
+    "anthropic-api": "anthropic",
+    "azure": "azure-openai-responses",
+    "kimi-for-coding": "kimi-coding",
+    "moonshot": "moonshotai",
+    "zhipuai": "zai"
+  }
+}

package/bin/lib/setup-detect.js

@@ -0,0 +1,167 @@
+import { existsSync, readFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+export const KNOWN_AUTH_SCHEMA_VERSIONS = new Set([4, 7])
+
+function sorted(values) {
+  return [...new Set(values)].sort()
+}
+
+function harness(id, installed, providers = [], credentialTypes = [], modelHint = "none") {
+  return {
+    id,
+    installed,
+    providers: sorted(providers),
+    credentialTypes: sorted(credentialTypes),
+    entryCount: providers.length,
+    importableCount: 0,
+    modelHint,
+    notices: [],
+  }
+}
+
+function readAuthJson(id, path) {
+  if (!existsSync(path)) return harness(id, false)
+  const result = harness(id, true)
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"))
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("expected an object")
+    }
+    for (const [provider, entry] of Object.entries(parsed)) {
+      result.providers.push(provider)
+      const type = entry !== null && typeof entry === "object" && typeof entry.type === "string"
+        ? entry.type
+        : "unknown"
+      result.credentialTypes.push(type)
+      if (id === "opencode" && type === "api") result.importableCount += 1
+    }
+    result.providers = sorted(result.providers)
+    result.credentialTypes = sorted(result.credentialTypes)
+    result.entryCount = result.providers.length
+  } catch (error) {
+    result.notices.push(`could not parse auth.json: ${error.message}`)
+  }
+  return result
+}
+
+function readSenpiModels(path, result) {
+  if (!existsSync(path)) return
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"))
+    const providers = parsed?.providers
+    if (providers !== null && typeof providers === "object" && !Array.isArray(providers)) {
+      const ids = sorted(Object.keys(providers))
+      result.modelHint = ids.length > 0 ? `providers: ${ids.join(", ")}` : "providers: none"
+    }
+  } catch (error) {
+    result.notices.push(`could not parse models.json: ${error.message}`)
+  }
+}
+
+function readGajaeModels(path) {
+  if (!existsSync(path)) return "none"
+  try {
+    const lines = readFileSync(path, "utf8").split(/\r?\n/)
+    const enabledModels = []
+    const modelRoles = []
+    let section
+    for (const line of lines) {
+      if (/^enabledModels\s*:/.test(line)) {
+        section = "enabledModels"
+        continue
+      }
+      if (/^modelRoles\s*:/.test(line)) {
+        section = "modelRoles"
+        continue
+      }
+      if (/^[^\s#][^:]*\s*:/.test(line)) {
+        section = undefined
+        continue
+      }
+      if (section === "enabledModels") {
+        const match = line.match(/^\s+-\s+(.+?)\s*$/)
+        if (match) enabledModels.push(match[1].replace(/^['"]|['"]$/g, ""))
+      } else if (section === "modelRoles") {
+        const match = line.match(/^\s+([^#][^:]*?)\s*:/)
+        if (match) modelRoles.push(match[1].trim())
+      }
+    }
+    const hints = []
+    if (enabledModels.length > 0) hints.push(`enabledModels: ${sorted(enabledModels).join(", ")}`)
+    if (modelRoles.length > 0) hints.push(`modelRoles: ${sorted(modelRoles).join(", ")}`)
+    return hints.length > 0 ? hints.join("; ") : "none"
+  } catch {
+    return "none"
+  }
+}
+
+function inspectSqlite(id, path, DatabaseSync, modelHint) {
+  const result = harness(id, existsSync(path), [], [], modelHint)
+  if (!result.installed) return result
+  let database
+  try {
+    database = new DatabaseSync(path, { readOnly: true })
+    const schema = database.prepare("SELECT version FROM auth_schema_version").get()
+    const version = schema?.version
+    if (!KNOWN_AUTH_SCHEMA_VERSIONS.has(version)) {
+      result.notices.push(`auth schema version ${String(version)} is unknown; credentials not inspected`)
+      return result
+    }
+    const rows = database.prepare(
+      "SELECT provider, credential_type, disabled_cause FROM auth_credentials",
+    ).all()
+    result.providers = sorted(rows.map((row) => row.provider))
+    result.credentialTypes = sorted(rows.map((row) => row.credential_type))
+    result.entryCount = rows.length
+    result.importableCount = rows.filter((row) =>
+      row.disabled_cause === null && row.credential_type === "api_key",
+    ).length
+  } catch (error) {
+    result.notices.push(`could not inspect agent.db: ${error.message}`)
+  } finally {
+    database?.close()
+  }
+  return result
+}
+
+export async function detectHarnesses(options = {}) {
+  const home = options.home ?? homedir()
+  const env = options.env ?? process.env
+  const agentDir = env.SENPI_CODING_AGENT_DIR || join(home, ".senpi", "agent")
+  const dataHome = env.XDG_DATA_HOME || join(home, ".local", "share")
+  const senpi = readAuthJson("senpi", join(agentDir, "auth.json"))
+  readSenpiModels(join(agentDir, "models.json"), senpi)
+  const opencode = readAuthJson("opencode", join(dataHome, "opencode", "auth.json"))
+  const ompPath = join(home, ".omp", "agent", "agent.db")
+  const gjcPath = join(home, ".gjc", "agent", "agent.db")
+  const ompModels = existsSync(join(home, ".omp", "agent", "models.db")) ? "models.db: yes" : "models.db: no"
+  const gjcModels = readGajaeModels(join(home, ".gjc", "agent", "config.yml"))
+  let DatabaseSync
+  try {
+    const sqlite = await (options.loadSqlite ?? (() => import("node:sqlite")))()
+    DatabaseSync = sqlite.DatabaseSync
+  } catch {
+    const omp = harness("oh-my-pi", existsSync(ompPath), [], [], ompModels)
+    const gjc = harness("gajae-code", existsSync(gjcPath), [], [], gjcModels)
+    for (const item of [omp, gjc]) {
+      if (item.installed) item.notices.push("node:sqlite unavailable; file presence only")
+    }
+    return { harnesses: [senpi, opencode, omp, gjc] }
+  }
+  return {
+    harnesses: [
+      senpi,
+      opencode,
+      inspectSqlite("oh-my-pi", ompPath, DatabaseSync, ompModels),
+      inspectSqlite("gajae-code", gjcPath, DatabaseSync, gjcModels),
+    ],
+  }
+}
+
+export function needsSetupSuggestion(inventory) {
+  const senpi = inventory.harnesses.find((item) => item.id === "senpi")
+  const siblingInstalled = inventory.harnesses.some((item) => item.id !== "senpi" && item.installed)
+  return (senpi?.entryCount ?? 0) === 0 && siblingInstalled
+}

package/bin/lib/setup-import.js

@@ -0,0 +1,231 @@
+import {
+  chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync,
+} from "node:fs"
+import { homedir } from "node:os"
+import { dirname, join } from "node:path"
+import { createInterface } from "node:readline/promises"
+import { detectHarnesses } from "./setup-detect.js"
+import { printModelReport } from "./setup-models.js"
+import { printSetupReport } from "./setup-report.js"
+
+export const API_KEY_TYPE_ACCEPTLIST = new Set(["api_key"])
+const SQLITE_STORES = [
+  ["oh-my-pi", ".omp", 7],
+  ["gajae-code", ".gjc", 4],
+]
+
+function sorted(values) {
+  return [...new Set(values)].sort()
+}
+
+function readProviderMap() {
+  return JSON.parse(readFileSync(new URL("./provider-map.json", import.meta.url), "utf8"))
+}
+
+function targetProvider(provider, providerMap) {
+  if (providerMap.excludedHostedGatewayIds.includes(provider)) return undefined
+  if (providerMap.builtinProviderIds.includes(provider)) return provider
+  return providerMap.providers[provider]
+}
+
+function candidate(provider, key, source, providerMap) {
+  const target = targetProvider(provider, providerMap)
+  return target ? { provider: target, key, source } : { provider, source, unmapped: true }
+}
+
+function readOpencode(path, providerMap, plan) {
+  if (!existsSync(path)) return
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"))
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return
+    for (const [provider, entry] of Object.entries(parsed)) {
+      if (entry === null || typeof entry !== "object") continue
+      if (entry.type === "oauth") {
+        plan.oauth.push(provider)
+      } else if (entry.type === "api" && typeof entry.key === "string") {
+        plan.candidates.push(candidate(provider, entry.key, "opencode", providerMap))
+      }
+    }
+  } catch (error) {
+    plan.notices.push(`WARN opencode: could not parse auth.json: ${error.message}`)
+  }
+}
+
+function readSqliteStore(id, path, expectedVersion, DatabaseSync, providerMap, plan) {
+  if (!existsSync(path)) return
+  let database
+  try {
+    database = new DatabaseSync(path, { readOnly: true })
+    const version = database.prepare("SELECT version FROM auth_schema_version").get()?.version
+    if (version !== expectedVersion) {
+      plan.notices.push(`NOTICE ${id}: auth schema version ${String(version)} is unknown; credentials not imported`)
+      return
+    }
+    const rows = database.prepare(
+      "SELECT provider, credential_type, data FROM auth_credentials WHERE disabled_cause IS NULL ORDER BY id ASC",
+    ).all()
+    for (const row of rows) {
+      if (row.credential_type === "oauth") {
+        plan.oauth.push(row.provider)
+        continue
+      }
+      if (!API_KEY_TYPE_ACCEPTLIST.has(row.credential_type)) continue
+      try {
+        const data = JSON.parse(row.data)
+        if (typeof data?.key === "string") {
+          plan.candidates.push(candidate(row.provider, data.key, id, providerMap))
+        }
+      } catch {
+        plan.notices.push(`WARN ${id}: ignored malformed ${row.credential_type} row for ${row.provider}`)
+      }
+    }
+  } catch (error) {
+    plan.notices.push(`WARN ${id}: could not inspect agent.db: ${error.message}`)
+  } finally {
+    database?.close()
+  }
+}
+
+async function buildPlan(options) {
+  const home = options.home ?? homedir()
+  const env = options.env ?? process.env
+  const dataHome = env.XDG_DATA_HOME || join(home, ".local", "share")
+  const providerMap = readProviderMap()
+  const plan = { candidates: [], oauth: [], notices: [] }
+  readOpencode(join(dataHome, "opencode", "auth.json"), providerMap, plan)
+  try {
+    const { DatabaseSync } = await (options.loadSqlite ?? (() => import("node:sqlite")))()
+    for (const [id, directory, version] of SQLITE_STORES) {
+      readSqliteStore(id, join(home, directory, "agent", "agent.db"), version, DatabaseSync, providerMap, plan)
+    }
+  } catch {
+    plan.notices.push("NOTICE setup: node:sqlite unavailable; database credentials not imported")
+  }
+  return plan
+}
+
+function readTarget(path) {
+  if (!existsSync(path)) return { entries: {}, bytes: undefined }
+  const bytes = readFileSync(path, "utf8")
+  try {
+    const entries = JSON.parse(bytes)
+    if (entries === null || typeof entries !== "object" || Array.isArray(entries)) throw new Error("expected object")
+    return { entries, bytes }
+  } catch {
+    return { malformed: true, bytes }
+  }
+}
+
+function classify(plan, existing) {
+  const additions = []
+  const skippedExisting = []
+  const skippedUnmapped = []
+  const reserved = new Set(Object.keys(existing))
+  for (const item of plan.candidates) {
+    if (item.unmapped) {
+      skippedUnmapped.push(item.provider)
+    } else if (reserved.has(item.provider)) {
+      skippedExisting.push(item.provider)
+    } else {
+      reserved.add(item.provider)
+      additions.push(item)
+    }
+  }
+  return {
+    additions,
+    skippedExisting: sorted(skippedExisting),
+    skippedOauth: sorted(plan.oauth),
+    skippedUnmapped: sorted(skippedUnmapped),
+  }
+}
+
+function list(label, ids) {
+  return `${label}: ${ids.length > 0 ? ids.join(", ") : "none"}`
+}
+
+function printPlan(result, dryRun) {
+  if (dryRun) process.stdout.write("DRY RUN: no files will be written\n")
+  process.stdout.write(`${[
+    list("planned-add", result.additions.map((item) => item.provider)),
+    list("skipped-existing", result.skippedExisting),
+    list("skipped-oauth", result.skippedOauth),
+    list("skipped-unmapped", result.skippedUnmapped),
+  ].join("\n")}\n`)
+}
+
+function printCounts(result) {
+  process.stdout.write([
+    `imported: ${result.additions.length}`,
+    `skipped-existing: ${result.skippedExisting.length}`,
+    `skipped-oauth: ${result.skippedOauth.length}`,
+    `skipped-unmapped: ${result.skippedUnmapped.length}`,
+    "Use `omo auth` to sign in to OAuth providers.",
+  ].join("\n") + "\n")
+}
+
+function timestamp() {
+  return new Date().toISOString().replace(/[-:]/g, "")
+}
+
+function writeTarget(path, current, additions) {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 })
+  if (current.bytes !== undefined) copyFileSync(path, `${path}.bak-${timestamp()}`)
+  const next = { ...current.entries }
+  for (const item of additions) next[item.provider] = { type: "api_key", key: item.key }
+  const temporary = `${path}.tmp-${process.pid}`
+  try {
+    writeFileSync(temporary, JSON.stringify(next, null, 2), { encoding: "utf8", mode: 0o600 })
+    chmodSync(temporary, 0o600)
+    renameSync(temporary, path)
+    chmodSync(path, 0o600)
+  } finally {
+    if (existsSync(temporary)) unlinkSync(temporary)
+  }
+}
+
+async function consent(result, target, options) {
+  if (options.yes) return true
+  if (options.stdin?.isTTY !== true || options.stdout?.isTTY !== true) {
+    process.stdout.write("Non-interactive setup did not import credentials. Re-run with `omo setup --yes`.\n")
+    return false
+  }
+  process.stdout.write(`Import API credentials for ${result.additions.map((item) => item.provider).join(", ")} into ${target}? [y/N] `)
+  const readline = createInterface({ input: options.stdin, output: options.stdout })
+  try {
+    return (await readline.question("")).trim().toLowerCase() === "y"
+  } finally {
+    readline.close()
+  }
+}
+
+export async function runSetup(args = process.argv.slice(2), options = {}) {
+  const home = options.home ?? homedir()
+  const env = options.env ?? process.env
+  const agentDir = env.SENPI_CODING_AGENT_DIR || join(home, ".senpi", "agent")
+  const target = join(agentDir, "auth.json")
+  const runtime = { stdin: process.stdin, stdout: process.stdout, ...options, home, env }
+  const inventory = await detectHarnesses(runtime)
+  printSetupReport(inventory)
+  printModelReport(inventory)
+  const plan = await buildPlan(runtime)
+  for (const notice of plan.notices) process.stdout.write(`${notice}\n`)
+  const current = readTarget(target)
+  if (current.malformed) {
+    process.stdout.write("WARN senpi: malformed auth.json; credentials were not imported\n")
+    return
+  }
+  const result = classify(plan, current.entries)
+  const dryRun = args.includes("--dry-run")
+  printPlan(result, dryRun)
+  if (dryRun) return
+  if (result.additions.length === 0) {
+    printCounts(result)
+    return
+  }
+  if (!await consent(result, target, { ...runtime, yes: args.includes("--yes") })) {
+    if (runtime.stdin.isTTY === true) process.stdout.write("Import cancelled\n")
+    return
+  }
+  writeTarget(target, current, result.additions)
+  printCounts(result)
+}

package/bin/lib/setup-models.js

@@ -0,0 +1,26 @@
+function values(items) {
+  return items.length > 0 ? items.join(", ") : "none"
+}
+
+export function formatModelReport(inventory) {
+  const lines = ["", "MODEL AVAILABILITY"]
+  for (const harness of inventory.harnesses) {
+    lines.push(`${harness.id}: providers ${values(harness.providers)}; models ${harness.modelHint}`)
+  }
+  lines.push(
+    "Model-to-agent guidance: docs/guide/agent-model-matching.md",
+    "Ready-to-paste omo.json models catalog template:",
+    JSON.stringify({
+      models: {
+        primary: { model: "<provider>/<model-id>", reasoning: "<off|low|medium|high|max>" },
+        "custom-endpoint": { model: "<custom-baseUrl-provider>/<model-id>" },
+      },
+    }, null, 2),
+    "For custom endpoints, define the provider baseUrl in senpi models.json, then use that provider id above.",
+  )
+  return `${lines.join("\n")}\n`
+}
+
+export function printModelReport(inventory) {
+  process.stdout.write(formatModelReport(inventory))
+}