oh-my-opencode-gpt-slim 0.0.3

package/dist/features/claude-code-plugin-loader/loader.d.ts

@@ -0,0 +1,20 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { CommandDefinition } from "../claude-code-command-loader/types";
+import type { McpServerConfig } from "../claude-code-mcp-loader/types";
+import type { HooksConfig, LoadedPlugin, PluginLoadError, PluginLoaderOptions } from "./types";
+export { discoverInstalledPlugins } from "./discovery";
+export { loadPluginCommands } from "./command-loader";
+export { loadPluginSkillsAsCommands } from "./skill-loader";
+export { loadPluginAgents } from "./agent-loader";
+export { loadPluginMcpServers } from "./mcp-server-loader";
+export { loadPluginHooksConfigs } from "./hook-loader";
+export interface PluginComponentsResult {
+    commands: Record<string, CommandDefinition>;
+    skills: Record<string, CommandDefinition>;
+    agents: Record<string, AgentConfig>;
+    mcpServers: Record<string, McpServerConfig>;
+    hooksConfigs: HooksConfig[];
+    plugins: LoadedPlugin[];
+    errors: PluginLoadError[];
+}
+export declare function loadAllPluginComponents(options?: PluginLoaderOptions): Promise<PluginComponentsResult>;

package/dist/features/claude-code-plugin-loader/mcp-server-loader.d.ts

@@ -0,0 +1,3 @@
+import type { McpServerConfig } from "../claude-code-mcp-loader/types";
+import type { LoadedPlugin } from "./types";
+export declare function loadPluginMcpServers(plugins: LoadedPlugin[]): Promise<Record<string, McpServerConfig>>;

package/dist/features/claude-code-plugin-loader/plugin-path-resolver.d.ts

@@ -0,0 +1,2 @@
+export declare function resolvePluginPath(path: string, pluginRoot: string): string;
+export declare function resolvePluginPaths<T>(obj: T, pluginRoot: string): T;

package/dist/features/claude-code-plugin-loader/skill-loader.d.ts

@@ -0,0 +1,3 @@
+import type { CommandDefinition } from "../claude-code-command-loader/types";
+import type { LoadedPlugin } from "./types";
+export declare function loadPluginSkillsAsCommands(plugins: LoadedPlugin[]): Record<string, CommandDefinition>;

package/dist/features/claude-code-plugin-loader/types.d.ts

@@ -0,0 +1,196 @@
+/**
+ * Claude Code Plugin Types
+ *
+ * Type definitions for Claude Code plugin system compatibility.
+ * Based on https://code.claude.com/docs/en/plugins-reference
+ */
+export type PluginScope = "user" | "project" | "local" | "managed";
+/**
+ * Plugin installation entry in installed_plugins.json
+ */
+export interface PluginInstallation {
+    scope: PluginScope;
+    installPath: string;
+    version: string;
+    installedAt: string;
+    lastUpdated: string;
+    gitCommitSha?: string;
+    isLocal?: boolean;
+}
+/**
+ * Installed plugins database v1 (legacy)
+ * plugins stored as direct objects
+ */
+export interface InstalledPluginsDatabaseV1 {
+    version: 1;
+    plugins: Record<string, PluginInstallation>;
+}
+/**
+ * Installed plugins database v2 (current)
+ * plugins stored as arrays
+ */
+export interface InstalledPluginsDatabaseV2 {
+    version: 2;
+    plugins: Record<string, PluginInstallation[]>;
+}
+/**
+ * Installed plugins database structure
+ * Located at ~/.claude/plugins/installed_plugins.json
+ */
+export type InstalledPluginsDatabase = InstalledPluginsDatabaseV1 | InstalledPluginsDatabaseV2;
+/**
+ * Plugin author information
+ */
+export interface PluginAuthor {
+    name?: string;
+    email?: string;
+    url?: string;
+}
+/**
+ * Plugin manifest (plugin.json)
+ * Located at <plugin_root>/.claude-plugin/plugin.json
+ */
+export interface PluginManifest {
+    name: string;
+    version?: string;
+    description?: string;
+    author?: PluginAuthor;
+    homepage?: string;
+    repository?: string;
+    license?: string;
+    keywords?: string[];
+    commands?: string | string[];
+    agents?: string | string[];
+    skills?: string | string[];
+    hooks?: string | HooksConfig;
+    mcpServers?: string | McpServersConfig;
+    lspServers?: string | LspServersConfig;
+    outputStyles?: string | string[];
+}
+/**
+ * Hooks configuration
+ */
+export type HookEntry = {
+    type: "command";
+    command?: string;
+} | {
+    type: "prompt";
+    prompt?: string;
+} | {
+    type: "agent";
+    agent?: string;
+} | {
+    type: "http";
+    url: string;
+    headers?: Record<string, string>;
+    allowedEnvVars?: string[];
+    timeout?: number;
+};
+export interface HookMatcher {
+    matcher?: string;
+    hooks: HookEntry[];
+}
+export interface HooksConfig {
+    hooks?: {
+        PreToolUse?: HookMatcher[];
+        PostToolUse?: HookMatcher[];
+        PostToolUseFailure?: HookMatcher[];
+        PermissionRequest?: HookMatcher[];
+        UserPromptSubmit?: HookMatcher[];
+        Notification?: HookMatcher[];
+        Stop?: HookMatcher[];
+        SubagentStart?: HookMatcher[];
+        SubagentStop?: HookMatcher[];
+        SessionStart?: HookMatcher[];
+        SessionEnd?: HookMatcher[];
+        PreCompact?: HookMatcher[];
+    };
+}
+/**
+ * MCP servers configuration in plugin
+ */
+export interface PluginMcpServer {
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    url?: string;
+    type?: "stdio" | "http" | "sse";
+    disabled?: boolean;
+}
+export interface McpServersConfig {
+    mcpServers?: Record<string, PluginMcpServer>;
+}
+/**
+ * LSP server configuration
+ */
+export interface LspServerConfig {
+    command: string;
+    args?: string[];
+    extensionToLanguage: Record<string, string>;
+    transport?: "stdio" | "socket";
+    env?: Record<string, string>;
+    initializationOptions?: Record<string, unknown>;
+    settings?: Record<string, unknown>;
+    workspaceFolder?: string;
+    startupTimeout?: number;
+    shutdownTimeout?: number;
+    restartOnCrash?: boolean;
+    maxRestarts?: number;
+    loggingConfig?: {
+        args?: string[];
+        env?: Record<string, string>;
+    };
+}
+export interface LspServersConfig {
+    [language: string]: LspServerConfig;
+}
+/**
+ * Loaded plugin with all resolved components
+ */
+export interface LoadedPlugin {
+    name: string;
+    version: string;
+    scope: PluginScope;
+    installPath: string;
+    manifest?: PluginManifest;
+    pluginKey: string;
+    commandsDir?: string;
+    agentsDir?: string;
+    skillsDir?: string;
+    hooksPath?: string;
+    mcpPath?: string;
+    lspPath?: string;
+}
+/**
+ * Plugin load result with all components
+ */
+export interface PluginLoadResult {
+    plugins: LoadedPlugin[];
+    errors: PluginLoadError[];
+}
+export interface PluginLoadError {
+    pluginKey: string;
+    installPath: string;
+    error: string;
+}
+/**
+ * Claude settings from ~/.claude/settings.json
+ */
+export interface ClaudeSettings {
+    enabledPlugins?: Record<string, boolean>;
+    [key: string]: unknown;
+}
+/**
+ * Plugin loader options
+ */
+export interface PluginLoaderOptions {
+    /**
+     * Override enabled plugins from oh-my-opencode config.
+     * Key format: "pluginName@marketplace" (e.g., "shell-scripting@claude-code-workflows")
+     * Value: true = enabled, false = disabled
+     *
+     * This takes precedence over ~/.claude/settings.json enabledPlugins
+     */
+    enabledPluginsOverride?: Record<string, boolean>;
+}

package/dist/features/claude-code-session-state/index.d.ts

@@ -0,0 +1 @@
+export * from "./state";

package/dist/features/claude-code-session-state/state.d.ts

@@ -0,0 +1,10 @@
+export declare const subagentSessions: Set<string>;
+export declare const syncSubagentSessions: Set<string>;
+export declare function setMainSession(id: string | undefined): void;
+export declare function getMainSessionID(): string | undefined;
+/** @internal For testing only */
+export declare function _resetForTesting(): void;
+export declare function setSessionAgent(sessionID: string, agent: string): void;
+export declare function updateSessionAgent(sessionID: string, agent: string): void;
+export declare function getSessionAgent(sessionID: string): string | undefined;
+export declare function clearSessionAgent(sessionID: string): void;

package/dist/features/claude-tasks/session-storage.d.ts

@@ -0,0 +1,9 @@
+import type { OhMyOpenCodeConfig } from "../../config/schema";
+export declare function getSessionTaskDir(config: Partial<OhMyOpenCodeConfig>, sessionID: string): string;
+export declare function listSessionTaskFiles(config: Partial<OhMyOpenCodeConfig>, sessionID: string): string[];
+export declare function listAllSessionDirs(config: Partial<OhMyOpenCodeConfig>): string[];
+export interface TaskLocation {
+    path: string;
+    sessionID: string;
+}
+export declare function findTaskAcrossSessions(config: Partial<OhMyOpenCodeConfig>, taskId: string): TaskLocation | null;

package/dist/features/claude-tasks/storage.d.ts

@@ -0,0 +1,14 @@
+import type { z } from "zod";
+import type { OhMyOpenCodeConfig } from "../../config/schema";
+export declare function getTaskDir(config?: Partial<OhMyOpenCodeConfig>): string;
+export declare function sanitizePathSegment(value: string): string;
+export declare function resolveTaskListId(config?: Partial<OhMyOpenCodeConfig>): string;
+export declare function ensureDir(dirPath: string): void;
+export declare function readJsonSafe<T>(filePath: string, schema: z.ZodType<T>): T | null;
+export declare function writeJsonAtomic(filePath: string, data: unknown): void;
+export declare function generateTaskId(): string;
+export declare function listTaskFiles(config?: Partial<OhMyOpenCodeConfig>): string[];
+export declare function acquireLock(dirPath: string): {
+    acquired: boolean;
+    release: () => void;
+};

package/dist/features/claude-tasks/types.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const TaskStatusSchema: z.ZodEnum<{
+    deleted: "deleted";
+    pending: "pending";
+    completed: "completed";
+    in_progress: "in_progress";
+}>;
+export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+export declare const TaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    subject: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodEnum<{
+        deleted: "deleted";
+        pending: "pending";
+        completed: "completed";
+        in_progress: "in_progress";
+    }>;
+    activeForm: z.ZodOptional<z.ZodString>;
+    blocks: z.ZodArray<z.ZodString>;
+    blockedBy: z.ZodArray<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type Task = z.infer<typeof TaskSchema>;

package/dist/features/context-injector/collector.d.ts

@@ -0,0 +1,11 @@
+import type { PendingContext, RegisterContextOptions } from "./types";
+export declare class ContextCollector {
+    private sessions;
+    register(sessionID: string, options: RegisterContextOptions): void;
+    getPending(sessionID: string): PendingContext;
+    consume(sessionID: string): PendingContext;
+    clear(sessionID: string): void;
+    hasPending(sessionID: string): boolean;
+    private sortEntries;
+}
+export declare const contextCollector: ContextCollector;

package/dist/features/context-injector/index.d.ts

@@ -0,0 +1,3 @@
+export { ContextCollector, contextCollector } from "./collector";
+export { createContextInjectorMessagesTransformHook, } from "./injector";
+export type { ContextSourceType, ContextPriority, ContextEntry, RegisterContextOptions, PendingContext, MessageContext, OutputParts, InjectionStrategy, } from "./types";

package/dist/features/context-injector/injector.d.ts

@@ -0,0 +1,39 @@
+import type { ContextCollector } from "./collector";
+import type { Message, Part } from "@opencode-ai/sdk";
+interface OutputPart {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+interface InjectionResult {
+    injected: boolean;
+    contextLength: number;
+}
+export declare function injectPendingContext(collector: ContextCollector, sessionID: string, parts: OutputPart[]): InjectionResult;
+interface ChatMessageInput {
+    sessionID: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    messageID?: string;
+}
+interface ChatMessageOutput {
+    message: Record<string, unknown>;
+    parts: OutputPart[];
+}
+export declare function createContextInjectorHook(collector: ContextCollector): {
+    "chat.message": (input: ChatMessageInput, output: ChatMessageOutput) => Promise<void>;
+};
+interface MessageWithParts {
+    info: Message;
+    parts: Part[];
+}
+type MessagesTransformHook = {
+    "experimental.chat.messages.transform"?: (input: Record<string, never>, output: {
+        messages: MessageWithParts[];
+    }) => Promise<void>;
+};
+export declare function createContextInjectorMessagesTransformHook(collector: ContextCollector): MessagesTransformHook;
+export {};

package/dist/features/context-injector/types.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Source identifier for context injection
+ * Each source registers context that will be merged and injected together
+ */
+export type ContextSourceType = "keyword-detector" | "rules-injector" | "directory-agents" | "directory-readme" | "custom";
+/**
+ * Priority levels for context ordering
+ * Higher priority contexts appear first in the merged output
+ */
+export type ContextPriority = "critical" | "high" | "normal" | "low";
+/**
+ * A single context entry registered by a source
+ */
+export interface ContextEntry {
+    /** Unique identifier for this entry within the source */
+    id: string;
+    /** The source that registered this context */
+    source: ContextSourceType;
+    /** The actual context content to inject */
+    content: string;
+    /** Priority for ordering (default: normal) */
+    priority: ContextPriority;
+    /** Monotonic order when registered */
+    registrationOrder: number;
+    /** Optional metadata for debugging/logging */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options for registering context
+ */
+export interface RegisterContextOptions {
+    /** Unique ID for this context entry (used for deduplication) */
+    id: string;
+    /** Source identifier */
+    source: ContextSourceType;
+    /** The content to inject */
+    content: string;
+    /** Priority for ordering (default: normal) */
+    priority?: ContextPriority;
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Result of getting pending context for a session
+ */
+export interface PendingContext {
+    /** Merged context string, ready for injection */
+    merged: string;
+    /** Individual entries that were merged */
+    entries: ContextEntry[];
+    /** Whether there's any content to inject */
+    hasContent: boolean;
+}
+/**
+ * Message context from the original user message
+ * Used when injecting to match the message format
+ */
+export interface MessageContext {
+    agent?: string;
+    model?: {
+        providerID?: string;
+        modelID?: string;
+    };
+    path?: {
+        cwd?: string;
+        root?: string;
+    };
+    tools?: Record<string, boolean>;
+}
+/**
+ * Output parts from chat.message hook
+ */
+export interface OutputParts {
+    parts: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+}
+/**
+ * Injection strategy
+ */
+export type InjectionStrategy = "prepend-parts" | "storage" | "auto";

package/dist/features/hook-message-injector/constants.d.ts

@@ -0,0 +1 @@
+export { OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE } from "../../shared";

package/dist/features/hook-message-injector/index.d.ts

@@ -0,0 +1,4 @@
+export { injectHookMessage, findNearestMessageWithFields, findFirstMessageWithAgent, findNearestMessageWithFieldsFromSDK, findFirstMessageWithAgentFromSDK, resolveMessageContext, } from "./injector";
+export type { StoredMessage } from "./injector";
+export type { MessageMeta, OriginalMessageContext, TextPart, ToolPermission } from "./types";
+export { MESSAGE_STORAGE } from "./constants";

package/dist/features/hook-message-injector/injector.d.ts

@@ -0,0 +1,69 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { OriginalMessageContext, ToolPermission } from "./types";
+export interface StoredMessage {
+    agent?: string;
+    model?: {
+        providerID?: string;
+        modelID?: string;
+        variant?: string;
+    };
+    tools?: Record<string, ToolPermission>;
+}
+type OpencodeClient = PluginInput["client"];
+/**
+ * Finds the nearest message with required fields using SDK (for beta/SQLite backend).
+ * Uses client.session.messages() to fetch message data from SQLite.
+ */
+export declare function findNearestMessageWithFieldsFromSDK(client: OpencodeClient, sessionID: string): Promise<StoredMessage | null>;
+/**
+ * Finds the FIRST (oldest) message with agent field using SDK (for beta/SQLite backend).
+ */
+export declare function findFirstMessageWithAgentFromSDK(client: OpencodeClient, sessionID: string): Promise<string | null>;
+/**
+ * Finds the nearest message with required fields (agent, model.providerID, model.modelID).
+ * Reads from JSON files - for stable (JSON) backend.
+ *
+ * **Version-gated behavior:**
+ * - On beta (SQLite backend): Returns null immediately (no JSON storage)
+ * - On stable (JSON backend): Reads from JSON files in messageDir
+ *
+ * @deprecated Use findNearestMessageWithFieldsFromSDK for beta/SQLite backend
+ */
+export declare function findNearestMessageWithFields(messageDir: string): StoredMessage | null;
+/**
+ * Finds the FIRST (oldest) message in the session with agent field.
+ * Reads from JSON files - for stable (JSON) backend.
+ *
+ * **Version-gated behavior:**
+ * - On beta (SQLite backend): Returns null immediately (no JSON storage)
+ * - On stable (JSON backend): Reads from JSON files in messageDir
+ *
+ * @deprecated Use findFirstMessageWithAgentFromSDK for beta/SQLite backend
+ */
+export declare function findFirstMessageWithAgent(messageDir: string): string | null;
+export declare function generateMessageId(): string;
+export declare function generatePartId(): string;
+/**
+ * Injects a hook message into the session storage.
+ *
+ * **Version-gated behavior:**
+ * - On beta (SQLite backend): Logs warning and skips injection (writes are invisible to SQLite)
+ * - On stable (JSON backend): Writes message and part JSON files
+ *
+ * Features degraded on beta:
+ * - Hook message injection (e.g., continuation prompts, context injection) won't persist
+ * - Atlas hook's injected messages won't be visible in SQLite backend
+ * - Todo continuation enforcer's injected prompts won't persist
+ * - Ralph loop's continuation prompts won't persist
+ *
+ * @param sessionID - Target session ID
+ * @param hookContent - Content to inject
+ * @param originalMessage - Context from the original message
+ * @returns true if injection succeeded, false otherwise
+ */
+export declare function injectHookMessage(sessionID: string, hookContent: string, originalMessage: OriginalMessageContext): boolean;
+export declare function resolveMessageContext(sessionID: string, client: OpencodeClient, messageDir: string | null): Promise<{
+    prevMessage: StoredMessage | null;
+    firstMessageAgent: string | null;
+}>;
+export {};

package/dist/features/hook-message-injector/types.d.ts

@@ -0,0 +1,46 @@
+export type ToolPermission = boolean | "allow" | "deny" | "ask";
+export interface MessageMeta {
+    id: string;
+    sessionID: string;
+    role: "user" | "assistant";
+    time: {
+        created: number;
+        completed?: number;
+    };
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+        variant?: string;
+    };
+    path?: {
+        cwd: string;
+        root: string;
+    };
+    tools?: Record<string, ToolPermission>;
+}
+export interface OriginalMessageContext {
+    agent?: string;
+    model?: {
+        providerID?: string;
+        modelID?: string;
+        variant?: string;
+    };
+    path?: {
+        cwd?: string;
+        root?: string;
+    };
+    tools?: Record<string, ToolPermission>;
+}
+export interface TextPart {
+    id: string;
+    type: "text";
+    text: string;
+    synthetic: boolean;
+    time: {
+        start: number;
+        end: number;
+    };
+    messageID: string;
+    sessionID: string;
+}

package/dist/features/mcp-oauth/callback-server.d.ts

@@ -0,0 +1,11 @@
+export type OAuthCallbackResult = {
+    code: string;
+    state: string;
+};
+export type CallbackServer = {
+    port: number;
+    waitForCallback: () => Promise<OAuthCallbackResult>;
+    close: () => void;
+};
+export declare function findAvailablePort(startPort?: number): Promise<number>;
+export declare function startCallbackServer(startPort?: number): Promise<CallbackServer>;

package/dist/features/mcp-oauth/dcr.d.ts

@@ -0,0 +1,34 @@
+export type ClientRegistrationRequest = {
+    redirect_uris: string[];
+    client_name: string;
+    grant_types: ["authorization_code", "refresh_token"];
+    response_types: ["code"];
+    token_endpoint_auth_method: "none" | "client_secret_post";
+};
+export type ClientCredentials = {
+    clientId: string;
+    clientSecret?: string;
+};
+export type ClientRegistrationStorage = {
+    getClientRegistration: (serverIdentifier: string) => ClientCredentials | null;
+    setClientRegistration: (serverIdentifier: string, credentials: ClientCredentials) => void;
+};
+export type DynamicClientRegistrationOptions = {
+    registrationEndpoint?: string | null;
+    serverIdentifier?: string;
+    clientName: string;
+    redirectUris: string[];
+    tokenEndpointAuthMethod: "none" | "client_secret_post";
+    clientId?: string | null;
+    storage: ClientRegistrationStorage;
+    fetch?: DcrFetch;
+};
+export type DcrFetch = (input: string, init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}) => Promise<{
+    ok: boolean;
+    json: () => Promise<unknown>;
+}>;
+export declare function getOrRegisterClient(options: DynamicClientRegistrationOptions): Promise<ClientCredentials | null>;

package/dist/features/mcp-oauth/discovery.d.ts

@@ -0,0 +1,8 @@
+export interface OAuthServerMetadata {
+    authorizationEndpoint: string;
+    tokenEndpoint: string;
+    registrationEndpoint?: string;
+    resource: string;
+}
+export declare function discoverOAuthServerMetadata(resource: string): Promise<OAuthServerMetadata>;
+export declare function resetDiscoveryCache(): void;

package/dist/features/mcp-oauth/oauth-authorization-flow.d.ts

@@ -0,0 +1,26 @@
+export type OAuthCallbackResult = {
+    code: string;
+    state: string;
+};
+export declare function generateCodeVerifier(): string;
+export declare function generateCodeChallenge(verifier: string): string;
+export declare function buildAuthorizationUrl(authorizationEndpoint: string, options: {
+    clientId: string;
+    redirectUri: string;
+    codeChallenge: string;
+    state: string;
+    scopes?: string[];
+    resource?: string;
+}): string;
+export declare function startCallbackServer(port: number): Promise<OAuthCallbackResult>;
+export declare function runAuthorizationCodeRedirect(options: {
+    authorizationEndpoint: string;
+    callbackPort: number;
+    clientId: string;
+    redirectUri: string;
+    scopes?: string[];
+    resource?: string;
+}): Promise<{
+    code: string;
+    verifier: string;
+}>;