oh-my-parallel-agent-opencode 0.1.0 → 0.2.1

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

@@ -0,0 +1,42 @@
+export type CommandScope = "user" | "project" | "opencode" | "opencode-project";
+/**
+ * Handoff definition for command workflows.
+ * Based on speckit's handoff pattern for multi-agent orchestration.
+ * @see https://github.com/github/spec-kit
+ */
+export interface HandoffDefinition {
+    /** Human-readable label for the handoff action */
+    label: string;
+    /** Target agent/command identifier (e.g., "speckit.tasks") */
+    agent: string;
+    /** Pre-filled prompt text for the handoff */
+    prompt: string;
+    /** If true, automatically executes after command completion; if false, shows as suggestion */
+    send?: boolean;
+}
+export interface CommandDefinition {
+    name: string;
+    description?: string;
+    template: string;
+    agent?: string;
+    model?: string;
+    subtask?: boolean;
+    argumentHint?: string;
+    /** Handoff definitions for workflow transitions */
+    handoffs?: HandoffDefinition[];
+}
+export interface CommandFrontmatter {
+    description?: string;
+    "argument-hint"?: string;
+    agent?: string;
+    model?: string;
+    subtask?: boolean;
+    /** Handoff definitions for workflow transitions */
+    handoffs?: HandoffDefinition[];
+}
+export interface LoadedCommand {
+    name: string;
+    path: string;
+    definition: CommandDefinition;
+    scope: CommandScope;
+}

package/dist/features/claude-code-mcp-loader/env-expander.d.ts

@@ -0,0 +1,2 @@
+export declare function expandEnvVars(value: string): string;
+export declare function expandEnvVarsInObject<T>(obj: T): T;

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

@@ -0,0 +1,10 @@
+/**
+ * MCP Configuration Loader
+ *
+ * Loads Claude Code .mcp.json format configurations from multiple scopes
+ * and transforms them to OpenCode SDK format
+ */
+export * from "./types";
+export * from "./loader";
+export * from "./transformer";
+export * from "./env-expander";

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

@@ -0,0 +1,4 @@
+import type { LoadedMcpServer, McpLoadResult } from "./types";
+export declare function getSystemMcpServerNames(): Set<string>;
+export declare function loadMcpConfigs(): Promise<McpLoadResult>;
+export declare function formatLoadedServersForToast(loadedServers: LoadedMcpServer[]): string;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+import type { ClaudeCodeMcpServer, McpServerConfig } from "./types";
+export declare function transformMcpServer(name: string, server: ClaudeCodeMcpServer): McpServerConfig;

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

@@ -0,0 +1,39 @@
+export type McpScope = "user" | "project" | "local";
+export interface ClaudeCodeMcpServer {
+    type?: "http" | "sse" | "stdio";
+    url?: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    headers?: Record<string, string>;
+    oauth?: {
+        clientId?: string;
+        scopes?: string[];
+    };
+    disabled?: boolean;
+}
+export interface ClaudeCodeMcpConfig {
+    mcpServers?: Record<string, ClaudeCodeMcpServer>;
+}
+export interface McpLocalConfig {
+    type: "local";
+    command: string[];
+    environment?: Record<string, string>;
+    enabled?: boolean;
+}
+export interface McpRemoteConfig {
+    type: "remote";
+    url: string;
+    headers?: Record<string, string>;
+    enabled?: boolean;
+}
+export type McpServerConfig = McpLocalConfig | McpRemoteConfig;
+export interface LoadedMcpServer {
+    name: string;
+    scope: McpScope;
+    config: McpServerConfig;
+}
+export interface McpLoadResult {
+    servers: Record<string, McpServerConfig>;
+    loadedServers: LoadedMcpServer[];
+}

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

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./loader";
+export type { PluginLoaderOptions, ClaudeSettings } from "./types";

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 { LoadedPlugin, PluginLoadResult, PluginLoadError, HooksConfig, PluginLoaderOptions } from "./types";
+export declare function discoverInstalledPlugins(options?: PluginLoaderOptions): PluginLoadResult;
+export declare function loadPluginCommands(plugins: LoadedPlugin[]): Record<string, CommandDefinition>;
+export declare function loadPluginSkillsAsCommands(plugins: LoadedPlugin[]): Record<string, CommandDefinition>;
+export declare function loadPluginAgents(plugins: LoadedPlugin[]): Record<string, AgentConfig>;
+export declare function loadPluginMcpServers(plugins: LoadedPlugin[]): Promise<Record<string, McpServerConfig>>;
+export declare function loadPluginHooksConfigs(plugins: LoadedPlugin[]): HooksConfig[];
+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/types.d.ts

@@ -0,0 +1,186 @@
+/**
+ * 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 interface HookEntry {
+    type: "command" | "prompt" | "agent";
+    command?: string;
+    prompt?: string;
+    agent?: string;
+}
+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-parallel-agent-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,9 @@
+export declare const subagentSessions: 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-code-session-state/state.test.d.ts

@@ -0,0 +1 @@
+export {};

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/collector.test.d.ts

@@ -0,0 +1 @@
+export {};

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/injector.test.d.ts

@@ -0,0 +1 @@
+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;
+    /** Timestamp when registered */
+    timestamp: 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,3 @@
+export declare const OPENCODE_STORAGE: string;
+export declare const MESSAGE_STORAGE: string;
+export declare const PART_STORAGE: string;

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

@@ -0,0 +1,4 @@
+export { injectHookMessage, findNearestMessageWithFields, findFirstMessageWithAgent } 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,19 @@
+import type { OriginalMessageContext, ToolPermission } from "./types";
+export interface StoredMessage {
+    agent?: string;
+    model?: {
+        providerID?: string;
+        modelID?: string;
+        variant?: string;
+    };
+    tools?: Record<string, ToolPermission>;
+}
+export declare function findNearestMessageWithFields(messageDir: string): StoredMessage | null;
+/**
+ * Finds the FIRST (oldest) message in the session with agent field.
+ * This is used to get the original agent that started the session,
+ * avoiding issues where newer messages may have a different agent
+ * due to OpenCode's internal agent switching.
+ */
+export declare function findFirstMessageWithAgent(messageDir: string): string | null;
+export declare function injectHookMessage(sessionID: string, hookContent: string, originalMessage: OriginalMessageContext): boolean;

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/callback-server.test.d.ts

@@ -0,0 +1 @@
+export {};

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/dcr.test.d.ts

@@ -0,0 +1 @@
+export {};

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/discovery.test.d.ts

@@ -0,0 +1 @@
+export {};

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

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