oh-my-opencode-kikokikok 2.13.0

package/dist/features/builtin-skills/test/types.d.ts

@@ -0,0 +1,231 @@
+export type TestSubcommand = "run" | "generate" | "coverage" | "matrix";
+export type Language = "typescript" | "javascript" | "python" | "go" | "rust" | "java" | "kotlin" | "csharp";
+export type TestFramework = "jest" | "vitest" | "mocha" | "playwright" | "cypress" | "pytest" | "unittest" | "hypothesis" | "go-test" | "testify" | "ginkgo" | "cargo-test" | "proptest" | "junit" | "testng" | "mockito" | "spock" | "xunit" | "nunit" | "mstest";
+export interface RunInput {
+    language?: Language;
+    framework?: TestFramework;
+    pattern?: string;
+    file?: string;
+    directory?: string;
+    watch?: boolean;
+    coverage?: boolean;
+    updateSnapshots?: boolean;
+    bail?: boolean;
+    grep?: string;
+    timeout?: number;
+    reporter?: "default" | "verbose" | "json" | "junit" | "tap";
+    parallel?: boolean;
+    tags?: string[];
+}
+export interface RunResult {
+    language: Language;
+    framework: TestFramework;
+    total: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    duration: number;
+    coverage?: CoverageResult;
+    failures: TestFailure[];
+    suites: TestSuite[];
+}
+export interface TestSuite {
+    name: string;
+    file: string;
+    tests: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    duration: number;
+}
+export interface TestFailure {
+    name: string;
+    file: string;
+    line: number;
+    message: string;
+    expected?: string;
+    actual?: string;
+    stack?: string;
+}
+export interface GenerateInput {
+    file: string;
+    language?: Language;
+    type: "unit" | "integration" | "e2e" | "property" | "snapshot" | "benchmark";
+    framework?: TestFramework;
+    functions?: string[];
+    coverage?: boolean;
+    mocks?: boolean;
+    fixtures?: boolean;
+}
+export interface GenerateResult {
+    testFile: string;
+    language: Language;
+    framework: TestFramework;
+    tests: GeneratedTest[];
+    mocks: GeneratedMock[];
+    fixtures: GeneratedFixture[];
+    imports: string[];
+}
+export interface GeneratedTest {
+    name: string;
+    description: string;
+    type: "unit" | "integration" | "e2e" | "property" | "benchmark";
+    code: string;
+}
+export interface GeneratedMock {
+    name: string;
+    target: string;
+    language: Language;
+    code: string;
+}
+export interface GeneratedFixture {
+    name: string;
+    type: "setup" | "teardown" | "data";
+    scope: "test" | "suite" | "module" | "session";
+    code: string;
+}
+export interface CoverageInput {
+    language?: Language;
+    directory?: string;
+    threshold?: CoverageThreshold;
+    include?: string[];
+    exclude?: string[];
+    reporter?: ("text" | "html" | "lcov" | "json" | "cobertura" | "jacoco")[];
+}
+export interface CoverageResult {
+    language: Language;
+    tool: string;
+    lines: CoverageMetric;
+    statements: CoverageMetric;
+    functions: CoverageMetric;
+    branches: CoverageMetric;
+    files: FileCoverage[];
+    uncovered: UncoveredCode[];
+}
+export interface CoverageMetric {
+    total: number;
+    covered: number;
+    percentage: number;
+    threshold?: number;
+    passing: boolean;
+}
+export interface CoverageThreshold {
+    lines?: number;
+    statements?: number;
+    functions?: number;
+    branches?: number;
+}
+export interface FileCoverage {
+    file: string;
+    lines: number;
+    covered: number;
+    percentage: number;
+    uncoveredLines: number[];
+}
+export interface UncoveredCode {
+    file: string;
+    startLine: number;
+    endLine: number;
+    type: "function" | "branch" | "statement";
+    code: string;
+}
+export interface MatrixInput {
+    parameters: MatrixParameter[];
+    constraints?: MatrixConstraint[];
+    algorithm?: "pict" | "allpairs" | "exhaustive";
+    coverage?: number;
+    outputFormat?: "json" | "csv" | "yaml" | "code";
+    language?: Language;
+}
+export interface MatrixParameter {
+    name: string;
+    values: string[];
+    weight?: number;
+}
+export interface MatrixConstraint {
+    if: Record<string, string>;
+    then?: Record<string, string>;
+    else?: Record<string, string>;
+}
+export interface MatrixResult {
+    combinations: MatrixCombination[];
+    totalPossible: number;
+    generated: number;
+    coverage: number;
+    parameters: string[];
+    code?: string;
+}
+export interface MatrixCombination {
+    id: number;
+    values: Record<string, string>;
+    priority?: "high" | "medium" | "low";
+}
+export interface E2EInput {
+    url?: string;
+    scenario: string;
+    browser?: "chromium" | "firefox" | "webkit";
+    headless?: boolean;
+    screenshots?: boolean;
+    video?: boolean;
+    trace?: boolean;
+    language?: Language;
+}
+export interface E2EResult {
+    passed: boolean;
+    duration: number;
+    steps: E2EStep[];
+    screenshots?: string[];
+    video?: string;
+    trace?: string;
+    errors: string[];
+}
+export interface E2EStep {
+    action: string;
+    selector?: string;
+    value?: string;
+    duration: number;
+    passed: boolean;
+    screenshot?: string;
+    error?: string;
+}
+export interface BenchmarkInput {
+    file: string;
+    language?: Language;
+    functions?: string[];
+    iterations?: number;
+    warmup?: number;
+    outputFormat?: "text" | "json" | "markdown";
+}
+export interface BenchmarkResult {
+    benchmarks: Benchmark[];
+    environment: BenchmarkEnvironment;
+}
+export interface Benchmark {
+    name: string;
+    iterations: number;
+    meanTime: number;
+    stdDev: number;
+    minTime: number;
+    maxTime: number;
+    opsPerSecond: number;
+    memoryUsage?: number;
+}
+export interface BenchmarkEnvironment {
+    os: string;
+    arch: string;
+    cpu: string;
+    memory: string;
+    runtime: string;
+    version: string;
+}
+export interface TestConfig {
+    defaultLanguage?: Language;
+    frameworks?: Partial<Record<Language, TestFramework>>;
+    coverageThreshold?: CoverageThreshold;
+    testDirectory?: string;
+    testPatterns?: Partial<Record<Language, string>>;
+    timeout?: number;
+    parallel?: boolean;
+}
+export declare const LANGUAGE_FRAMEWORKS: Record<Language, TestFramework[]>;
+export declare const LANGUAGE_COVERAGE_TOOLS: Record<Language, string[]>;

package/dist/features/builtin-skills/types.d.ts

@@ -0,0 +1,15 @@
+import type { SkillMcpConfig } from "../skill-mcp-manager/types";
+export interface BuiltinSkill {
+    name: string;
+    description: string;
+    template: string;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, unknown>;
+    allowedTools?: string[];
+    agent?: string;
+    model?: string;
+    subtask?: boolean;
+    argumentHint?: string;
+    mcpConfig?: SkillMcpConfig;
+}

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

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./loader";

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

@@ -0,0 +1,3 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+export declare function loadUserAgents(): Record<string, AgentConfig>;
+export declare function loadProjectAgents(): Record<string, AgentConfig>;

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

@@ -0,0 +1,14 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+export type AgentScope = "user" | "project";
+export interface AgentFrontmatter {
+    name?: string;
+    description?: string;
+    model?: string;
+    tools?: string;
+}
+export interface LoadedAgent {
+    name: string;
+    path: string;
+    config: AgentConfig;
+    scope: AgentScope;
+}

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

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./loader";

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

@@ -0,0 +1,5 @@
+import type { CommandDefinition } from "./types";
+export declare function loadUserCommands(): Record<string, CommandDefinition>;
+export declare function loadProjectCommands(): Record<string, CommandDefinition>;
+export declare function loadOpencodeGlobalCommands(): Record<string, CommandDefinition>;
+export declare function loadOpencodeProjectCommands(): Record<string, CommandDefinition>;

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,35 @@
+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>;
+    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-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,4 @@
+export declare const subagentSessions: Set<string>;
+export declare let mainSessionID: string | undefined;
+export declare function setMainSession(id: string | undefined): void;
+export declare function getMainSessionID(): string | undefined;

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 } from "./injector";
+export type { StoredMessage } from "./injector";
+export type { MessageMeta, OriginalMessageContext, TextPart } from "./types";
+export { MESSAGE_STORAGE } from "./constants";

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

@@ -0,0 +1,11 @@
+import type { OriginalMessageContext } from "./types";
+export interface StoredMessage {
+    agent?: string;
+    model?: {
+        providerID?: string;
+        modelID?: string;
+    };
+    tools?: Record<string, boolean>;
+}
+export declare function findNearestMessageWithFields(messageDir: string): StoredMessage | null;
+export declare function injectHookMessage(sessionID: string, hookContent: string, originalMessage: OriginalMessageContext): boolean;

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

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