opencode-repos 0.3.0 → 0.3.1

package/oh-my-opencode/src/cli/model-fallback.ts

@@ -1,246 +0,0 @@
-import type { InstallConfig } from "./types"
-
-type NativeProvider = "claude" | "openai" | "gemini"
-
-type ModelCapability =
-  | "unspecified-high"
-  | "unspecified-low"
-  | "quick"
-  | "ultrabrain"
-  | "visual-engineering"
-  | "artistry"
-  | "writing"
-  | "glm"
-
-interface ProviderAvailability {
-  native: {
-    claude: boolean
-    openai: boolean
-    gemini: boolean
-  }
-  opencodeZen: boolean
-  copilot: boolean
-  zai: boolean
-  isMaxPlan: boolean
-}
-
-interface AgentConfig {
-  model: string
-  variant?: string
-}
-
-interface CategoryConfig {
-  model: string
-  variant?: string
-}
-
-export interface GeneratedOmoConfig {
-  $schema: string
-  agents?: Record<string, AgentConfig>
-  categories?: Record<string, CategoryConfig>
-  [key: string]: unknown
-}
-
-interface NativeFallbackEntry {
-  provider: NativeProvider
-  model: string
-}
-
-const NATIVE_FALLBACK_CHAINS: Record<ModelCapability, NativeFallbackEntry[]> = {
-  "unspecified-high": [
-    { provider: "claude", model: "anthropic/claude-opus-4-5" },
-    { provider: "openai", model: "openai/gpt-5.2" },
-    { provider: "gemini", model: "google/gemini-3-pro-preview" },
-  ],
-  "unspecified-low": [
-    { provider: "claude", model: "anthropic/claude-sonnet-4-5" },
-    { provider: "openai", model: "openai/gpt-5.2" },
-    { provider: "gemini", model: "google/gemini-3-flash-preview" },
-  ],
-  quick: [
-    { provider: "claude", model: "anthropic/claude-haiku-4-5" },
-    { provider: "openai", model: "openai/gpt-5.1-codex-mini" },
-    { provider: "gemini", model: "google/gemini-3-flash-preview" },
-  ],
-  ultrabrain: [
-    { provider: "openai", model: "openai/gpt-5.2-codex" },
-    { provider: "claude", model: "anthropic/claude-opus-4-5" },
-    { provider: "gemini", model: "google/gemini-3-pro-preview" },
-  ],
-  "visual-engineering": [
-    { provider: "gemini", model: "google/gemini-3-pro-preview" },
-    { provider: "openai", model: "openai/gpt-5.2" },
-    { provider: "claude", model: "anthropic/claude-sonnet-4-5" },
-  ],
-  artistry: [
-    { provider: "gemini", model: "google/gemini-3-pro-preview" },
-    { provider: "openai", model: "openai/gpt-5.2" },
-    { provider: "claude", model: "anthropic/claude-opus-4-5" },
-  ],
-  writing: [
-    { provider: "gemini", model: "google/gemini-3-flash-preview" },
-    { provider: "openai", model: "openai/gpt-5.2" },
-    { provider: "claude", model: "anthropic/claude-sonnet-4-5" },
-  ],
-  glm: [],
-}
-
-const OPENCODE_ZEN_MODELS: Record<ModelCapability, string> = {
-  "unspecified-high": "opencode/claude-opus-4-5",
-  "unspecified-low": "opencode/claude-sonnet-4-5",
-  quick: "opencode/claude-haiku-4-5",
-  ultrabrain: "opencode/gpt-5.2-codex",
-  "visual-engineering": "opencode/gemini-3-pro",
-  artistry: "opencode/gemini-3-pro",
-  writing: "opencode/gemini-3-flash",
-  glm: "opencode/glm-4.7-free",
-}
-
-const GITHUB_COPILOT_MODELS: Record<ModelCapability, string> = {
-  "unspecified-high": "github-copilot/claude-opus-4.5",
-  "unspecified-low": "github-copilot/claude-sonnet-4.5",
-  quick: "github-copilot/claude-haiku-4.5",
-  ultrabrain: "github-copilot/gpt-5.2-codex",
-  "visual-engineering": "github-copilot/gemini-3-pro-preview",
-  artistry: "github-copilot/gemini-3-pro-preview",
-  writing: "github-copilot/gemini-3-flash-preview",
-  glm: "github-copilot/gpt-5.2",
-}
-
-const ZAI_MODEL = "zai-coding-plan/glm-4.7"
-
-interface AgentRequirement {
-  capability: ModelCapability
-  variant?: string
-}
-
-const AGENT_REQUIREMENTS: Record<string, AgentRequirement> = {
-  Sisyphus: { capability: "unspecified-high" },
-  oracle: { capability: "ultrabrain", variant: "high" },
-  librarian: { capability: "glm" },
-  explore: { capability: "quick" },
-  "multimodal-looker": { capability: "visual-engineering" },
-  "Prometheus (Planner)": { capability: "unspecified-high" },
-  "Metis (Plan Consultant)": { capability: "unspecified-high" },
-  "Momus (Plan Reviewer)": { capability: "ultrabrain", variant: "medium" },
-  Atlas: { capability: "unspecified-high" },
-}
-
-interface CategoryRequirement {
-  capability: ModelCapability
-  variant?: string
-}
-
-const CATEGORY_REQUIREMENTS: Record<string, CategoryRequirement> = {
-  "visual-engineering": { capability: "visual-engineering" },
-  ultrabrain: { capability: "ultrabrain" },
-  artistry: { capability: "artistry", variant: "max" },
-  quick: { capability: "quick" },
-  "unspecified-low": { capability: "unspecified-low" },
-  "unspecified-high": { capability: "unspecified-high" },
-  writing: { capability: "writing" },
-}
-
-const ULTIMATE_FALLBACK = "opencode/glm-4.7-free"
-const SCHEMA_URL = "https://raw.githubusercontent.com/code-yeongyu/oh-my-opencode/master/assets/oh-my-opencode.schema.json"
-
-function toProviderAvailability(config: InstallConfig): ProviderAvailability {
-  return {
-    native: {
-      claude: config.hasClaude,
-      openai: config.hasOpenAI,
-      gemini: config.hasGemini,
-    },
-    opencodeZen: config.hasOpencodeZen,
-    copilot: config.hasCopilot,
-    zai: config.hasZaiCodingPlan,
-    isMaxPlan: config.isMax20,
-  }
-}
-
-function resolveModel(capability: ModelCapability, avail: ProviderAvailability): string {
-  const nativeChain = NATIVE_FALLBACK_CHAINS[capability]
-  for (const entry of nativeChain) {
-    if (avail.native[entry.provider]) {
-      return entry.model
-    }
-  }
-
-  if (avail.opencodeZen) {
-    return OPENCODE_ZEN_MODELS[capability]
-  }
-
-  if (avail.copilot) {
-    return GITHUB_COPILOT_MODELS[capability]
-  }
-
-  if (avail.zai) {
-    return ZAI_MODEL
-  }
-
-  return ULTIMATE_FALLBACK
-}
-
-function resolveClaudeCapability(avail: ProviderAvailability): ModelCapability {
-  return avail.isMaxPlan ? "unspecified-high" : "unspecified-low"
-}
-
-export function generateModelConfig(config: InstallConfig): GeneratedOmoConfig {
-  const avail = toProviderAvailability(config)
-  const hasAnyProvider =
-    avail.native.claude ||
-    avail.native.openai ||
-    avail.native.gemini ||
-    avail.opencodeZen ||
-    avail.copilot ||
-    avail.zai
-
-  if (!hasAnyProvider) {
-    return {
-      $schema: SCHEMA_URL,
-      agents: Object.fromEntries(
-        Object.keys(AGENT_REQUIREMENTS).map((role) => [role, { model: ULTIMATE_FALLBACK }])
-      ),
-      categories: Object.fromEntries(
-        Object.keys(CATEGORY_REQUIREMENTS).map((cat) => [cat, { model: ULTIMATE_FALLBACK }])
-      ),
-    }
-  }
-
-  const agents: Record<string, AgentConfig> = {}
-  const categories: Record<string, CategoryConfig> = {}
-
-  const claudeCapability = resolveClaudeCapability(avail)
-
-  for (const [role, req] of Object.entries(AGENT_REQUIREMENTS)) {
-    if (role === "librarian" && avail.zai) {
-      agents[role] = { model: ZAI_MODEL }
-    } else if (role === "explore") {
-      if (avail.native.claude && avail.isMaxPlan) {
-        agents[role] = { model: "anthropic/claude-haiku-4-5" }
-      } else {
-        agents[role] = { model: "opencode/grok-code" }
-      }
-    } else {
-      const capability = req.capability === "unspecified-high" ? claudeCapability : req.capability
-      const model = resolveModel(capability, avail)
-      agents[role] = req.variant ? { model, variant: req.variant } : { model }
-    }
-  }
-
-  for (const [cat, req] of Object.entries(CATEGORY_REQUIREMENTS)) {
-    const capability = req.capability === "unspecified-high" ? claudeCapability : req.capability
-    const model = resolveModel(capability, avail)
-    categories[cat] = req.variant ? { model, variant: req.variant } : { model }
-  }
-
-  return {
-    $schema: SCHEMA_URL,
-    agents,
-    categories,
-  }
-}
-
-export function shouldShowChatGPTOnlyWarning(config: InstallConfig): boolean {
-  return !config.hasClaude && !config.hasGemini && config.hasOpenAI
-}

package/oh-my-opencode/src/cli/run/completion.test.ts

@@ -1,170 +0,0 @@
-import { describe, it, expect, mock, spyOn } from "bun:test"
-import type { RunContext, Todo, ChildSession, SessionStatus } from "./types"
-
-const createMockContext = (overrides: {
-  todo?: Todo[]
-  childrenBySession?: Record<string, ChildSession[]>
-  statuses?: Record<string, SessionStatus>
-} = {}): RunContext => {
-  const {
-    todo = [],
-    childrenBySession = { "test-session": [] },
-    statuses = {},
-  } = overrides
-
-  return {
-    client: {
-      session: {
-        todo: mock(() => Promise.resolve({ data: todo })),
-        children: mock((opts: { path: { id: string } }) =>
-          Promise.resolve({ data: childrenBySession[opts.path.id] ?? [] })
-        ),
-        status: mock(() => Promise.resolve({ data: statuses })),
-      },
-    } as unknown as RunContext["client"],
-    sessionID: "test-session",
-    directory: "/test",
-    abortController: new AbortController(),
-  }
-}
-
-describe("checkCompletionConditions", () => {
-  it("returns true when no todos and no children", async () => {
-    // #given
-    spyOn(console, "log").mockImplementation(() => {})
-    const ctx = createMockContext()
-    const { checkCompletionConditions } = await import("./completion")
-
-    // #when
-    const result = await checkCompletionConditions(ctx)
-
-    // #then
-    expect(result).toBe(true)
-  })
-
-  it("returns false when incomplete todos exist", async () => {
-    // #given
-    spyOn(console, "log").mockImplementation(() => {})
-    const ctx = createMockContext({
-      todo: [
-        { id: "1", content: "Done", status: "completed", priority: "high" },
-        { id: "2", content: "WIP", status: "in_progress", priority: "high" },
-      ],
-    })
-    const { checkCompletionConditions } = await import("./completion")
-
-    // #when
-    const result = await checkCompletionConditions(ctx)
-
-    // #then
-    expect(result).toBe(false)
-  })
-
-  it("returns true when all todos completed or cancelled", async () => {
-    // #given
-    spyOn(console, "log").mockImplementation(() => {})
-    const ctx = createMockContext({
-      todo: [
-        { id: "1", content: "Done", status: "completed", priority: "high" },
-        { id: "2", content: "Skip", status: "cancelled", priority: "medium" },
-      ],
-    })
-    const { checkCompletionConditions } = await import("./completion")
-
-    // #when
-    const result = await checkCompletionConditions(ctx)
-
-    // #then
-    expect(result).toBe(true)
-  })
-
-  it("returns false when child session is busy", async () => {
-    // #given
-    spyOn(console, "log").mockImplementation(() => {})
-    const ctx = createMockContext({
-      childrenBySession: {
-        "test-session": [{ id: "child-1" }],
-        "child-1": [],
-      },
-      statuses: { "child-1": { type: "busy" } },
-    })
-    const { checkCompletionConditions } = await import("./completion")
-
-    // #when
-    const result = await checkCompletionConditions(ctx)
-
-    // #then
-    expect(result).toBe(false)
-  })
-
-  it("returns true when all children idle", async () => {
-    // #given
-    spyOn(console, "log").mockImplementation(() => {})
-    const ctx = createMockContext({
-      childrenBySession: {
-        "test-session": [{ id: "child-1" }, { id: "child-2" }],
-        "child-1": [],
-        "child-2": [],
-      },
-      statuses: {
-        "child-1": { type: "idle" },
-        "child-2": { type: "idle" },
-      },
-    })
-    const { checkCompletionConditions } = await import("./completion")
-
-    // #when
-    const result = await checkCompletionConditions(ctx)
-
-    // #then
-    expect(result).toBe(true)
-  })
-
-  it("returns false when grandchild is busy (recursive)", async () => {
-    // #given
-    spyOn(console, "log").mockImplementation(() => {})
-    const ctx = createMockContext({
-      childrenBySession: {
-        "test-session": [{ id: "child-1" }],
-        "child-1": [{ id: "grandchild-1" }],
-        "grandchild-1": [],
-      },
-      statuses: {
-        "child-1": { type: "idle" },
-        "grandchild-1": { type: "busy" },
-      },
-    })
-    const { checkCompletionConditions } = await import("./completion")
-
-    // #when
-    const result = await checkCompletionConditions(ctx)
-
-    // #then
-    expect(result).toBe(false)
-  })
-
-  it("returns true when all descendants idle (recursive)", async () => {
-    // #given
-    spyOn(console, "log").mockImplementation(() => {})
-    const ctx = createMockContext({
-      childrenBySession: {
-        "test-session": [{ id: "child-1" }],
-        "child-1": [{ id: "grandchild-1" }],
-        "grandchild-1": [{ id: "great-grandchild-1" }],
-        "great-grandchild-1": [],
-      },
-      statuses: {
-        "child-1": { type: "idle" },
-        "grandchild-1": { type: "idle" },
-        "great-grandchild-1": { type: "idle" },
-      },
-    })
-    const { checkCompletionConditions } = await import("./completion")
-
-    // #when
-    const result = await checkCompletionConditions(ctx)
-
-    // #then
-    expect(result).toBe(true)
-  })
-})

package/oh-my-opencode/src/cli/run/completion.ts

@@ -1,79 +0,0 @@
-import pc from "picocolors"
-import type { RunContext, Todo, ChildSession, SessionStatus } from "./types"
-
-export async function checkCompletionConditions(ctx: RunContext): Promise<boolean> {
-  try {
-    if (!await areAllTodosComplete(ctx)) {
-      return false
-    }
-
-    if (!await areAllChildrenIdle(ctx)) {
-      return false
-    }
-
-    return true
-  } catch (err) {
-    console.error(pc.red(`[completion] API error: ${err}`))
-    return false
-  }
-}
-
-async function areAllTodosComplete(ctx: RunContext): Promise<boolean> {
-  const todosRes = await ctx.client.session.todo({ path: { id: ctx.sessionID } })
-  const todos = (todosRes.data ?? []) as Todo[]
-
-  const incompleteTodos = todos.filter(
-    (t) => t.status !== "completed" && t.status !== "cancelled"
-  )
-
-  if (incompleteTodos.length > 0) {
-    console.log(pc.dim(`  Waiting: ${incompleteTodos.length} todos remaining`))
-    return false
-  }
-
-  return true
-}
-
-async function areAllChildrenIdle(ctx: RunContext): Promise<boolean> {
-  const allStatuses = await fetchAllStatuses(ctx)
-  return areAllDescendantsIdle(ctx, ctx.sessionID, allStatuses)
-}
-
-async function fetchAllStatuses(
-  ctx: RunContext
-): Promise<Record<string, SessionStatus>> {
-  const statusRes = await ctx.client.session.status()
-  return (statusRes.data ?? {}) as Record<string, SessionStatus>
-}
-
-async function areAllDescendantsIdle(
-  ctx: RunContext,
-  sessionID: string,
-  allStatuses: Record<string, SessionStatus>
-): Promise<boolean> {
-  const childrenRes = await ctx.client.session.children({
-    path: { id: sessionID },
-  })
-  const children = (childrenRes.data ?? []) as ChildSession[]
-
-  for (const child of children) {
-    const status = allStatuses[child.id]
-    if (status && status.type !== "idle") {
-      console.log(
-        pc.dim(`  Waiting: session ${child.id.slice(0, 8)}... is ${status.type}`)
-      )
-      return false
-    }
-
-    const descendantsIdle = await areAllDescendantsIdle(
-      ctx,
-      child.id,
-      allStatuses
-    )
-    if (!descendantsIdle) {
-      return false
-    }
-  }
-
-  return true
-}

package/oh-my-opencode/src/cli/run/events.test.ts

@@ -1,155 +0,0 @@
-import { describe, it, expect } from "bun:test"
-import { createEventState, serializeError, type EventState } from "./events"
-import type { RunContext, EventPayload } from "./types"
-
-const createMockContext = (sessionID: string = "test-session"): RunContext => ({
-  client: {} as RunContext["client"],
-  sessionID,
-  directory: "/test",
-  abortController: new AbortController(),
-})
-
-async function* toAsyncIterable<T>(items: T[]): AsyncIterable<T> {
-  for (const item of items) {
-    yield item
-  }
-}
-
-describe("serializeError", () => {
-  it("returns 'Unknown error' for null/undefined", () => {
-    // #given / #when / #then
-    expect(serializeError(null)).toBe("Unknown error")
-    expect(serializeError(undefined)).toBe("Unknown error")
-  })
-
-  it("returns message from Error instance", () => {
-    // #given
-    const error = new Error("Something went wrong")
-
-    // #when / #then
-    expect(serializeError(error)).toBe("Something went wrong")
-  })
-
-  it("returns string as-is", () => {
-    // #given / #when / #then
-    expect(serializeError("Direct error message")).toBe("Direct error message")
-  })
-
-  it("extracts message from plain object", () => {
-    // #given
-    const errorObj = { message: "Object error message", code: "ERR_001" }
-
-    // #when / #then
-    expect(serializeError(errorObj)).toBe("Object error message")
-  })
-
-  it("extracts message from nested error object", () => {
-    // #given
-    const errorObj = { error: { message: "Nested error message" } }
-
-    // #when / #then
-    expect(serializeError(errorObj)).toBe("Nested error message")
-  })
-
-  it("extracts message from data.message path", () => {
-    // #given
-    const errorObj = { data: { message: "Data error message" } }
-
-    // #when / #then
-    expect(serializeError(errorObj)).toBe("Data error message")
-  })
-
-  it("JSON stringifies object without message property", () => {
-    // #given
-    const errorObj = { code: "ERR_001", status: 500 }
-
-    // #when
-    const result = serializeError(errorObj)
-
-    // #then
-    expect(result).toContain("ERR_001")
-    expect(result).toContain("500")
-  })
-})
-
-describe("createEventState", () => {
-  it("creates initial state with correct defaults", () => {
-    // #given / #when
-    const state = createEventState()
-
-    // #then
-    expect(state.mainSessionIdle).toBe(false)
-    expect(state.lastOutput).toBe("")
-    expect(state.lastPartText).toBe("")
-    expect(state.currentTool).toBe(null)
-  })
-})
-
-describe("event handling", () => {
-  it("session.idle sets mainSessionIdle to true for matching session", async () => {
-    // #given
-    const ctx = createMockContext("my-session")
-    const state = createEventState()
-
-    const payload: EventPayload = {
-      type: "session.idle",
-      properties: { sessionID: "my-session" },
-    }
-
-    const events = toAsyncIterable([payload])
-    const { processEvents } = await import("./events")
-
-    // #when
-    await processEvents(ctx, events, state)
-
-    // #then
-    expect(state.mainSessionIdle).toBe(true)
-  })
-
-  it("session.idle does not affect state for different session", async () => {
-    // #given
-    const ctx = createMockContext("my-session")
-    const state = createEventState()
-
-    const payload: EventPayload = {
-      type: "session.idle",
-      properties: { sessionID: "other-session" },
-    }
-
-    const events = toAsyncIterable([payload])
-    const { processEvents } = await import("./events")
-
-    // #when
-    await processEvents(ctx, events, state)
-
-    // #then
-    expect(state.mainSessionIdle).toBe(false)
-  })
-
-  it("session.status with busy type sets mainSessionIdle to false", async () => {
-    // #given
-    const ctx = createMockContext("my-session")
-    const state: EventState = {
-      mainSessionIdle: true,
-      mainSessionError: false,
-      lastError: null,
-      lastOutput: "",
-      lastPartText: "",
-      currentTool: null,
-    }
-
-    const payload: EventPayload = {
-      type: "session.status",
-      properties: { sessionID: "my-session", status: { type: "busy" } },
-    }
-
-    const events = toAsyncIterable([payload])
-    const { processEvents } = await import("./events")
-
-    // #when
-    await processEvents(ctx, events, state)
-
-    // #then
-    expect(state.mainSessionIdle).toBe(false)
-  })
-})