@heidi-dang/oh-my-opencode 3.10.0

package/dist/cli/init/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * oh-my-opencode init command
+ *
+ * Writes the Heidi performance default config to the global oh-my-opencode config path.
+ * Safe by default — does nothing if the file already exists unless --force is passed.
+ *
+ * Config path:
+ *   Linux/macOS: ~/.config/opencode/oh-my-opencode.json
+ *   Windows:     %APPDATA%\opencode\oh-my-opencode.json
+ *
+ * Precedence (highest → lowest):
+ *   1. Project config: .opencode/oh-my-opencode.json[c]
+ *   2. Global config:  ~/.config/opencode/oh-my-opencode.json  ← this file
+ *   3. Plugin defaults
+ */
+export interface InitOptions {
+    force: boolean;
+}
+export declare function initCommand(options: InitOptions): Promise<number>;

package/dist/cli/install-validators.d.ts

@@ -0,0 +1,32 @@
+import type { BooleanArg, ClaudeSubscription, DetectedConfig, InstallArgs, InstallConfig } from "./types";
+export declare const SYMBOLS: {
+    check: string;
+    cross: string;
+    arrow: string;
+    bullet: string;
+    info: string;
+    warn: string;
+    star: string;
+};
+export declare function formatConfigSummary(config: InstallConfig): string;
+export declare function printHeader(isUpdate: boolean): void;
+export declare function printStep(step: number, total: number, message: string): void;
+export declare function printSuccess(message: string): void;
+export declare function printError(message: string): void;
+export declare function printInfo(message: string): void;
+export declare function printWarning(message: string): void;
+export declare function printBox(content: string, title?: string): void;
+export declare function validateNonTuiArgs(args: InstallArgs): {
+    valid: boolean;
+    errors: string[];
+};
+export declare function argsToConfig(args: InstallArgs): InstallConfig;
+export declare function detectedToInitialValues(detected: DetectedConfig): {
+    claude: ClaudeSubscription;
+    openai: BooleanArg;
+    gemini: BooleanArg;
+    copilot: BooleanArg;
+    opencodeZen: BooleanArg;
+    zaiCodingPlan: BooleanArg;
+    kimiForCoding: BooleanArg;
+};

package/dist/cli/install.d.ts

@@ -0,0 +1,2 @@
+import type { InstallArgs } from "./types";
+export declare function install(args: InstallArgs): Promise<number>;

package/dist/cli/mcp-oauth/index.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "commander";
+import { login } from "./login";
+import { logout } from "./logout";
+import { status } from "./status";
+export declare function createMcpOAuthCommand(): Command;
+export { login, logout, status };

package/dist/cli/mcp-oauth/login.d.ts

@@ -0,0 +1,6 @@
+export interface LoginOptions {
+    serverUrl?: string;
+    clientId?: string;
+    scopes?: string[];
+}
+export declare function login(serverName: string, options: LoginOptions): Promise<number>;

package/dist/cli/mcp-oauth/logout.d.ts

@@ -0,0 +1,4 @@
+export interface LogoutOptions {
+    serverUrl?: string;
+}
+export declare function logout(serverName: string, options?: LogoutOptions): Promise<number>;

package/dist/cli/mcp-oauth/status.d.ts

@@ -0,0 +1 @@
+export declare function status(serverName: string | undefined): Promise<number>;

package/dist/cli/model-fallback-requirements.d.ts

@@ -0,0 +1,3 @@
+import type { ModelRequirement } from "../shared/model-requirements";
+export declare const CLI_AGENT_MODEL_REQUIREMENTS: Record<string, ModelRequirement>;
+export declare const CLI_CATEGORY_MODEL_REQUIREMENTS: Record<string, ModelRequirement>;

package/dist/cli/model-fallback-types.d.ts

@@ -0,0 +1,26 @@
+export interface ProviderAvailability {
+    native: {
+        claude: boolean;
+        openai: boolean;
+        gemini: boolean;
+    };
+    opencodeZen: boolean;
+    copilot: boolean;
+    zai: boolean;
+    kimiForCoding: boolean;
+    isMaxPlan: boolean;
+}
+export interface AgentConfig {
+    model: string;
+    variant?: string;
+}
+export interface CategoryConfig {
+    model: string;
+    variant?: string;
+}
+export interface GeneratedOmoConfig {
+    $schema: string;
+    agents?: Record<string, AgentConfig>;
+    categories?: Record<string, CategoryConfig>;
+    [key: string]: unknown;
+}

package/dist/cli/model-fallback.d.ts

@@ -0,0 +1,5 @@
+import type { InstallConfig } from "./types";
+import type { GeneratedOmoConfig } from "./model-fallback-types";
+export type { GeneratedOmoConfig } from "./model-fallback-types";
+export declare function generateModelConfig(config: InstallConfig): GeneratedOmoConfig;
+export declare function shouldShowChatGPTOnlyWarning(config: InstallConfig): boolean;

package/dist/cli/provider-availability.d.ts

@@ -0,0 +1,4 @@
+import type { InstallConfig } from "./types";
+import type { ProviderAvailability } from "./model-fallback-types";
+export declare function toProviderAvailability(config: InstallConfig): ProviderAvailability;
+export declare function isProviderAvailable(provider: string, availability: ProviderAvailability): boolean;

package/dist/cli/provider-model-id-transform.d.ts

@@ -0,0 +1 @@
+export { transformModelForProvider } from "../shared/provider-model-id-transform";

package/dist/cli/run/agent-profile-colors.d.ts

@@ -0,0 +1,2 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+export declare function loadAgentProfileColors(client: OpencodeClient): Promise<Record<string, string>>;

package/dist/cli/run/agent-resolver.d.ts

@@ -0,0 +1,5 @@
+import type { RunOptions } from "./types";
+import type { OhMyOpenCodeConfig } from "../../config";
+type EnvVars = Record<string, string | undefined>;
+export declare const resolveRunAgent: (options: RunOptions, pluginConfig: OhMyOpenCodeConfig, env?: EnvVars) => string;
+export {};

package/dist/cli/run/completion.d.ts

@@ -0,0 +1,2 @@
+import type { RunContext } from "./types";
+export declare function checkCompletionConditions(ctx: RunContext): Promise<boolean>;

package/dist/cli/run/continuation-state.d.ts

@@ -0,0 +1,9 @@
+export interface ContinuationState {
+    hasActiveBoulder: boolean;
+    hasActiveRalphLoop: boolean;
+    hasHookMarker: boolean;
+    hasTodoHookMarker: boolean;
+    hasActiveHookMarker: boolean;
+    activeHookMarkerReason: string | null;
+}
+export declare function getContinuationState(directory: string, sessionID: string): ContinuationState;

package/dist/cli/run/display-chars.d.ts

@@ -0,0 +1,5 @@
+export declare const displayChars: {
+    readonly treeEnd: "`-" | "└─";
+    readonly treeIndent: "   ";
+    readonly treeJoin: "   " | "      ";
+};

package/dist/cli/run/event-formatting.d.ts

@@ -0,0 +1,3 @@
+import type { RunContext, EventPayload } from "./types";
+export declare function serializeError(error: unknown): string;
+export declare function logEventVerbose(ctx: RunContext, payload: EventPayload): void;

package/dist/cli/run/event-handlers.d.ts

@@ -0,0 +1,11 @@
+import type { RunContext, EventPayload } from "./types";
+import type { EventState } from "./event-state";
+export declare function handleSessionIdle(ctx: RunContext, payload: EventPayload, state: EventState): void;
+export declare function handleSessionStatus(ctx: RunContext, payload: EventPayload, state: EventState): void;
+export declare function handleSessionError(ctx: RunContext, payload: EventPayload, state: EventState): void;
+export declare function handleMessagePartUpdated(ctx: RunContext, payload: EventPayload, state: EventState): void;
+export declare function handleMessagePartDelta(ctx: RunContext, payload: EventPayload, state: EventState): void;
+export declare function handleMessageUpdated(ctx: RunContext, payload: EventPayload, state: EventState): void;
+export declare function handleToolExecute(ctx: RunContext, payload: EventPayload, state: EventState): void;
+export declare function handleToolResult(ctx: RunContext, payload: EventPayload, state: EventState): void;
+export declare function handleTuiToast(_ctx: RunContext, payload: EventPayload, state: EventState): void;

package/dist/cli/run/event-state.d.ts

@@ -0,0 +1,49 @@
+export interface EventState {
+    mainSessionIdle: boolean;
+    mainSessionError: boolean;
+    lastError: string | null;
+    lastOutput: string;
+    lastPartText: string;
+    currentTool: string | null;
+    /** Set to true when the main session has produced meaningful work (text, tool call, or tool result) */
+    hasReceivedMeaningfulWork: boolean;
+    /** Timestamp of the last received event (for watchdog detection) */
+    lastEventTimestamp: number;
+    /** Count of assistant messages for the main session */
+    messageCount: number;
+    /** Current agent name from the latest assistant message */
+    currentAgent: string | null;
+    /** Current model ID from the latest assistant message */
+    currentModel: string | null;
+    /** Current model variant from the latest assistant message */
+    currentVariant: string | null;
+    /** Current message role (user/assistant) — used to filter user messages from display */
+    currentMessageRole: string | null;
+    /** Agent profile colors keyed by display name */
+    agentColorsByName: Record<string, string>;
+    /** Part type registry keyed by partID (text, reasoning, tool, ...) */
+    partTypesById: Record<string, string>;
+    /** Whether a THINK block is currently open in output */
+    inThinkBlock: boolean;
+    /** Tracks streamed reasoning text to avoid duplicates */
+    lastReasoningText: string;
+    /** Whether compact thinking line already printed for current reasoning block */
+    hasPrintedThinkingLine: boolean;
+    /** Last rendered thinking line width (for in-place padding updates) */
+    lastThinkingLineWidth: number;
+    /** Message role lookup by message ID to filter user parts */
+    messageRoleById: Record<string, string>;
+    /** Last rendered thinking summary (to avoid duplicate re-render) */
+    lastThinkingSummary: string;
+    /** Whether text stream is currently at line start (for padding) */
+    textAtLineStart: boolean;
+    /** Whether reasoning stream is currently at line start (for padding) */
+    thinkingAtLineStart: boolean;
+    /** Current assistant message ID — prevents counter resets on repeated message.updated for same message */
+    currentMessageId: string | null;
+    /** Assistant message start timestamp by message ID */
+    messageStartedAtById: Record<string, number>;
+    /** Prevent duplicate completion metadata lines per message */
+    completionMetaPrintedByMessageId: Record<string, boolean>;
+}
+export declare function createEventState(): EventState;

package/dist/cli/run/event-stream-processor.d.ts

@@ -0,0 +1,3 @@
+import type { RunContext } from "./types";
+import type { EventState } from "./event-state";
+export declare function processEvents(ctx: RunContext, stream: AsyncIterable<unknown>, state: EventState): Promise<void>;

package/dist/cli/run/events.d.ts

@@ -0,0 +1,4 @@
+export type { EventState } from "./event-state";
+export { createEventState } from "./event-state";
+export { serializeError } from "./event-formatting";
+export { processEvents } from "./event-stream-processor";

package/dist/cli/run/index.d.ts

@@ -0,0 +1,9 @@
+export { run } from "./runner";
+export { resolveRunAgent } from "./agent-resolver";
+export { createServerConnection } from "./server-connection";
+export { resolveSession } from "./session-resolver";
+export { createJsonOutputManager } from "./json-output";
+export { executeOnCompleteHook } from "./on-complete-hook";
+export { createEventState, processEvents, serializeError } from "./events";
+export type { EventState } from "./events";
+export type { RunOptions, RunContext, RunResult, ServerConnection } from "./types";

package/dist/cli/run/json-output.d.ts

@@ -0,0 +1,12 @@
+import type { RunResult } from "./types";
+export interface JsonOutputManager {
+    redirectToStderr: () => void;
+    restore: () => void;
+    emitResult: (result: RunResult) => void;
+}
+interface JsonOutputManagerOptions {
+    stdout?: NodeJS.WriteStream;
+    stderr?: NodeJS.WriteStream;
+}
+export declare function createJsonOutputManager(options?: JsonOutputManagerOptions): JsonOutputManager;
+export {};

package/dist/cli/run/on-complete-hook.d.ts

@@ -0,0 +1,7 @@
+export declare function executeOnCompleteHook(options: {
+    command: string;
+    sessionId: string;
+    exitCode: number;
+    durationMs: number;
+    messageCount: number;
+}): Promise<void>;

package/dist/cli/run/opencode-binary-resolver.d.ts

@@ -0,0 +1,5 @@
+export declare function collectCandidateBinaryPaths(pathEnv: string | undefined, which?: (command: string) => string | null | undefined, platform?: NodeJS.Platform): string[];
+export declare function canExecuteBinary(binaryPath: string): Promise<boolean>;
+export declare function findWorkingOpencodeBinary(pathEnv?: string | undefined, probe?: (binaryPath: string) => Promise<boolean>, which?: (command: string) => string | null | undefined, platform?: NodeJS.Platform): Promise<string | null>;
+export declare function buildPathWithBinaryFirst(pathEnv: string | undefined, binaryPath: string): string;
+export declare function withWorkingOpencodePath<T>(startServer: () => Promise<T>, finder?: (pathEnv: string | undefined) => Promise<string | null>): Promise<T>;

package/dist/cli/run/output-renderer.d.ts

@@ -0,0 +1,7 @@
+export declare function renderAgentHeader(agent: string | null, model: string | null, variant: string | null, agentColorsByName: Record<string, string>): void;
+export declare function openThinkBlock(): void;
+export declare function closeThinkBlock(): void;
+export declare function writePaddedText(text: string, atLineStart: boolean): {
+    output: string;
+    atLineStart: boolean;
+};

package/dist/cli/run/poll-for-completion.d.ts

@@ -0,0 +1,10 @@
+import type { RunContext } from "./types";
+import type { EventState } from "./events";
+export interface PollOptions {
+    pollIntervalMs?: number;
+    requiredConsecutive?: number;
+    minStabilizationMs?: number;
+    eventWatchdogMs?: number;
+    secondaryMeaningfulWorkTimeoutMs?: number;
+}
+export declare function pollForCompletion(ctx: RunContext, eventState: EventState, abortController: AbortController, options?: PollOptions): Promise<number>;

package/dist/cli/run/runner.d.ts

@@ -0,0 +1,5 @@
+import type { RunOptions } from "./types";
+import { resolveRunAgent } from "./agent-resolver";
+export { resolveRunAgent };
+export declare function waitForEventProcessorShutdown(eventProcessor: Promise<void>, timeoutMs?: number): Promise<void>;
+export declare function run(options: RunOptions): Promise<number>;

package/dist/cli/run/server-connection.d.ts

@@ -0,0 +1,6 @@
+import type { ServerConnection } from "./types";
+export declare function createServerConnection(options: {
+    port?: number;
+    attach?: string;
+    signal: AbortSignal;
+}): Promise<ServerConnection>;

package/dist/cli/run/session-resolver.d.ts

@@ -0,0 +1,6 @@
+import type { OpencodeClient } from "./types";
+export declare function resolveSession(options: {
+    client: OpencodeClient;
+    sessionId?: string;
+    directory: string;
+}): Promise<string>;

package/dist/cli/run/stdin-suppression.d.ts

@@ -0,0 +1,12 @@
+type StdinLike = {
+    isTTY?: boolean;
+    isRaw?: boolean;
+    setRawMode?: (mode: boolean) => void;
+    isPaused?: () => boolean;
+    resume: () => void;
+    pause: () => void;
+    on: (event: "data", listener: (chunk: string | Uint8Array) => void) => void;
+    removeListener: (event: "data", listener: (chunk: string | Uint8Array) => void) => void;
+};
+export declare function suppressRunInput(stdin?: StdinLike, onInterrupt?: () => void): () => void;
+export {};

package/dist/cli/run/timestamp-output.d.ts

@@ -0,0 +1,5 @@
+export declare function createTimestampTransformer(now?: () => Date): (chunk: string) => string;
+export declare function createTimestampedStdoutController(stdout?: NodeJS.WriteStream): {
+    enable: () => void;
+    restore: () => void;
+};

package/dist/cli/run/tool-input-preview.d.ts

@@ -0,0 +1,6 @@
+export interface ToolHeader {
+    icon: string;
+    title: string;
+    description?: string;
+}
+export declare function formatToolHeader(toolName: string, input: Record<string, unknown>): ToolHeader;

package/dist/cli/run/types.d.ts

@@ -0,0 +1,131 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+export type { OpencodeClient };
+export interface RunOptions {
+    message: string;
+    agent?: string;
+    timestamp?: boolean;
+    verbose?: boolean;
+    directory?: string;
+    port?: number;
+    attach?: string;
+    onComplete?: string;
+    json?: boolean;
+    sessionId?: string;
+}
+export interface ServerConnection {
+    client: OpencodeClient;
+    cleanup: () => void;
+}
+export interface RunResult {
+    sessionId: string;
+    success: boolean;
+    durationMs: number;
+    messageCount: number;
+    summary: string;
+}
+export interface RunContext {
+    client: OpencodeClient;
+    sessionID: string;
+    directory: string;
+    abortController: AbortController;
+    verbose?: boolean;
+}
+export interface Todo {
+    id?: string;
+    content: string;
+    status: string;
+    priority: string;
+}
+export interface SessionStatus {
+    type: "idle" | "busy" | "retry";
+}
+export interface ChildSession {
+    id: string;
+}
+export interface EventPayload {
+    type: string;
+    properties?: Record<string, unknown>;
+}
+export interface SessionIdleProps {
+    sessionID?: string;
+    sessionId?: string;
+}
+export interface SessionStatusProps {
+    sessionID?: string;
+    sessionId?: string;
+    status?: {
+        type?: string;
+    };
+}
+export interface MessageUpdatedProps {
+    info?: {
+        id?: string;
+        sessionID?: string;
+        sessionId?: string;
+        role?: string;
+        modelID?: string;
+        providerID?: string;
+        agent?: string;
+        variant?: string;
+    };
+}
+export interface MessagePartUpdatedProps {
+    /** @deprecated Legacy structure — current OpenCode puts sessionID inside part */
+    info?: {
+        sessionID?: string;
+        sessionId?: string;
+        role?: string;
+    };
+    part?: {
+        id?: string;
+        sessionID?: string;
+        sessionId?: string;
+        messageID?: string;
+        type?: string;
+        text?: string;
+        /** Tool name (for part.type === "tool") */
+        tool?: string;
+        /** Tool state (for part.type === "tool") */
+        state?: {
+            status?: string;
+            input?: Record<string, unknown>;
+            output?: string;
+        };
+        name?: string;
+        input?: unknown;
+        time?: {
+            start?: number;
+            end?: number;
+        };
+    };
+}
+export interface MessagePartDeltaProps {
+    sessionID?: string;
+    sessionId?: string;
+    messageID?: string;
+    partID?: string;
+    field?: string;
+    delta?: string;
+}
+export interface ToolExecuteProps {
+    sessionID?: string;
+    sessionId?: string;
+    name?: string;
+    input?: Record<string, unknown>;
+}
+export interface ToolResultProps {
+    sessionID?: string;
+    sessionId?: string;
+    name?: string;
+    output?: string;
+}
+export interface SessionErrorProps {
+    sessionID?: string;
+    sessionId?: string;
+    error?: unknown;
+}
+export interface TuiToastShowProps {
+    title?: string;
+    message?: string;
+    variant?: "info" | "success" | "warning" | "error";
+}

package/dist/cli/tui-install-prompts.d.ts

@@ -0,0 +1,2 @@
+import type { DetectedConfig, InstallConfig } from "./types";
+export declare function promptInstallConfig(detected: DetectedConfig): Promise<InstallConfig | null>;

package/dist/cli/tui-installer.d.ts

@@ -0,0 +1,2 @@
+import type { InstallArgs } from "./types";
+export declare function runTuiInstaller(args: InstallArgs, version: string): Promise<number>;

package/dist/cli/types.d.ts

@@ -0,0 +1,39 @@
+export type ClaudeSubscription = "no" | "yes" | "max20";
+export type BooleanArg = "no" | "yes";
+export interface InstallArgs {
+    tui: boolean;
+    claude?: ClaudeSubscription;
+    openai?: BooleanArg;
+    gemini?: BooleanArg;
+    copilot?: BooleanArg;
+    opencodeZen?: BooleanArg;
+    zaiCodingPlan?: BooleanArg;
+    kimiForCoding?: BooleanArg;
+    skipAuth?: boolean;
+}
+export interface InstallConfig {
+    hasClaude: boolean;
+    isMax20: boolean;
+    hasOpenAI: boolean;
+    hasGemini: boolean;
+    hasCopilot: boolean;
+    hasOpencodeZen: boolean;
+    hasZaiCodingPlan: boolean;
+    hasKimiForCoding: boolean;
+}
+export interface ConfigMergeResult {
+    success: boolean;
+    configPath: string;
+    error?: string;
+}
+export interface DetectedConfig {
+    isInstalled: boolean;
+    hasClaude: boolean;
+    isMax20: boolean;
+    hasOpenAI: boolean;
+    hasGemini: boolean;
+    hasCopilot: boolean;
+    hasOpencodeZen: boolean;
+    hasZaiCodingPlan: boolean;
+    hasKimiForCoding: boolean;
+}

package/dist/config/index.d.ts

@@ -0,0 +1,2 @@
+export { OhMyOpenCodeConfigSchema, } from "./schema";
+export type { OhMyOpenCodeConfig, AgentOverrideConfig, AgentOverrides, McpName, AgentName, HookName, BuiltinCommandName, SisyphusAgentConfig, ExperimentalConfig, DynamicContextPruningConfig, RalphLoopConfig, TmuxConfig, TmuxLayout, SisyphusConfig, SisyphusTasksConfig, RuntimeFallbackConfig, FallbackModels, } from "./schema";

package/dist/config/schema/agent-names.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+export declare const BuiltinAgentNameSchema: z.ZodEnum<{
+    sisyphus: "sisyphus";
+    hephaestus: "hephaestus";
+    oracle: "oracle";
+    librarian: "librarian";
+    explore: "explore";
+    "multimodal-looker": "multimodal-looker";
+    metis: "metis";
+    momus: "momus";
+    atlas: "atlas";
+    prometheus: "prometheus";
+}>;
+export declare const BuiltinSkillNameSchema: z.ZodEnum<{
+    playwright: "playwright";
+    "agent-browser": "agent-browser";
+    "dev-browser": "dev-browser";
+    "frontend-ui-ux": "frontend-ui-ux";
+    "git-master": "git-master";
+}>;
+export declare const OverridableAgentNameSchema: z.ZodEnum<{
+    sisyphus: "sisyphus";
+    hephaestus: "hephaestus";
+    oracle: "oracle";
+    librarian: "librarian";
+    explore: "explore";
+    "multimodal-looker": "multimodal-looker";
+    metis: "metis";
+    momus: "momus";
+    atlas: "atlas";
+    build: "build";
+    plan: "plan";
+    prometheus: "prometheus";
+    "sisyphus-junior": "sisyphus-junior";
+    "OpenCode-Builder": "OpenCode-Builder";
+}>;
+export declare const AgentNameSchema: z.ZodEnum<{
+    sisyphus: "sisyphus";
+    hephaestus: "hephaestus";
+    oracle: "oracle";
+    librarian: "librarian";
+    explore: "explore";
+    "multimodal-looker": "multimodal-looker";
+    metis: "metis";
+    momus: "momus";
+    atlas: "atlas";
+    prometheus: "prometheus";
+}>;
+export type AgentName = z.infer<typeof AgentNameSchema>;
+export type BuiltinSkillName = z.infer<typeof BuiltinSkillNameSchema>;