@a4hgehad/oh-my-openagent-slim 0.8.4

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/model-key-normalization.d.ts

@@ -0,0 +1 @@
+export declare function buildModelKeyAliases(input: string): string[];

package/dist/cli/paths.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Get the OpenCode plugin config directory.
+ *
+ * Resolution order:
+ * 1. OPENCODE_CONFIG_DIR (custom OpenCode directory)
+ * 2. XDG_CONFIG_HOME/opencode
+ * 3. ~/.config/opencode
+ */
+export declare function getConfigDir(): string;
+export declare function getOpenCodeConfigPaths(): string[];
+export declare function getConfigJson(): string;
+export declare function getConfigJsonc(): string;
+export declare function getLiteConfig(): string;
+export declare function getLiteConfigJsonc(): string;
+export declare function getExistingLiteConfigPath(): string;
+export declare function getExistingConfigPath(): string;
+export declare function ensureConfigDir(): void;
+/**
+ * Ensure the directory for OpenCode's main config file exists.
+ */
+export declare function ensureOpenCodeConfigDir(): void;

package/dist/cli/providers.d.ts

@@ -0,0 +1,104 @@
+import type { InstallConfig } from './types';
+export declare const MODEL_MAPPINGS: {
+    readonly openai: {
+        readonly Ra: {
+            readonly model: "openai/gpt-5.4";
+        };
+        readonly Oracle: {
+            readonly model: "openai/gpt-5.4";
+            readonly variant: "high";
+        };
+        readonly Thoth: {
+            readonly model: "openai/gpt-5.4-mini";
+            readonly variant: "low";
+        };
+        readonly Horus: {
+            readonly model: "openai/gpt-5.4-mini";
+            readonly variant: "low";
+        };
+        readonly Bastet: {
+            readonly model: "openai/gpt-5.4-mini";
+            readonly variant: "medium";
+        };
+        readonly Anubis: {
+            readonly model: "openai/gpt-5.4-mini";
+            readonly variant: "low";
+        };
+    };
+    readonly kimi: {
+        readonly Ra: {
+            readonly model: "kimi-for-coding/k2p5";
+        };
+        readonly Oracle: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "high";
+        };
+        readonly Thoth: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "low";
+        };
+        readonly Horus: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "low";
+        };
+        readonly Bastet: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "medium";
+        };
+        readonly Anubis: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "low";
+        };
+    };
+    readonly copilot: {
+        readonly Ra: {
+            readonly model: "github-copilot/claude-opus-4.6";
+        };
+        readonly Oracle: {
+            readonly model: "github-copilot/claude-opus-4.6";
+            readonly variant: "high";
+        };
+        readonly Thoth: {
+            readonly model: "github-copilot/grok-code-fast-1";
+            readonly variant: "low";
+        };
+        readonly Horus: {
+            readonly model: "github-copilot/grok-code-fast-1";
+            readonly variant: "low";
+        };
+        readonly Bastet: {
+            readonly model: "github-copilot/gemini-3.1-pro-preview";
+            readonly variant: "medium";
+        };
+        readonly Anubis: {
+            readonly model: "github-copilot/claude-sonnet-4.6";
+            readonly variant: "low";
+        };
+    };
+    readonly 'zai-plan': {
+        readonly Ra: {
+            readonly model: "zai-coding-plan/glm-5";
+        };
+        readonly Oracle: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "high";
+        };
+        readonly Thoth: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "low";
+        };
+        readonly Horus: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "low";
+        };
+        readonly Bastet: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "medium";
+        };
+        readonly Anubis: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "low";
+        };
+    };
+};
+export declare function generateLiteConfig(installConfig: InstallConfig): Record<string, unknown>;

package/dist/cli/skills.d.ts

@@ -0,0 +1,52 @@
+/**
+ * A recommended skill to install via `npx skills add`.
+ */
+export interface RecommendedSkill {
+    /** Human-readable name for prompts */
+    name: string;
+    /** GitHub repo URL for `npx skills add` */
+    repo: string;
+    /** Skill name within the repo (--skill flag) */
+    skillName: string;
+    /** List of agents that should auto-allow this skill */
+    allowedAgents: string[];
+    /** Description shown to user during install */
+    description: string;
+    /** Optional commands to run after the skill is added */
+    postInstallCommands?: string[];
+}
+/**
+ * A skill that is managed externally (e.g. user-installed) and needs
+ * permission grants but is NOT installed by this plugin's CLI.
+ */
+export interface PermissionOnlySkill {
+    /** Skill name — must match the name OpenCode uses for permission checks */
+    name: string;
+    /** List of agents that should auto-allow this skill */
+    allowedAgents: string[];
+    /** Human-readable description (for documentation only) */
+    description: string;
+}
+/**
+ * List of recommended skills.
+ * Add new skills here to include them in the installation flow.
+ */
+export declare const RECOMMENDED_SKILLS: RecommendedSkill[];
+/**
+ * Skills managed externally (not installed by this plugin's CLI).
+ * Entries here only affect agent permission grants — nothing is installed.
+ */
+export declare const PERMISSION_ONLY_SKILLS: PermissionOnlySkill[];
+/**
+ * Install a skill using `npx skills add`.
+ * @param skill - The skill to install
+ * @returns True if installation succeeded, false otherwise
+ */
+export declare function installSkill(skill: RecommendedSkill): boolean;
+/**
+ * Get permission presets for a specific agent based on recommended skills.
+ * @param agentName - The name of the agent
+ * @param skillList - Optional explicit list of skills to allow (overrides recommendations)
+ * @returns Permission rules for the skill permission type
+ */
+export declare function getSkillPermissionsForAgent(agentName: string, skillList?: string[]): Record<string, 'allow' | 'ask' | 'deny'>;

package/dist/cli/system.d.ts

@@ -0,0 +1,6 @@
+export declare function resolveOpenCodePath(): string;
+export declare function isOpenCodeInstalled(): Promise<boolean>;
+export declare function isTmuxInstalled(): Promise<boolean>;
+export declare function getOpenCodeVersion(): Promise<string | null>;
+export declare function getOpenCodePath(): string | null;
+export declare function fetchLatestVersion(packageName: string): Promise<string | null>;

package/dist/cli/types.d.ts

@@ -0,0 +1,38 @@
+export type BooleanArg = 'yes' | 'no';
+export interface InstallArgs {
+    tui: boolean;
+    tmux?: BooleanArg;
+    skills?: BooleanArg;
+    dryRun?: boolean;
+    reset?: boolean;
+}
+export interface OpenCodeConfig {
+    plugin?: string[];
+    provider?: Record<string, unknown>;
+    agent?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface InstallConfig {
+    hasTmux: boolean;
+    installSkills: boolean;
+    installCustomSkills: boolean;
+    dryRun?: boolean;
+    reset: boolean;
+}
+export interface ConfigMergeResult {
+    success: boolean;
+    configPath: string;
+    error?: string;
+}
+export interface DetectedConfig {
+    isInstalled: boolean;
+    hasKimi: boolean;
+    hasOpenAI: boolean;
+    hasAnthropic?: boolean;
+    hasCopilot?: boolean;
+    hasZaiPlan?: boolean;
+    hasAntigravity: boolean;
+    hasChutes?: boolean;
+    hasOpencodeZen: boolean;
+    hasTmux: boolean;
+}

package/dist/config/agent-mcps.d.ts

@@ -0,0 +1,15 @@
+import { type AgentName, type PluginConfig } from '.';
+/** Default MCPs per agent - "*" means all MCPs, "!item" excludes specific MCPs */
+export declare const DEFAULT_AGENT_MCPS: Record<AgentName, string[]>;
+/**
+ * Parse a list with wildcard and exclusion syntax.
+ */
+export declare function parseList(items: string[], allAvailable: string[]): string[];
+/**
+ * Get available MCP names from schema and config.
+ */
+export declare function getAvailableMcpNames(config?: PluginConfig): string[];
+/**
+ * Get the MCP list for an agent (from config or defaults).
+ */
+export declare function getAgentMcpList(agentName: string, config?: PluginConfig): string[];

package/dist/config/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const AGENT_ALIASES: Record<string, string>;
+export declare const SUBAGENT_NAMES: readonly ["Horus", "Thoth", "Oracle", "Bastet", "Anubis"];
+export declare const ORCHESTRATOR_NAME: "Ra";
+export declare const ALL_AGENT_NAMES: readonly ["Ra", "Horus", "Thoth", "Oracle", "Bastet", "Anubis"];
+export type AgentName = (typeof ALL_AGENT_NAMES)[number];
+export declare const SUBAGENT_DELEGATION_RULES: Record<AgentName, readonly string[]>;
+export declare const DEFAULT_MODELS: Record<AgentName, string | undefined>;
+export declare const POLL_INTERVAL_MS = 500;
+export declare const POLL_INTERVAL_SLOW_MS = 1000;
+export declare const POLL_INTERVAL_BACKGROUND_MS = 2000;
+export declare const DEFAULT_TIMEOUT_MS: number;
+export declare const MAX_POLL_TIME_MS: number;
+export declare const FALLBACK_FAILOVER_TIMEOUT_MS = 15000;
+export declare const STABLE_POLLS_THRESHOLD = 3;

package/dist/config/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants';
+export { loadAgentPrompt, loadPluginConfig } from './loader';
+export * from './schema';
+export { getAgentOverride } from './utils';

package/dist/config/loader.d.ts

@@ -0,0 +1,31 @@
+import { type PluginConfig } from './schema';
+/**
+ * Load plugin configuration from user and project config files, merging them appropriately.
+ *
+ * Configuration is loaded from two locations:
+ * 1. User config: $OPENCODE_CONFIG_DIR/oh-my-opencode-slim.jsonc or .json,
+ *    or ~/.config/opencode/oh-my-opencode-slim.jsonc or .json (or $XDG_CONFIG_HOME)
+ * 2. Project config: <directory>/.opencode/oh-my-opencode-slim.jsonc or .json
+ *
+ * JSONC format is preferred over JSON (allows comments and trailing commas).
+ * Project config takes precedence over user config. Nested objects (agents, tmux) are
+ * deep-merged, while top-level arrays are replaced entirely by project config.
+ *
+ * @param directory - Project directory to search for .opencode config
+ * @returns Merged plugin configuration (empty object if no configs found)
+ */
+export declare function loadPluginConfig(directory: string): PluginConfig;
+/**
+ * Load custom prompt for an agent from the prompts directory.
+ * Checks for {agent}.md (replaces default) and {agent}_append.md (appends to default).
+ * If preset is provided and safe for paths, it first checks {preset}/ subdirectory,
+ * then falls back to the root prompts directory.
+ *
+ * @param agentName - Name of the agent (e.g., "Ra", "Horus")
+ * @param preset - Optional preset name for preset-scoped prompt lookup
+ * @returns Object with prompt and/or appendPrompt if files exist
+ */
+export declare function loadAgentPrompt(agentName: string, preset?: string): {
+    prompt?: string;
+    appendPrompt?: string;
+};

package/dist/config/schema.d.ts

@@ -0,0 +1,220 @@
+import { z } from 'zod';
+declare const FALLBACK_AGENT_NAMES: readonly ["Ra", "Oracle", "Bastet", "Horus", "Thoth", "Anubis"];
+declare const MANUAL_AGENT_NAMES: readonly ["Ra", "Oracle", "Bastet", "Horus", "Thoth", "Anubis"];
+export declare const ManualAgentPlanSchema: z.ZodObject<{
+    primary: z.ZodString;
+    fallback1: z.ZodString;
+    fallback2: z.ZodString;
+    fallback3: z.ZodString;
+}, z.core.$strip>;
+export declare const ManualPlanSchema: z.ZodObject<{
+    Ra: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    Oracle: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    Bastet: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    Horus: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    Thoth: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    Anubis: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export type ManualAgentName = (typeof MANUAL_AGENT_NAMES)[number];
+export type ManualAgentPlan = z.infer<typeof ManualAgentPlanSchema>;
+export type ManualPlan = z.infer<typeof ManualPlanSchema>;
+export type FallbackAgentName = (typeof FALLBACK_AGENT_NAMES)[number];
+export declare const AgentOverrideConfigSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const TmuxLayoutSchema: z.ZodEnum<{
+    "main-horizontal": "main-horizontal";
+    "main-vertical": "main-vertical";
+    tiled: "tiled";
+    "even-horizontal": "even-horizontal";
+    "even-vertical": "even-vertical";
+}>;
+export type TmuxLayout = z.infer<typeof TmuxLayoutSchema>;
+export declare const TmuxConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    layout: z.ZodDefault<z.ZodEnum<{
+        "main-horizontal": "main-horizontal";
+        "main-vertical": "main-vertical";
+        tiled: "tiled";
+        "even-horizontal": "even-horizontal";
+        "even-vertical": "even-vertical";
+    }>>;
+    main_pane_size: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type TmuxConfig = z.infer<typeof TmuxConfigSchema>;
+export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
+/** Normalized model entry with optional per-model variant. */
+export type ModelEntry = {
+    id: string;
+    variant?: string;
+};
+export declare const PresetSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>;
+export type Preset = z.infer<typeof PresetSchema>;
+export declare const McpNameSchema: z.ZodEnum<{
+    websearch: "websearch";
+    context7: "context7";
+    grep_app: "grep_app";
+}>;
+export type McpName = z.infer<typeof McpNameSchema>;
+export declare const BackgroundTaskConfigSchema: z.ZodObject<{
+    maxConcurrentStarts: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type BackgroundTaskConfig = z.infer<typeof BackgroundTaskConfigSchema>;
+export declare const FailoverConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+    retryDelayMs: z.ZodDefault<z.ZodNumber>;
+    chains: z.ZodDefault<z.ZodObject<{
+        Ra: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        Oracle: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        Bastet: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        Horus: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        Thoth: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        Anubis: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$catchall<z.ZodArray<z.ZodString>>>>;
+}, z.core.$strip>;
+export type FailoverConfig = z.infer<typeof FailoverConfigSchema>;
+export declare const PluginConfigSchema: z.ZodObject<{
+    preset: z.ZodOptional<z.ZodString>;
+    setDefaultAgent: z.ZodOptional<z.ZodBoolean>;
+    scoringEngineVersion: z.ZodOptional<z.ZodEnum<{
+        v1: "v1";
+        "v2-shadow": "v2-shadow";
+        v2: "v2";
+    }>>;
+    balanceProviderUsage: z.ZodOptional<z.ZodBoolean>;
+    manualPlan: z.ZodOptional<z.ZodObject<{
+        Ra: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        Oracle: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        Bastet: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        Horus: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        Thoth: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        Anubis: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strict>>;
+    presets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            variant: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>]>>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>>;
+    agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            variant: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>]>>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    disabled_mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tmux: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        layout: z.ZodDefault<z.ZodEnum<{
+            "main-horizontal": "main-horizontal";
+            "main-vertical": "main-vertical";
+            tiled: "tiled";
+            "even-horizontal": "even-horizontal";
+            "even-vertical": "even-vertical";
+        }>>;
+        main_pane_size: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    background: z.ZodOptional<z.ZodObject<{
+        maxConcurrentStarts: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    fallback: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        retryDelayMs: z.ZodDefault<z.ZodNumber>;
+        chains: z.ZodDefault<z.ZodObject<{
+            Ra: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            Oracle: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            Bastet: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            Horus: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            Thoth: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            Anubis: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$catchall<z.ZodArray<z.ZodString>>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PluginConfig = z.infer<typeof PluginConfigSchema>;
+export type { AgentName } from './constants';

package/dist/config/utils.d.ts

@@ -0,0 +1,10 @@
+import type { AgentOverrideConfig, PluginConfig } from './schema';
+/**
+ * Get agent override config by name, supporting backward-compatible aliases.
+ * Checks both the current name and any legacy alias names.
+ *
+ * @param config - The plugin configuration
+ * @param name - The current agent name
+ * @returns The agent-specific override configuration if found
+ */
+export declare function getAgentOverride(config: PluginConfig | undefined, name: string): AgentOverrideConfig | undefined;

package/dist/hooks/auto-update-checker/cache.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Invalidates the current package by removing its directory and dependency entries.
+ * This forces a clean state before running a fresh install.
+ * @param packageName The name of the package to invalidate.
+ */
+export declare function invalidatePackage(packageName?: string): boolean;

package/dist/hooks/auto-update-checker/checker.d.ts

@@ -0,0 +1,28 @@
+import type { PluginEntryInfo } from './types';
+/**
+ * Extracts the update channel (latest, alpha, beta, etc.) from a version string.
+ * @param version The version or tag to analyze.
+ * @returns The channel name.
+ */
+export declare function extractChannel(version: string | null): string;
+/**
+ * Resolves the version of the plugin when running in local development mode.
+ */
+export declare function getLocalDevVersion(directory: string): string | null;
+/**
+ * Searches across all config locations to find the current installation entry for this plugin.
+ */
+export declare function findPluginEntry(directory: string): PluginEntryInfo | null;
+/**
+ * Resolves the installed version from node_modules, with memoization.
+ */
+export declare function getCachedVersion(): string | null;
+/**
+ * Safely updates a pinned version in the configuration file.
+ * It attempts to replace the exact plugin string to preserve comments and formatting.
+ */
+export declare function updatePinnedVersion(configPath: string, oldEntry: string, newVersion: string): boolean;
+/**
+ * Fetches the latest version for a specific channel from the NPM registry.
+ */
+export declare function getLatestVersion(channel?: string): Promise<string | null>;

package/dist/hooks/auto-update-checker/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const PACKAGE_NAME = "oh-my-opencode-slim";
+export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/oh-my-opencode-slim/dist-tags";
+export declare const NPM_FETCH_TIMEOUT = 5000;
+/** The directory used by OpenCode to cache node_modules for plugins. */
+export declare const CACHE_DIR: string;
+/** Path to this plugin's package.json within the OpenCode cache. */
+export declare const INSTALLED_PACKAGE_JSON: string;
+/** Primary OpenCode configuration file path (standard JSON). */
+export declare const USER_OPENCODE_CONFIG: string;
+/** Alternative OpenCode configuration file path (JSON with Comments). */
+export declare const USER_OPENCODE_CONFIG_JSONC: string;

package/dist/hooks/auto-update-checker/index.d.ts

@@ -0,0 +1,17 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { AutoUpdateCheckerOptions } from './types';
+/**
+ * Creates an OpenCode hook that checks for plugin updates when a new session is created.
+ * @param ctx The plugin input context.
+ * @param options Configuration options for the update checker.
+ * @returns A hook object for the session.created event.
+ */
+export declare function createAutoUpdateCheckerHook(ctx: PluginInput, options?: AutoUpdateCheckerOptions): {
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => void;
+};
+export type { AutoUpdateCheckerOptions } from './types';

package/dist/hooks/auto-update-checker/types.d.ts

@@ -0,0 +1,23 @@
+export interface NpmDistTags {
+    latest: string;
+    [key: string]: string;
+}
+export interface OpencodeConfig {
+    plugin?: string[];
+    [key: string]: unknown;
+}
+export interface PackageJson {
+    version: string;
+    name?: string;
+    [key: string]: unknown;
+}
+export interface AutoUpdateCheckerOptions {
+    showStartupToast?: boolean;
+    autoUpdate?: boolean;
+}
+export interface PluginEntryInfo {
+    entry: string;
+    isPinned: boolean;
+    pinnedVersion: string | null;
+    configPath: string;
+}

package/dist/hooks/chat-headers.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput, ProviderContext } from '@opencode-ai/plugin';
+import type { Model, UserMessage } from '@opencode-ai/sdk';
+interface ChatHeadersInput {
+    sessionID: string;
+    model: Model;
+    provider: ProviderContext;
+    message: UserMessage;
+}
+interface ChatHeadersOutput {
+    headers: Record<string, string>;
+}
+export declare function __resetInternalMarkerCacheForTesting(): void;
+export declare function createChatHeadersHook(ctx: PluginInput): {
+    'chat.headers': (input: ChatHeadersInput, output: ChatHeadersOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/delegate-task-retry/guidance.d.ts

@@ -0,0 +1,2 @@
+import { type DetectedError } from './patterns';
+export declare function buildRetryGuidance(errorInfo: DetectedError): string;

package/dist/hooks/delegate-task-retry/hook.d.ts

@@ -0,0 +1,8 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+export declare function createDelegateTaskRetryHook(_ctx: PluginInput): {
+    'tool.execute.after': (input: {
+        tool: string;
+    }, output: {
+        output: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/delegate-task-retry/index.d.ts

@@ -0,0 +1,4 @@
+export { buildRetryGuidance } from './guidance';
+export { createDelegateTaskRetryHook } from './hook';
+export type { DelegateTaskErrorPattern, DetectedError } from './patterns';
+export { DELEGATE_TASK_ERROR_PATTERNS, detectDelegateTaskError, } from './patterns';