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

package/dist/plugin-config.d.ts

@@ -0,0 +1,4 @@
+import { type OhMyOpenCodeConfig } from "./config";
+export declare function loadConfigFromPath(configPath: string, ctx: unknown): OhMyOpenCodeConfig | null;
+export declare function mergeConfigs(base: OhMyOpenCodeConfig, override: OhMyOpenCodeConfig): OhMyOpenCodeConfig;
+export declare function loadPluginConfig(directory: string, ctx: unknown): OhMyOpenCodeConfig;

package/dist/plugin-config.test.d.ts

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

package/dist/plugin-handlers/config-handler.d.ts

@@ -0,0 +1,13 @@
+import type { OhMyOpenCodeConfig } from "../config";
+import type { ModelCacheState } from "../plugin-state";
+import type { CategoryConfig } from "../config/schema";
+export interface ConfigHandlerDeps {
+    ctx: {
+        directory: string;
+        client?: any;
+    };
+    pluginConfig: OhMyOpenCodeConfig;
+    modelCacheState: ModelCacheState;
+}
+export declare function resolveCategoryConfig(categoryName: string, userCategories?: Record<string, CategoryConfig>): CategoryConfig | undefined;
+export declare function createConfigHandler(deps: ConfigHandlerDeps): (config: Record<string, unknown>) => Promise<void>;

package/dist/plugin-handlers/config-handler.test.d.ts

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

package/dist/plugin-handlers/index.d.ts

@@ -0,0 +1 @@
+export { createConfigHandler, type ConfigHandlerDeps } from "./config-handler";

package/dist/plugin-state.d.ts

@@ -0,0 +1,6 @@
+export interface ModelCacheState {
+    modelContextLimitsCache: Map<string, number>;
+    anthropicContext1MEnabled: boolean;
+}
+export declare function createModelCacheState(): ModelCacheState;
+export declare function getModelLimit(state: ModelCacheState, providerID: string, modelID: string): number | undefined;

package/dist/shared/agent-config-integration.test.d.ts

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

package/dist/shared/agent-display-names.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Agent config keys to display names mapping.
+ * Config keys are lowercase (e.g., "sisyphus", "atlas").
+ * Display names include suffixes for UI/logs (e.g., "Sisyphus (Ultraworker)").
+ */
+export declare const AGENT_DISPLAY_NAMES: Record<string, string>;
+/**
+ * Get display name for an agent config key.
+ * Uses case-insensitive lookup for backward compatibility.
+ * Returns original key if not found.
+ */
+export declare function getAgentDisplayName(configKey: string): string;

package/dist/shared/agent-display-names.test.d.ts

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

package/dist/shared/agent-tool-restrictions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Agent tool restrictions for session.prompt calls.
+ * OpenCode SDK's session.prompt `tools` parameter expects boolean values.
+ * true = tool allowed, false = tool denied.
+ */
+export declare function getAgentToolRestrictions(agentName: string): Record<string, boolean>;
+export declare function hasAgentToolRestrictions(agentName: string): boolean;

package/dist/shared/agent-variant.d.ts

@@ -0,0 +1,9 @@
+import type { OhMyOpenCodeConfig } from "../config";
+export declare function resolveAgentVariant(config: OhMyOpenCodeConfig, agentName?: string): string | undefined;
+export declare function resolveVariantForModel(config: OhMyOpenCodeConfig, agentName: string, currentModel: {
+    providerID: string;
+    modelID: string;
+}): string | undefined;
+export declare function applyAgentVariant(config: OhMyOpenCodeConfig, agentName: string | undefined, message: {
+    variant?: string;
+}): void;

package/dist/shared/agent-variant.test.d.ts

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

package/dist/shared/binary-downloader.d.ts

@@ -0,0 +1,10 @@
+export declare function getCachedBinaryPath(cacheDir: string, binaryName: string): string | null;
+export declare function ensureCacheDir(cacheDir: string): void;
+export declare function downloadArchive(downloadUrl: string, archivePath: string): Promise<void>;
+export declare function extractTarGz(archivePath: string, destDir: string, options?: {
+    args?: string[];
+    cwd?: string;
+}): Promise<void>;
+export declare function extractZipArchive(archivePath: string, destDir: string): Promise<void>;
+export declare function cleanupArchive(archivePath: string): void;
+export declare function ensureExecutable(binaryPath: string): void;

package/dist/shared/claude-config-dir.d.ts

@@ -0,0 +1 @@
+export declare function getClaudeConfigDir(): string;

package/dist/shared/claude-config-dir.test.d.ts

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

package/dist/shared/command-executor.d.ts

@@ -0,0 +1,21 @@
+export interface CommandResult {
+    exitCode: number;
+    stdout?: string;
+    stderr?: string;
+}
+export interface ExecuteHookOptions {
+    forceZsh?: boolean;
+    zshPath?: string;
+}
+/**
+ * Execute a hook command with stdin input
+ */
+export declare function executeHookCommand(command: string, stdin: string, cwd: string, options?: ExecuteHookOptions): Promise<CommandResult>;
+/**
+ * Execute a simple command and return output
+ */
+export declare function executeCommand(command: string): Promise<string>;
+/**
+ * Resolve embedded commands in text recursively
+ */
+export declare function resolveCommandsInText(text: string, depth?: number, maxDepth?: number): Promise<string>;

package/dist/shared/config-errors.d.ts

@@ -0,0 +1,7 @@
+export type ConfigLoadError = {
+    path: string;
+    error: string;
+};
+export declare function getConfigLoadErrors(): ConfigLoadError[];
+export declare function clearConfigLoadErrors(): void;
+export declare function addConfigLoadError(error: ConfigLoadError): void;

package/dist/shared/connected-providers-cache.d.ts

@@ -0,0 +1,52 @@
+interface ProviderModelsCache {
+    models: Record<string, string[]>;
+    connected: string[];
+    updatedAt: string;
+}
+/**
+ * Read the connected providers cache.
+ * Returns the list of connected provider IDs, or null if cache doesn't exist.
+ */
+export declare function readConnectedProvidersCache(): string[] | null;
+/**
+ * Check if connected providers cache exists.
+ */
+export declare function hasConnectedProvidersCache(): boolean;
+/**
+ * Read the provider-models cache.
+ * Returns the cache data, or null if cache doesn't exist.
+ */
+export declare function readProviderModelsCache(): ProviderModelsCache | null;
+/**
+ * Check if provider-models cache exists.
+ */
+export declare function hasProviderModelsCache(): boolean;
+/**
+ * Write the provider-models cache.
+ */
+export declare function writeProviderModelsCache(data: {
+    models: Record<string, string[]>;
+    connected: string[];
+}): void;
+/**
+ * Update the connected providers cache by fetching from the client.
+ * Also updates the provider-models cache with model lists per provider.
+ */
+export declare function updateConnectedProvidersCache(client: {
+    provider?: {
+        list?: () => Promise<{
+            data?: {
+                connected?: string[];
+            };
+        }>;
+    };
+    model?: {
+        list?: () => Promise<{
+            data?: Array<{
+                id: string;
+                provider: string;
+            }>;
+        }>;
+    };
+}): Promise<void>;
+export {};

package/dist/shared/data-path.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Returns the user-level data directory.
+ * Matches OpenCode's behavior via xdg-basedir:
+ * - All platforms: XDG_DATA_HOME or ~/.local/share
+ *
+ * Note: OpenCode uses xdg-basedir which returns ~/.local/share on ALL platforms
+ * including Windows, so we match that behavior exactly.
+ */
+export declare function getDataDir(): string;
+/**
+ * Returns the OpenCode storage directory path.
+ * All platforms: ~/.local/share/opencode/storage
+ */
+export declare function getOpenCodeStorageDir(): string;
+/**
+ * Returns the user-level cache directory.
+ * Matches OpenCode's behavior via xdg-basedir:
+ * - All platforms: XDG_CACHE_HOME or ~/.cache
+ */
+export declare function getCacheDir(): string;
+/**
+ * Returns the oh-my-parallel-agent-opencode cache directory.
+ * All platforms: ~/.cache/oh-my-parallel-agent-opencode
+ */
+export declare function getOmoOpenCodeCacheDir(): string;
+/**
+ * Returns the OpenCode cache directory (for reading OpenCode's cache).
+ * All platforms: ~/.cache/opencode
+ */
+export declare function getOpenCodeCacheDir(): string;

package/dist/shared/deep-merge.d.ts

@@ -0,0 +1,13 @@
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Deep merges two objects, with override values taking precedence.
+ * - Objects are recursively merged
+ * - Arrays are replaced (not concatenated)
+ * - undefined values in override do not overwrite base values
+ *
+ * @example
+ * deepMerge({ a: 1, b: { c: 2, d: 3 } }, { b: { c: 10 }, e: 5 })
+ * // => { a: 1, b: { c: 10, d: 3 }, e: 5 }
+ */
+export declare function deepMerge<T extends Record<string, unknown>>(base: T, override: Partial<T>, depth?: number): T;
+export declare function deepMerge<T extends Record<string, unknown>>(base: T | undefined, override: T | undefined, depth?: number): T | undefined;

package/dist/shared/deep-merge.test.d.ts

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

package/dist/shared/dynamic-truncator.d.ts

@@ -0,0 +1,27 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export interface TruncationResult {
+    result: string;
+    truncated: boolean;
+    removedCount?: number;
+}
+export interface TruncationOptions {
+    targetMaxTokens?: number;
+    preserveHeaderLines?: number;
+    contextWindowLimit?: number;
+}
+export declare function truncateToTokenLimit(output: string, maxTokens: number, preserveHeaderLines?: number): TruncationResult;
+export declare function getContextWindowUsage(ctx: PluginInput, sessionID: string): Promise<{
+    usedTokens: number;
+    remainingTokens: number;
+    usagePercentage: number;
+} | null>;
+export declare function dynamicTruncate(ctx: PluginInput, sessionID: string, output: string, options?: TruncationOptions): Promise<TruncationResult>;
+export declare function createDynamicTruncator(ctx: PluginInput): {
+    truncate: (sessionID: string, output: string, options?: TruncationOptions) => Promise<TruncationResult>;
+    getUsage: (sessionID: string) => Promise<{
+        usedTokens: number;
+        remainingTokens: number;
+        usagePercentage: number;
+    } | null>;
+    truncateSync: (output: string, maxTokens: number, preserveHeaderLines?: number) => TruncationResult;
+};

package/dist/shared/external-plugin-detector.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Detects external plugins that may conflict with oh-my-parallel-agent-opencode features.
+ * Used to prevent crashes from concurrent notification plugins.
+ */
+export interface ExternalNotifierResult {
+    detected: boolean;
+    pluginName: string | null;
+    allPlugins: string[];
+}
+/**
+ * Detect if any external notification plugin is configured.
+ * Returns information about detected plugins for logging/warning.
+ */
+export declare function detectExternalNotificationPlugin(directory: string): ExternalNotifierResult;
+/**
+ * Generate a warning message for users with conflicting notification plugins.
+ */
+export declare function getNotificationConflictWarning(pluginName: string): string;

package/dist/shared/external-plugin-detector.test.d.ts

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

package/dist/shared/file-reference-resolver.d.ts

@@ -0,0 +1 @@
+export declare function resolveFileReferencesInText(text: string, cwd?: string, depth?: number, maxDepth?: number): Promise<string>;

package/dist/shared/file-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function isMarkdownFile(entry: {
+    name: string;
+    isFile: () => boolean;
+}): boolean;
+export declare function isSymbolicLink(filePath: string): boolean;
+export declare function resolveSymlink(filePath: string): string;
+export declare function resolveSymlinkAsync(filePath: string): Promise<string>;

package/dist/shared/first-message-variant.d.ts

@@ -0,0 +1,11 @@
+type SessionInfo = {
+    id?: string;
+    parentID?: string;
+};
+export declare function createFirstMessageVariantGate(): {
+    markSessionCreated(info?: SessionInfo): void;
+    shouldOverride(sessionID?: string): boolean;
+    markApplied(sessionID?: string): void;
+    clear(sessionID?: string): void;
+};
+export {};

package/dist/shared/first-message-variant.test.d.ts

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

package/dist/shared/frontmatter.d.ts

@@ -0,0 +1,7 @@
+export interface FrontmatterResult<T = Record<string, unknown>> {
+    data: T;
+    body: string;
+    hadFrontmatter: boolean;
+    parseError: boolean;
+}
+export declare function parseFrontmatter<T = Record<string, unknown>>(content: string): FrontmatterResult<T>;

package/dist/shared/frontmatter.test.d.ts

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

package/dist/shared/hook-disabled.d.ts

@@ -0,0 +1,2 @@
+import type { ClaudeHookEvent, PluginConfig } from "../hooks/claude-code-hooks/types";
+export declare function isHookDisabled(config: PluginConfig, hookType: ClaudeHookEvent): boolean;

package/dist/shared/index.d.ts

@@ -0,0 +1,36 @@
+export * from "./frontmatter";
+export * from "./command-executor";
+export * from "./file-reference-resolver";
+export * from "./model-sanitizer";
+export * from "./logger";
+export * from "./snake-case";
+export * from "./tool-name";
+export * from "./pattern-matcher";
+export * from "./hook-disabled";
+export * from "./deep-merge";
+export * from "./file-utils";
+export * from "./dynamic-truncator";
+export * from "./data-path";
+export * from "./config-errors";
+export * from "./claude-config-dir";
+export * from "./jsonc-parser";
+export * from "./migration";
+export * from "./opencode-config-dir";
+export * from "./opencode-version";
+export * from "./permission-compat";
+export * from "./external-plugin-detector";
+export * from "./zip-extractor";
+export * from "./binary-downloader";
+export * from "./agent-variant";
+export * from "./session-cursor";
+export * from "./shell-env";
+export * from "./system-directive";
+export * from "./agent-tool-restrictions";
+export * from "./model-requirements";
+export * from "./model-resolver";
+export { resolveModelPipeline, type ModelResolutionRequest, type ModelResolutionResult as ModelResolutionPipelineResult, type ModelResolutionProvenance, } from "./model-resolution-pipeline";
+export * from "./model-availability";
+export * from "./connected-providers-cache";
+export * from "./session-utils";
+export * from "./tmux";
+export * from "./model-suggestion-retry";

package/dist/shared/jsonc-parser.d.ts

@@ -0,0 +1,15 @@
+export interface JsoncParseResult<T> {
+    data: T | null;
+    errors: Array<{
+        message: string;
+        offset: number;
+        length: number;
+    }>;
+}
+export declare function parseJsonc<T = unknown>(content: string): T;
+export declare function parseJsoncSafe<T = unknown>(content: string): JsoncParseResult<T>;
+export declare function readJsoncFile<T = unknown>(filePath: string): T | null;
+export declare function detectConfigFile(basePath: string): {
+    format: "json" | "jsonc" | "none";
+    path: string;
+};

package/dist/shared/jsonc-parser.test.d.ts

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

package/dist/shared/logger.d.ts

@@ -0,0 +1,2 @@
+export declare function log(message: string, data?: unknown): void;
+export declare function getLogFilePath(): string;

package/dist/shared/migration.d.ts

@@ -0,0 +1,32 @@
+export declare const AGENT_NAME_MAP: Record<string, string>;
+export declare const BUILTIN_AGENT_NAMES: Set<string>;
+export declare const HOOK_NAME_MAP: Record<string, string | null>;
+/**
+ * @deprecated LEGACY MIGRATION ONLY
+ *
+ * This map exists solely for migrating old configs that used hardcoded model strings.
+ * It maps legacy model strings to semantic category names, allowing users to migrate
+ * from explicit model configs to category-based configs.
+ *
+ * DO NOT add new entries here. New agents should use:
+ * - Category-based config (preferred): { category: "unspecified-high" }
+ * - Or inherit from OpenCode's config.model
+ *
+ * This map will be removed in a future major version once migration period ends.
+ */
+export declare const MODEL_TO_CATEGORY_MAP: Record<string, string>;
+export declare function migrateAgentNames(agents: Record<string, unknown>): {
+    migrated: Record<string, unknown>;
+    changed: boolean;
+};
+export declare function migrateHookNames(hooks: string[]): {
+    migrated: string[];
+    changed: boolean;
+    removed: string[];
+};
+export declare function migrateAgentConfigToCategory(config: Record<string, unknown>): {
+    migrated: Record<string, unknown>;
+    changed: boolean;
+};
+export declare function shouldDeleteAgentConfig(config: Record<string, unknown>, category: string): boolean;
+export declare function migrateConfigFile(configPath: string, rawConfig: Record<string, unknown>): boolean;

package/dist/shared/migration.test.d.ts

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

package/dist/shared/model-availability.d.ts

@@ -0,0 +1,19 @@
+export declare function fuzzyMatchModel(target: string, available: Set<string>, providers?: string[]): string | null;
+/**
+ * Check if a target model is available (fuzzy match by model name, no provider filtering)
+ *
+ * @param targetModel - Model name to check (e.g., "gpt-5.2-codex")
+ * @param availableModels - Set of available models in "provider/model" format
+ * @returns true if model is available, false otherwise
+ */
+export declare function isModelAvailable(targetModel: string, availableModels: Set<string>): boolean;
+export declare function getConnectedProviders(client: any): Promise<string[]>;
+export declare function fetchAvailableModels(client?: any, options?: {
+    connectedProviders?: string[] | null;
+}): Promise<Set<string>>;
+export declare function isAnyFallbackModelAvailable(fallbackChain: Array<{
+    providers: string[];
+    model: string;
+}>, availableModels: Set<string>): boolean;
+export declare function __resetModelCache(): void;
+export declare function isModelCacheAvailable(): boolean;

package/dist/shared/model-availability.test.d.ts

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

package/dist/shared/model-requirements.d.ts

@@ -0,0 +1,13 @@
+export type FallbackEntry = {
+    providers: string[];
+    model: string;
+    variant?: string;
+};
+export type ModelRequirement = {
+    fallbackChain: FallbackEntry[];
+    variant?: string;
+    requiresModel?: string;
+    requiresAnyModel?: boolean;
+};
+export declare const AGENT_MODEL_REQUIREMENTS: Record<string, ModelRequirement>;
+export declare const CATEGORY_MODEL_REQUIREMENTS: Record<string, ModelRequirement>;

package/dist/shared/model-requirements.test.d.ts

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

package/dist/shared/model-resolution-pipeline.d.ts

@@ -0,0 +1,24 @@
+import type { FallbackEntry } from "./model-requirements";
+export type ModelResolutionRequest = {
+    intent?: {
+        uiSelectedModel?: string;
+        userModel?: string;
+        categoryDefaultModel?: string;
+    };
+    constraints: {
+        availableModels: Set<string>;
+    };
+    policy?: {
+        fallbackChain?: FallbackEntry[];
+        systemDefaultModel?: string;
+    };
+};
+export type ModelResolutionProvenance = "override" | "category-default" | "provider-fallback" | "system-default";
+export type ModelResolutionResult = {
+    model: string;
+    provenance: ModelResolutionProvenance;
+    variant?: string;
+    attempted?: string[];
+    reason?: string;
+};
+export declare function resolveModelPipeline(request: ModelResolutionRequest): ModelResolutionResult | undefined;

package/dist/shared/model-resolver.d.ts

@@ -0,0 +1,22 @@
+import type { FallbackEntry } from "./model-requirements";
+export type ModelResolutionInput = {
+    userModel?: string;
+    inheritedModel?: string;
+    systemDefault?: string;
+};
+export type ModelSource = "override" | "category-default" | "provider-fallback" | "system-default";
+export type ModelResolutionResult = {
+    model: string;
+    source: ModelSource;
+    variant?: string;
+};
+export type ExtendedModelResolutionInput = {
+    uiSelectedModel?: string;
+    userModel?: string;
+    categoryDefaultModel?: string;
+    fallbackChain?: FallbackEntry[];
+    availableModels: Set<string>;
+    systemDefaultModel?: string;
+};
+export declare function resolveModel(input: ModelResolutionInput): string | undefined;
+export declare function resolveModelWithFallback(input: ExtendedModelResolutionInput): ModelResolutionResult | undefined;

package/dist/shared/model-resolver.test.d.ts

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

package/dist/shared/model-sanitizer.d.ts

@@ -0,0 +1,3 @@
+type CommandSource = "claude-code" | "opencode";
+export declare function sanitizeModelField(model: unknown, source?: CommandSource): string | undefined;
+export {};

package/dist/shared/model-suggestion-retry.d.ts

@@ -0,0 +1,24 @@
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+type Client = ReturnType<typeof createOpencodeClient>;
+export interface ModelSuggestionInfo {
+    providerID: string;
+    modelID: string;
+    suggestion: string;
+}
+export declare function parseModelSuggestion(error: unknown): ModelSuggestionInfo | null;
+interface PromptBody {
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    [key: string]: unknown;
+}
+interface PromptArgs {
+    path: {
+        id: string;
+    };
+    body: PromptBody;
+    [key: string]: unknown;
+}
+export declare function promptWithModelSuggestionRetry(client: Client, args: PromptArgs): Promise<void>;
+export {};

package/dist/shared/model-suggestion-retry.test.d.ts

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