oh-my-opencode-medium 0.8.2

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

@@ -0,0 +1,30 @@
+export interface ModelSelectionCandidate {
+    model: string;
+    status?: 'alpha' | 'beta' | 'deprecated' | 'active';
+    contextLimit?: number;
+    outputLimit?: number;
+    reasoning?: boolean;
+    toolcall?: boolean;
+    attachment?: boolean;
+    tags?: string[];
+    meta?: Record<string, unknown>;
+}
+export interface RankedModel<T extends ModelSelectionCandidate> {
+    candidate: T;
+    score: number;
+}
+export interface SelectionOptions<T extends ModelSelectionCandidate> {
+    excludeModels?: string[];
+    tieBreaker?: (left: T, right: T) => number;
+}
+export type ScoreFunction<T extends ModelSelectionCandidate> = (candidate: T) => number;
+export interface RoleScoring<T extends ModelSelectionCandidate> {
+    primary: ScoreFunction<T>;
+    support: ScoreFunction<T>;
+}
+export declare function rankModels<T extends ModelSelectionCandidate>(models: T[], scoreFn: ScoreFunction<T>, options?: SelectionOptions<T>): RankedModel<T>[];
+export declare function pickBestModel<T extends ModelSelectionCandidate>(models: T[], scoreFn: ScoreFunction<T>, options?: SelectionOptions<T>): T | null;
+export declare function pickPrimaryAndSupport<T extends ModelSelectionCandidate>(models: T[], scoring: RoleScoring<T>, preferredPrimaryModel?: string): {
+    primary: T | null;
+    support: T | null;
+};

package/dist/cli/opencode-models.d.ts

@@ -0,0 +1,18 @@
+import type { DiscoveredModel, OpenCodeFreeModel } from './types';
+export declare function parseOpenCodeModelsVerboseOutput(output: string, providerFilter?: string, freeOnly?: boolean): DiscoveredModel[];
+export declare function discoverModelCatalog(): Promise<{
+    models: DiscoveredModel[];
+    error?: string;
+}>;
+export declare function discoverOpenCodeFreeModels(): Promise<{
+    models: OpenCodeFreeModel[];
+    error?: string;
+}>;
+export declare function discoverProviderFreeModels(providerID: string): Promise<{
+    models: OpenCodeFreeModel[];
+    error?: string;
+}>;
+export declare function discoverProviderModels(providerID: string): Promise<{
+    models: DiscoveredModel[];
+    error?: string;
+}>;

package/dist/cli/opencode-selection.d.ts

@@ -0,0 +1,3 @@
+import type { OpenCodeFreeModel } from './types';
+export declare function pickBestCodingOpenCodeModel(models: OpenCodeFreeModel[]): OpenCodeFreeModel | null;
+export declare function pickSupportOpenCodeModel(models: OpenCodeFreeModel[], primaryModel?: string): OpenCodeFreeModel | null;

package/dist/cli/paths.d.ts

@@ -0,0 +1,9 @@
+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;

package/dist/cli/precedence-resolver.d.ts

@@ -0,0 +1,16 @@
+import type { AgentResolutionProvenance } from './types';
+export interface AgentLayerInput {
+    agentName: string;
+    openCodeDirectOverride?: string;
+    manualUserPlan?: string[];
+    pinnedModel?: string;
+    dynamicRecommendation?: string[];
+    providerFallbackPolicy?: string[];
+    systemDefault: string[];
+}
+export interface ResolvedAgentLayerResult {
+    model: string;
+    chain: string[];
+    provenance: AgentResolutionProvenance;
+}
+export declare function resolveAgentWithPrecedence(input: AgentLayerInput): ResolvedAgentLayerResult;

package/dist/cli/providers.d.ts

@@ -0,0 +1,204 @@
+import type { InstallConfig } from './types';
+export declare const MODEL_MAPPINGS: {
+    readonly kimi: {
+        readonly orchestrator: {
+            readonly model: "kimi-for-coding/k2p5";
+        };
+        readonly oracle: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "low";
+        };
+    };
+    readonly openai: {
+        readonly orchestrator: {
+            readonly model: "openai/gpt-5.3-codex";
+        };
+        readonly oracle: {
+            readonly model: "openai/gpt-5.3-codex";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "openai/gpt-5.1-codex-mini";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "openai/gpt-5.1-codex-mini";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "openai/gpt-5.1-codex-mini";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "openai/gpt-5.1-codex-mini";
+            readonly variant: "low";
+        };
+    };
+    readonly anthropic: {
+        readonly orchestrator: {
+            readonly model: "anthropic/claude-opus-4-6";
+        };
+        readonly oracle: {
+            readonly model: "anthropic/claude-opus-4-6";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "anthropic/claude-sonnet-4-5";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "anthropic/claude-haiku-4-5";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "anthropic/claude-sonnet-4-5";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "anthropic/claude-sonnet-4-5";
+            readonly variant: "low";
+        };
+    };
+    readonly copilot: {
+        readonly orchestrator: {
+            readonly model: "github-copilot/grok-code-fast-1";
+        };
+        readonly oracle: {
+            readonly model: "github-copilot/grok-code-fast-1";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "github-copilot/grok-code-fast-1";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "github-copilot/grok-code-fast-1";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "github-copilot/grok-code-fast-1";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "github-copilot/grok-code-fast-1";
+            readonly variant: "low";
+        };
+    };
+    readonly 'zai-plan': {
+        readonly orchestrator: {
+            readonly model: "zai-coding-plan/glm-4.7";
+        };
+        readonly oracle: {
+            readonly model: "zai-coding-plan/glm-4.7";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "zai-coding-plan/glm-4.7";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "zai-coding-plan/glm-4.7";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "zai-coding-plan/glm-4.7";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "zai-coding-plan/glm-4.7";
+            readonly variant: "low";
+        };
+    };
+    readonly antigravity: {
+        readonly orchestrator: {
+            readonly model: "google/antigravity-gemini-3-flash";
+        };
+        readonly oracle: {
+            readonly model: "google/antigravity-gemini-3.1-pro";
+        };
+        readonly librarian: {
+            readonly model: "google/antigravity-gemini-3-flash";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "google/antigravity-gemini-3-flash";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "google/antigravity-gemini-3-flash";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "google/antigravity-gemini-3-flash";
+            readonly variant: "low";
+        };
+    };
+    readonly chutes: {
+        readonly orchestrator: {
+            readonly model: "chutes/kimi-k2.5";
+        };
+        readonly oracle: {
+            readonly model: "chutes/kimi-k2.5";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "chutes/minimax-m2.1";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "chutes/minimax-m2.1";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "chutes/kimi-k2.5";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "chutes/minimax-m2.1";
+            readonly variant: "low";
+        };
+    };
+    readonly 'zen-free': {
+        readonly orchestrator: {
+            readonly model: "opencode/big-pickle";
+        };
+        readonly oracle: {
+            readonly model: "opencode/big-pickle";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "opencode/big-pickle";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "opencode/big-pickle";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "opencode/big-pickle";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "opencode/big-pickle";
+            readonly variant: "low";
+        };
+    };
+};
+export declare function generateAntigravityMixedPreset(config: InstallConfig, existingPreset?: Record<string, unknown>): Record<string, unknown>;
+export declare function generateLiteConfig(installConfig: InstallConfig): Record<string, unknown>;

package/dist/cli/scoring-v2/engine.d.ts

@@ -0,0 +1,4 @@
+import type { DiscoveredModel, ExternalSignalMap } from '../types';
+import type { ScoredCandidate, ScoringAgentName } from './types';
+export declare function scoreCandidateV2(model: DiscoveredModel, agent: ScoringAgentName, externalSignals?: ExternalSignalMap): ScoredCandidate;
+export declare function rankModelsV2(models: DiscoveredModel[], agent: ScoringAgentName, externalSignals?: ExternalSignalMap): ScoredCandidate[];

package/dist/cli/scoring-v2/features.d.ts

@@ -0,0 +1,3 @@
+import type { DiscoveredModel, ExternalSignalMap } from '../types';
+import type { FeatureVector, ScoringAgentName } from './types';
+export declare function extractFeatureVector(model: DiscoveredModel, agent: ScoringAgentName, externalSignals?: ExternalSignalMap): FeatureVector;

package/dist/cli/scoring-v2/index.d.ts

@@ -0,0 +1,4 @@
+export { rankModelsV2, scoreCandidateV2 } from './engine';
+export { extractFeatureVector } from './features';
+export type { FeatureVector, ScoredCandidate, ScoringAgentName, } from './types';
+export { getFeatureWeights } from './weights';

package/dist/cli/scoring-v2/types.d.ts

@@ -0,0 +1,17 @@
+import type { DiscoveredModel, ExternalSignalMap } from '../types';
+export type ScoreFeatureName = 'status' | 'context' | 'output' | 'versionBonus' | 'reasoning' | 'toolcall' | 'attachment' | 'quality' | 'coding' | 'latencyPenalty' | 'pricePenalty';
+export type FeatureVector = Record<ScoreFeatureName, number>;
+export type FeatureWeights = Record<ScoreFeatureName, number>;
+export type ScoringAgentName = 'orchestrator' | 'oracle' | 'designer' | 'explorer' | 'librarian' | 'fixer';
+export interface ScoringContext {
+    agent: ScoringAgentName;
+    externalSignals?: ExternalSignalMap;
+}
+export interface ScoredCandidate {
+    model: DiscoveredModel;
+    totalScore: number;
+    scoreBreakdown: {
+        features: FeatureVector;
+        weighted: FeatureVector;
+    };
+}

package/dist/cli/scoring-v2/weights.d.ts

@@ -0,0 +1,2 @@
+import type { FeatureWeights, ScoringAgentName } from './types';
+export declare function getFeatureWeights(agent: ScoringAgentName): FeatureWeights;

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,138 @@
+export type BooleanArg = 'yes' | 'no';
+export interface InstallArgs {
+    tui: boolean;
+    kimi?: BooleanArg;
+    openai?: BooleanArg;
+    anthropic?: BooleanArg;
+    copilot?: BooleanArg;
+    zaiPlan?: BooleanArg;
+    antigravity?: BooleanArg;
+    chutes?: BooleanArg;
+    tmux?: BooleanArg;
+    skills?: BooleanArg;
+    opencodeFree?: BooleanArg;
+    balancedSpend?: BooleanArg;
+    opencodeFreeModel?: string;
+    aaKey?: string;
+    openrouterKey?: string;
+    dryRun?: boolean;
+    modelsOnly?: boolean;
+}
+export interface OpenCodeFreeModel {
+    providerID: string;
+    model: string;
+    name: string;
+    status: 'alpha' | 'beta' | 'deprecated' | 'active';
+    contextLimit: number;
+    outputLimit: number;
+    reasoning: boolean;
+    toolcall: boolean;
+    attachment: boolean;
+    dailyRequestLimit?: number;
+}
+export interface DiscoveredModel {
+    providerID: string;
+    model: string;
+    name: string;
+    status: 'alpha' | 'beta' | 'deprecated' | 'active';
+    contextLimit: number;
+    outputLimit: number;
+    reasoning: boolean;
+    toolcall: boolean;
+    attachment: boolean;
+    dailyRequestLimit?: number;
+    costInput?: number;
+    costOutput?: number;
+}
+export interface DynamicAgentAssignment {
+    model: string;
+    variant?: string;
+}
+export type ScoringEngineVersion = 'v1' | 'v2-shadow' | 'v2';
+export type ResolutionLayerName = 'opencode-direct-override' | 'manual-user-plan' | 'pinned-model' | 'dynamic-recommendation' | 'provider-fallback-policy' | 'system-default';
+export interface AgentResolutionProvenance {
+    winnerLayer: ResolutionLayerName;
+    winnerModel: string;
+}
+export interface DynamicPlanScoringMeta {
+    engineVersionApplied: 'v1' | 'v2';
+    shadowCompared: boolean;
+    diffs?: Record<string, {
+        v1TopModel?: string;
+        v2TopModel?: string;
+    }>;
+}
+export interface DynamicModelPlan {
+    agents: Record<string, DynamicAgentAssignment>;
+    chains: Record<string, string[]>;
+    provenance?: Record<string, AgentResolutionProvenance>;
+    scoring?: DynamicPlanScoringMeta;
+}
+export interface ExternalModelSignal {
+    qualityScore?: number;
+    codingScore?: number;
+    latencySeconds?: number;
+    inputPricePer1M?: number;
+    outputPricePer1M?: number;
+    source: 'artificial-analysis' | 'openrouter' | 'merged';
+}
+export type ExternalSignalMap = Record<string, ExternalModelSignal>;
+export type ManualAgentConfig = {
+    primary: string;
+    fallback1: string;
+    fallback2: string;
+    fallback3: string;
+};
+export interface OpenCodeConfig {
+    plugin?: string[];
+    provider?: Record<string, unknown>;
+    agent?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface InstallConfig {
+    hasKimi: boolean;
+    hasOpenAI: boolean;
+    hasAnthropic?: boolean;
+    hasCopilot?: boolean;
+    hasZaiPlan?: boolean;
+    hasAntigravity: boolean;
+    hasChutes?: boolean;
+    hasOpencodeZen: boolean;
+    useOpenCodeFreeModels?: boolean;
+    preferredOpenCodeModel?: string;
+    selectedOpenCodePrimaryModel?: string;
+    selectedOpenCodeSecondaryModel?: string;
+    availableOpenCodeFreeModels?: OpenCodeFreeModel[];
+    selectedChutesPrimaryModel?: string;
+    selectedChutesSecondaryModel?: string;
+    availableChutesModels?: DiscoveredModel[];
+    dynamicModelPlan?: DynamicModelPlan;
+    scoringEngineVersion?: ScoringEngineVersion;
+    artificialAnalysisApiKey?: string;
+    openRouterApiKey?: string;
+    balanceProviderUsage?: boolean;
+    hasTmux: boolean;
+    installSkills: boolean;
+    installCustomSkills: boolean;
+    setupMode: 'quick' | 'manual';
+    manualAgentConfigs?: Record<string, ManualAgentConfig>;
+    dryRun?: boolean;
+    modelsOnly?: 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 ["explorer", "librarian", "oracle", "designer", "fixer"];
+export declare const ORCHESTRATOR_NAME: "orchestrator";
+export declare const ALL_AGENT_NAMES: readonly ["orchestrator", "explorer", "librarian", "oracle", "designer", "fixer"];
+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,30 @@
+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: ~/.config/opencode/oh-my-opencode-medium.jsonc or .json (or $XDG_CONFIG_HOME)
+ * 2. Project config: <directory>/.opencode/oh-my-opencode-medium.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., "orchestrator", "explorer")
+ * @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;
+};