oh-my-musacode 0.0.1

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-musacode 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 MUSACODE_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,18 @@
+import type { OriginalMessageContext, ToolPermission } from "./types";
+export interface StoredMessage {
+    agent?: string;
+    model?: {
+        providerID?: string;
+        modelID?: 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 MusaCode'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,44 @@
+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;
+    };
+    path?: {
+        cwd: string;
+        root: string;
+    };
+    tools?: Record<string, ToolPermission>;
+}
+export interface OriginalMessageContext {
+    agent?: string;
+    model?: {
+        providerID?: string;
+        modelID?: 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/musacode-skill-loader/async-loader.d.ts

@@ -0,0 +1,6 @@
+import type { SkillScope, LoadedSkill } from "./types";
+import type { SkillMcpConfig } from "../skill-mcp-manager/types";
+export declare function mapWithConcurrency<T, R>(items: T[], mapper: (item: T) => Promise<R>, concurrency: number): Promise<R[]>;
+export declare function loadMcpJsonFromDirAsync(skillDir: string): Promise<SkillMcpConfig | undefined>;
+export declare function loadSkillFromPathAsync(skillPath: string, resolvedPath: string, defaultName: string, scope: SkillScope): Promise<LoadedSkill | null>;
+export declare function discoverSkillsInDirAsync(skillsDir: string): Promise<LoadedSkill[]>;

package/dist/features/musacode-skill-loader/async-loader.test.d.ts

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

package/dist/features/musacode-skill-loader/blocking.d.ts

@@ -0,0 +1,2 @@
+import type { LoadedSkill, SkillScope } from "./types";
+export declare function discoverAllSkillsBlocking(dirs: string[], scopes: SkillScope[]): LoadedSkill[];

package/dist/features/musacode-skill-loader/blocking.test.d.ts

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

package/dist/features/musacode-skill-loader/discover-worker.d.ts

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

package/dist/features/musacode-skill-loader/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./loader";
+export * from "./merger";
+export * from "./skill-content";

package/dist/features/musacode-skill-loader/loader.d.ts

@@ -0,0 +1,16 @@
+import type { CommandDefinition } from "../claude-code-command-loader/types";
+import type { LoadedSkill } from "./types";
+export declare function loadUserSkills(): Promise<Record<string, CommandDefinition>>;
+export declare function loadProjectSkills(): Promise<Record<string, CommandDefinition>>;
+export declare function loadMusacodeGlobalSkills(): Promise<Record<string, CommandDefinition>>;
+export declare function loadMusacodeProjectSkills(): Promise<Record<string, CommandDefinition>>;
+export interface DiscoverSkillsOptions {
+    includeClaudeCodePaths?: boolean;
+}
+export declare function discoverAllSkills(): Promise<LoadedSkill[]>;
+export declare function discoverSkills(options?: DiscoverSkillsOptions): Promise<LoadedSkill[]>;
+export declare function getSkillByName(name: string, options?: DiscoverSkillsOptions): Promise<LoadedSkill | undefined>;
+export declare function discoverUserClaudeSkills(): Promise<LoadedSkill[]>;
+export declare function discoverProjectClaudeSkills(): Promise<LoadedSkill[]>;
+export declare function discoverMusacodeGlobalSkills(): Promise<LoadedSkill[]>;
+export declare function discoverMusacodeProjectSkills(): Promise<LoadedSkill[]>;

package/dist/features/musacode-skill-loader/loader.test.d.ts

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

package/dist/features/musacode-skill-loader/merger.d.ts

@@ -0,0 +1,7 @@
+import type { LoadedSkill } from "./types";
+import type { SkillsConfig } from "../../config/schema";
+import type { BuiltinSkill } from "../builtin-skills/types";
+export interface MergeSkillsOptions {
+    configDir?: string;
+}
+export declare function mergeSkills(builtinSkills: BuiltinSkill[], config: SkillsConfig | undefined, userClaudeSkills: LoadedSkill[], userMusacodeSkills: LoadedSkill[], projectClaudeSkills: LoadedSkill[], projectMusacodeSkills: LoadedSkill[], options?: MergeSkillsOptions): LoadedSkill[];

package/dist/features/musacode-skill-loader/skill-content.d.ts

@@ -0,0 +1,20 @@
+import type { LoadedSkill } from "./types";
+import type { GitMasterConfig } from "../../config/schema";
+export interface SkillResolutionOptions {
+    gitMasterConfig?: GitMasterConfig;
+}
+declare function clearSkillCache(): void;
+declare function getAllSkills(): Promise<LoadedSkill[]>;
+declare function extractSkillTemplate(skill: LoadedSkill): Promise<string>;
+export { clearSkillCache, getAllSkills, extractSkillTemplate };
+export declare function injectGitMasterConfig(template: string, config?: GitMasterConfig): string;
+export declare function resolveSkillContent(skillName: string, options?: SkillResolutionOptions): string | null;
+export declare function resolveMultipleSkills(skillNames: string[], options?: SkillResolutionOptions): {
+    resolved: Map<string, string>;
+    notFound: string[];
+};
+export declare function resolveSkillContentAsync(skillName: string, options?: SkillResolutionOptions): Promise<string | null>;
+export declare function resolveMultipleSkillsAsync(skillNames: string[], options?: SkillResolutionOptions): Promise<{
+    resolved: Map<string, string>;
+    notFound: string[];
+}>;

package/dist/features/musacode-skill-loader/skill-content.test.d.ts

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

package/dist/features/musacode-skill-loader/types.d.ts

@@ -0,0 +1,34 @@
+import type { CommandDefinition } from "../claude-code-command-loader/types";
+import type { SkillMcpConfig } from "../skill-mcp-manager/types";
+export type SkillScope = "builtin" | "config" | "user" | "project" | "musacode" | "musacode-project";
+export interface SkillMetadata {
+    name?: string;
+    description?: string;
+    model?: string;
+    "argument-hint"?: string;
+    agent?: string;
+    subtask?: boolean;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    "allowed-tools"?: string;
+    mcp?: SkillMcpConfig;
+}
+export interface LazyContentLoader {
+    loaded: boolean;
+    content?: string;
+    load: () => Promise<string>;
+}
+export interface LoadedSkill {
+    name: string;
+    path?: string;
+    resolvedPath?: string;
+    definition: CommandDefinition;
+    scope: SkillScope;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    allowedTools?: string[];
+    mcpConfig?: SkillMcpConfig;
+    lazyContent?: LazyContentLoader;
+}

package/dist/features/skill-mcp-manager/env-cleaner.d.ts

@@ -0,0 +1,2 @@
+export declare const EXCLUDED_ENV_PATTERNS: RegExp[];
+export declare function createCleanMcpEnvironment(customEnv?: Record<string, string>): Record<string, string>;

package/dist/features/skill-mcp-manager/env-cleaner.test.d.ts

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

package/dist/features/skill-mcp-manager/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export { SkillMcpManager } from "./manager";

package/dist/features/skill-mcp-manager/manager.d.ts

@@ -0,0 +1,40 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { Tool, Resource, Prompt } from "@modelcontextprotocol/sdk/types.js";
+import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
+import type { SkillMcpClientInfo, SkillMcpServerContext } from "./types";
+export declare class SkillMcpManager {
+    private clients;
+    private pendingConnections;
+    private cleanupRegistered;
+    private cleanupInterval;
+    private readonly IDLE_TIMEOUT;
+    private getClientKey;
+    private registerProcessCleanup;
+    getOrCreateClient(info: SkillMcpClientInfo, config: ClaudeCodeMcpServer): Promise<Client>;
+    private createClient;
+    /**
+     * Create an HTTP-based MCP client using StreamableHTTPClientTransport.
+     * Supports remote MCP servers with optional authentication headers.
+     */
+    private createHttpClient;
+    /**
+     * Create a stdio-based MCP client using StdioClientTransport.
+     * Spawns a local process and communicates via stdin/stdout.
+     */
+    private createStdioClient;
+    disconnectSession(sessionID: string): Promise<void>;
+    disconnectAll(): Promise<void>;
+    private startCleanupTimer;
+    private stopCleanupTimer;
+    private cleanupIdleClients;
+    listTools(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Tool[]>;
+    listResources(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Resource[]>;
+    listPrompts(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Prompt[]>;
+    callTool(info: SkillMcpClientInfo, context: SkillMcpServerContext, name: string, args: Record<string, unknown>): Promise<unknown>;
+    readResource(info: SkillMcpClientInfo, context: SkillMcpServerContext, uri: string): Promise<unknown>;
+    getPrompt(info: SkillMcpClientInfo, context: SkillMcpServerContext, name: string, args: Record<string, string>): Promise<unknown>;
+    private withOperationRetry;
+    private getOrCreateClientWithRetry;
+    getConnectedServers(): string[];
+    isConnected(info: SkillMcpClientInfo): boolean;
+}

package/dist/features/skill-mcp-manager/manager.test.d.ts

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

package/dist/features/skill-mcp-manager/types.d.ts

@@ -0,0 +1,11 @@
+import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
+export type SkillMcpConfig = Record<string, ClaudeCodeMcpServer>;
+export interface SkillMcpClientInfo {
+    serverName: string;
+    skillName: string;
+    sessionID: string;
+}
+export interface SkillMcpServerContext {
+    config: ClaudeCodeMcpServer;
+    skillName: string;
+}

package/dist/features/task-toast-manager/index.d.ts

@@ -0,0 +1,2 @@
+export { TaskToastManager, getTaskToastManager, initTaskToastManager } from "./manager";
+export type { TrackedTask, TaskStatus, TaskToastOptions, ModelFallbackInfo } from "./types";