opencode-repos 0.2.0 → 0.3.0

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

@@ -0,0 +1,246 @@
+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

@@ -0,0 +1,170 @@
+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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,155 @@
+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)
+  })
+})