@code-yeongyu/lazycodex 0.1.1

package/dist/shared/json-file-cache-store.d.ts

@@ -0,0 +1,16 @@
+type JsonFileCacheStoreOptions<TValue> = {
+    getCacheDir: () => string;
+    filename: string;
+    logPrefix: string;
+    cacheLabel: string;
+    describe: (value: TValue) => Record<string, unknown>;
+    serialize?: (value: TValue) => string;
+};
+type JsonFileCacheStore<TValue> = {
+    read: () => TValue | null;
+    has: () => boolean;
+    write: (value: TValue) => void;
+    resetMemory: () => void;
+};
+export declare function createJsonFileCacheStore<TValue>(options: JsonFileCacheStoreOptions<TValue>): JsonFileCacheStore<TValue>;
+export {};

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

@@ -0,0 +1 @@
+export { clearPluginConfigFileDetectionCache, detectConfigFile, detectPluginConfigFile, parseJsonc, parseJsoncSafe, readJsoncFile, type DetectPluginConfigFileOptions, type JsoncParseResult, } from "@oh-my-opencode/utils";

package/dist/shared/legacy-plugin-warning.d.ts

@@ -0,0 +1,7 @@
+export interface LegacyPluginCheckResult {
+    hasLegacyEntry: boolean;
+    hasCanonicalEntry: boolean;
+    legacyEntries: string[];
+    configPath: string | null;
+}
+export declare function checkForLegacyPluginEntry(overrideConfigDir?: string): LegacyPluginCheckResult;

package/dist/shared/legacy-workspace-migration.d.ts

@@ -0,0 +1,5 @@
+export type LegacyWorkspaceMigrationResult = {
+    migrated: boolean;
+    skipped: string[];
+};
+export declare function migrateLegacyWorkspaceDirectory(directory: string): LegacyWorkspaceMigrationResult;

package/dist/shared/load-opencode-plugins.d.ts

@@ -0,0 +1,2 @@
+export declare function loadOpencodePlugins(directory: string): string[];
+export declare function clearOpencodePluginsCache(): void;

package/dist/shared/log-legacy-plugin-startup-warning.d.ts

@@ -0,0 +1,10 @@
+import { checkForLegacyPluginEntry } from "./legacy-plugin-warning";
+import { log } from "./logger";
+import { migrateLegacyPluginEntry } from "./migrate-legacy-plugin-entry";
+type LogLegacyPluginStartupWarningDeps = {
+    checkForLegacyPluginEntry?: typeof checkForLegacyPluginEntry;
+    log?: typeof log;
+    migrateLegacyPluginEntry?: typeof migrateLegacyPluginEntry;
+};
+export declare function logLegacyPluginStartupWarning(deps?: LogLegacyPluginStartupWarningDeps): void;
+export {};

package/dist/shared/logger.d.ts

@@ -0,0 +1,14 @@
+export declare function log(message: string, data?: unknown): void;
+export declare function getLogFilePath(): string;
+interface LoggerTestOverrides {
+    filePath?: string;
+    maxSizeBytes?: number;
+    maxBackups?: number;
+}
+/** @internal test-only seam */
+export declare function _setLoggerForTesting(overrides: LoggerTestOverrides): void;
+/** @internal test-only seam */
+export declare function _resetLoggerForTesting(): void;
+/** @internal test-only seam: synchronously flush the buffer */
+export declare function _flushForTesting(): void;
+export {};

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

@@ -0,0 +1,6 @@
+import type { CategoriesConfig, CategoryConfig } from "../config/schema";
+/**
+ * Merge default and user categories, filtering out disabled ones.
+ * Single source of truth for category merging across the codebase.
+ */
+export declare function mergeCategories(userCategories?: CategoriesConfig): Record<string, CategoryConfig>;

package/dist/shared/migrate-legacy-config-file.d.ts

@@ -0,0 +1 @@
+export declare function migrateLegacyConfigFile(legacyPath: string): boolean;

package/dist/shared/migrate-legacy-plugin-entry.d.ts

@@ -0,0 +1 @@
+export declare function migrateLegacyPluginEntry(configPath: string): boolean;

package/dist/shared/migration/agent-category.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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 migrateAgentConfigToCategory(config: Record<string, unknown>): {
+    migrated: Record<string, unknown>;
+    changed: boolean;
+};
+export declare function shouldDeleteAgentConfig(config: Record<string, unknown>, category: string): boolean;

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

@@ -0,0 +1,6 @@
+export declare const AGENT_NAME_MAP: Record<string, string>;
+export declare const BUILTIN_AGENT_NAMES: Set<string>;
+export declare function migrateAgentNames(agents: Record<string, unknown>): {
+    migrated: Record<string, unknown>;
+    changed: boolean;
+};

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

@@ -0,0 +1 @@
+export declare function migrateConfigFile(configPath: string, rawConfig: Record<string, unknown>): boolean;

package/dist/shared/migration/hook-names.d.ts

@@ -0,0 +1,6 @@
+export declare const HOOK_NAME_MAP: Record<string, string | null>;
+export declare function migrateHookNames(hooks: string[]): {
+    migrated: string[];
+    changed: boolean;
+    removed: string[];
+};

package/dist/shared/migration/migrations-sidecar.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Sidecar state file that tracks applied config migrations outside the user's
+ * config file.
+ *
+ * Why this exists (#3263): users who revert an auto-migrated value (e.g.
+ * `gpt-5.4` → `gpt-5.3-codex`) and then delete the `_migrations` field from
+ * their config would fall into an infinite migration loop — every startup
+ * re-applied the migration because there was no memory of the previous
+ * application. The sidecar remembers applied migrations even when the user
+ * scrubs the config, and only "resets" when the user explicitly deletes both
+ * the config and the sidecar.
+ *
+ * The sidecar lives next to the config file as
+ * `<configFileName>.migrations.json`. One sidecar per config file. The file
+ * format is a flat JSON object:
+ *
+ *     {
+ *       "appliedMigrations": [
+ *         "model-version:openai/gpt-5.3-codex->openai/gpt-5.4",
+ *         "model-version:anthropic/claude-opus-4-5->anthropic/claude-opus-4-7"
+ *       ]
+ *     }
+ */
+export interface MigrationsSidecar {
+    appliedMigrations: string[];
+}
+export declare function getSidecarPath(configPath: string): string;
+/**
+ * Read the set of applied migration keys from the sidecar next to
+ * `configPath`. Returns an empty set on any read or parse failure so the
+ * caller can still trust the return value and safely fall back to the
+ * config's `_migrations` field.
+ */
+export declare function readAppliedMigrations(configPath: string): Set<string>;
+/**
+ * Persist the given set of applied migration keys to the sidecar next to
+ * `configPath`. The sidecar is written atomically. Returns true on success,
+ * false if the write failed (the caller can still proceed — the next
+ * startup will re-run the migration, which is idempotent by design).
+ */
+export declare function writeAppliedMigrations(configPath: string, migrations: Set<string>): boolean;

package/dist/shared/migration/model-versions.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Model version migration map: old full model strings → new full model strings.
+ * Used to auto-upgrade hardcoded model versions in user configs when the plugin
+ * bumps to newer model versions.
+ *
+ * Keys are full "provider/model" strings. Only openai and anthropic entries needed.
+ *
+ * Only include genuinely retired/superseded models here. Do NOT add mappings
+ * for current, user-selectable variants — `gpt-5.3-codex` is the canonical
+ * codex powerhouse referenced in docs/guide/agent-model-matching.md and is
+ * NOT a deprecated alias for `gpt-5.4`. Auto-rewriting an explicit user
+ * choice silently broke configurations (#3777).
+ */
+export declare const MODEL_VERSION_MAP: Record<string, string>;
+export declare function migrateModelVersions(configs: Record<string, unknown>, appliedMigrations?: Set<string>): {
+    migrated: Record<string, unknown>;
+    changed: boolean;
+    newMigrations: string[];
+};

package/dist/shared/migration.d.ts

@@ -0,0 +1,5 @@
+export { AGENT_NAME_MAP, BUILTIN_AGENT_NAMES, migrateAgentNames } from "./migration/agent-names";
+export { HOOK_NAME_MAP, migrateHookNames } from "./migration/hook-names";
+export { MODEL_VERSION_MAP, migrateModelVersions } from "./migration/model-versions";
+export { MODEL_TO_CATEGORY_MAP, migrateAgentConfigToCategory, shouldDeleteAgentConfig } from "./migration/agent-category";
+export { migrateConfigFile } from "./migration/config-migration";

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

@@ -0,0 +1,28 @@
+/**
+ * Fuzzy match a target model name against available models
+ *
+ * @param target - The model name or substring to search for (e.g., "gpt-5.4", "claude-opus")
+ * @param available - Set of available model names in format "provider/model-name"
+ * @param providers - Optional array of provider names to filter by (e.g., ["openai", "anthropic"])
+ * @returns The matched model name or null if no match found
+ *
+ * Matching priority:
+ * 1. Exact match (if exists)
+ * 2. Shorter model name (more specific)
+ *
+ * Matching is case-insensitive substring match.
+ * If providers array is given, only models starting with "provider/" are considered.
+ *
+ * @example
+ * const available = new Set(["openai/gpt-5.4", "openai/gpt-5.3-codex", "anthropic/claude-opus-4-7"])
+ * fuzzyMatchModel("gpt-5.4", available) // → "openai/gpt-5.4"
+ * fuzzyMatchModel("claude", available, ["openai"]) // → null (provider filter excludes anthropic)
+ */
+export declare function fuzzyMatchModel(target: string, available: Set<string>, providers?: string[]): string | null;
+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 __resetModelCache(): void;
+export declare function isModelCacheAvailable(): boolean;

package/dist/shared/model-capabilities/index.d.ts

@@ -0,0 +1,6 @@
+import type { GetModelCapabilitiesInput, ModelCapabilities } from "@oh-my-opencode/model-core";
+export declare function getBundledModelCapabilitiesSnapshotForRuntime(): import("@oh-my-opencode/model-core").ModelCapabilitiesSnapshot;
+export declare function getBundledModelCapabilitiesSnapshotForShared(): ReturnType<typeof getBundledModelCapabilitiesSnapshotForRuntime>;
+export { getBundledModelCapabilitiesSnapshotForShared as getBundledModelCapabilitiesSnapshot };
+export declare function getModelCapabilities(input: GetModelCapabilitiesInput): ModelCapabilities;
+export type { GetModelCapabilitiesInput, ModelCapabilities, ModelCapabilitiesDiagnostics, ModelCapabilitiesSnapshot, ModelCapabilitiesSnapshotEntry, } from "@oh-my-opencode/model-core";

package/dist/shared/model-capabilities-cache.d.ts

@@ -0,0 +1,16 @@
+import { MODELS_DEV_SOURCE_URL, buildModelCapabilitiesSnapshotFromModelsDev, fetchModelCapabilitiesSnapshot } from "@oh-my-opencode/model-core";
+import type { ModelCapabilitiesSnapshot } from "./model-capabilities";
+export { MODELS_DEV_SOURCE_URL, buildModelCapabilitiesSnapshotFromModelsDev, fetchModelCapabilitiesSnapshot, };
+export declare function createModelCapabilitiesCacheStore(getCacheDir?: () => string): {
+    readModelCapabilitiesCache: () => ModelCapabilitiesSnapshot | null;
+    hasModelCapabilitiesCache: () => boolean;
+    writeModelCapabilitiesCache: (snapshot: ModelCapabilitiesSnapshot) => void;
+    refreshModelCapabilitiesCache: (args?: {
+        sourceUrl?: string;
+        fetchImpl?: (input: string) => Promise<Response>;
+    }) => Promise<ModelCapabilitiesSnapshot>;
+};
+export declare const readModelCapabilitiesCache: () => ModelCapabilitiesSnapshot | null, hasModelCapabilitiesCache: () => boolean, writeModelCapabilitiesCache: (snapshot: ModelCapabilitiesSnapshot) => void, refreshModelCapabilitiesCache: (args?: {
+    sourceUrl?: string;
+    fetchImpl?: (input: string) => Promise<Response>;
+}) => Promise<ModelCapabilitiesSnapshot>;

package/dist/shared/model-error-classifier.d.ts

@@ -0,0 +1,5 @@
+import { getNextFallback, hasMoreFallbacks, isRetryableModelError, selectFallbackProviderWithCache, shouldRetryError } from "@oh-my-opencode/model-core";
+import type { ErrorInfo } from "@oh-my-opencode/model-core";
+export type { ErrorInfo };
+export { isRetryableModelError, shouldRetryError, getNextFallback, hasMoreFallbacks, selectFallbackProviderWithCache, };
+export declare function selectFallbackProvider(providers: string[], preferredProviderID?: string): string;

package/dist/shared/model-format-normalizer.d.ts

@@ -0,0 +1 @@
+export { normalizeModelFormat } from "@oh-my-opencode/model-core";

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

@@ -0,0 +1 @@
+export { normalizeModel, normalizeModelID } from "@oh-my-opencode/model-core";

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

@@ -0,0 +1,2 @@
+export type { FallbackEntry, ModelRequirement } from "@oh-my-opencode/model-core";
+export { AGENT_MODEL_REQUIREMENTS, CATEGORY_MODEL_REQUIREMENTS, } from "@oh-my-opencode/model-core";

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

@@ -0,0 +1,5 @@
+import { _setModelResolutionLogImplementationForTesting } from "@oh-my-opencode/model-core";
+import type { PipelineModelResolutionRequest, PipelineModelResolutionResult } from "@oh-my-opencode/model-core";
+export { _setModelResolutionLogImplementationForTesting };
+export declare function resolveModelPipeline(request: PipelineModelResolutionRequest): PipelineModelResolutionResult | undefined;
+export type { PipelineModelResolutionRequest as ModelResolutionRequest, PipelineModelResolutionProvenance as ModelResolutionProvenance, PipelineModelResolutionResult as ModelResolutionResult, } from "@oh-my-opencode/model-core";

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

@@ -0,0 +1 @@
+export type { DelegatedModelConfig, ModelResolutionRequest, ModelResolutionProvenance, ModelResolutionResult, } from "@oh-my-opencode/model-core";

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

@@ -0,0 +1,8 @@
+import { resolveModel, resolveModelWithFallback as resolveModelWithFallbackFromCore, normalizeFallbackModels, flattenToFallbackModelStrings } from "@oh-my-opencode/model-core";
+import type { ModelResolutionInput, ExtendedModelResolutionInput } from "@oh-my-opencode/model-core";
+export { resolveModel, normalizeFallbackModels, flattenToFallbackModelStrings };
+type CoreModelResolutionResult = ReturnType<typeof resolveModelWithFallbackFromCore>;
+export type ModelResolutionResult = Exclude<CoreModelResolutionResult, undefined>;
+export type ModelSource = ModelResolutionResult["source"];
+export declare function resolveModelWithFallback(input: ExtendedModelResolutionInput): CoreModelResolutionResult;
+export type { ModelResolutionInput, ExtendedModelResolutionInput, };

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

@@ -0,0 +1 @@
+export { sanitizeModelField } from "@oh-my-opencode/model-core";

package/dist/shared/model-settings-compatibility.d.ts

@@ -0,0 +1,2 @@
+export type { ModelSettingsCompatibilityInput, ModelSettingsCompatibilityChange, ModelSettingsCompatibilityResult, } from "@oh-my-opencode/model-core";
+export { resolveCompatibleModelSettings } from "@oh-my-opencode/model-core";

package/dist/shared/model-string-parser.d.ts

@@ -0,0 +1 @@
+export { parseVariantFromModelID, parseModelString } from "@oh-my-opencode/model-core";

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

@@ -0,0 +1,23 @@
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+import { parseModelSuggestion as parseModelSuggestionFromCore } from "@oh-my-opencode/model-core";
+import { type PromptRetryOptions } from "./prompt-timeout-context";
+type Client = ReturnType<typeof createOpencodeClient>;
+export type { ModelSuggestionInfo } from "@oh-my-opencode/model-core";
+export { parseModelSuggestionFromCore as parseModelSuggestion };
+interface PromptBody {
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    [key: string]: unknown;
+}
+interface PromptArgs {
+    path: {
+        id: string;
+    };
+    body: PromptBody;
+    signal?: AbortSignal;
+    [key: string]: unknown;
+}
+export declare function promptWithModelSuggestionRetry(client: Client, args: PromptArgs, options?: PromptRetryOptions): Promise<void>;
+export declare function promptSyncWithModelSuggestionRetry(client: Client, args: PromptArgs, options?: PromptRetryOptions): Promise<void>;

package/dist/shared/normalize-sdk-response.d.ts

@@ -0,0 +1,4 @@
+export interface NormalizeSDKResponseOptions {
+    preferResponseOnMissingData?: boolean;
+}
+export declare function normalizeSDKResponse<TData>(response: unknown, fallback: TData, options?: NormalizeSDKResponseOptions): TData;

package/dist/shared/opencode-command-dirs.d.ts

@@ -0,0 +1,3 @@
+import type { OpenCodeConfigDirOptions } from "./opencode-config-dir-types";
+export declare function getOpenCodeCommandDirs(options: OpenCodeConfigDirOptions): string[];
+export declare function getOpenCodeSkillDirs(options: OpenCodeConfigDirOptions): string[];

package/dist/shared/opencode-config-dir-types.d.ts

@@ -0,0 +1,13 @@
+export type OpenCodeBinaryType = "opencode" | "opencode-desktop";
+export type OpenCodeConfigDirOptions = {
+    binary: OpenCodeBinaryType;
+    version?: string | null;
+    checkExisting?: boolean;
+};
+export type OpenCodeConfigPaths = {
+    configDir: string;
+    configJson: string;
+    configJsonc: string;
+    packageJson: string;
+    omoConfig: string;
+};

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

@@ -0,0 +1,9 @@
+import type { OpenCodeBinaryType, OpenCodeConfigDirOptions, OpenCodeConfigPaths } from "./opencode-config-dir-types";
+export type { OpenCodeBinaryType, OpenCodeConfigDirOptions, OpenCodeConfigPaths, } from "./opencode-config-dir-types";
+export declare const TAURI_APP_IDENTIFIER = "ai.opencode.desktop";
+export declare const TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev";
+export declare function isDevBuild(version: string | null | undefined): boolean;
+export declare function getOpenCodeConfigDirs(options: OpenCodeConfigDirOptions): string[];
+export declare function getOpenCodeConfigDir(options: OpenCodeConfigDirOptions): string;
+export declare function getOpenCodeConfigPaths(options: OpenCodeConfigDirOptions): OpenCodeConfigPaths;
+export declare function detectExistingConfigDir(binary: OpenCodeBinaryType, version?: string | null): string | null;

package/dist/shared/opencode-http-api.d.ts

@@ -0,0 +1,12 @@
+import { getServerBasicAuthHeader as resolveServerBasicAuthHeader } from "./opencode-server-auth";
+import { log as writeLog } from "./logger";
+type FetchImplementation = typeof fetch;
+type LogImplementation = typeof writeLog;
+type ServerBasicAuthHeaderResolver = typeof resolveServerBasicAuthHeader;
+export declare function _setFetchImplementationForTesting(fetchImplementation: FetchImplementation | undefined): void;
+export declare function _setLogImplementationForTesting(logImplementation: LogImplementation | undefined): void;
+export declare function _setServerBasicAuthHeaderResolverForTesting(resolver: ServerBasicAuthHeaderResolver | undefined): void;
+export declare function getServerBaseUrl(client: unknown): string | null;
+export declare function patchPart(client: unknown, sessionID: string, messageID: string, partID: string, body: Record<string, unknown>): Promise<boolean>;
+export declare function deletePart(client: unknown, sessionID: string, messageID: string, partID: string): Promise<boolean>;
+export {};

package/dist/shared/opencode-message-dir.d.ts

@@ -0,0 +1 @@
+export declare function getMessageDir(sessionID: string): string | null;

package/dist/shared/opencode-provider-auth.d.ts

@@ -0,0 +1,3 @@
+export declare function getProviderAuthType(providerID: string): string | undefined;
+export declare function isProviderUsingOAuth(providerID: string): boolean;
+export declare function _resetProviderAuthCacheForTesting(): void;

package/dist/shared/opencode-server-auth.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Builds HTTP Basic Auth header from environment variables.
+ *
+ * @returns Basic Auth header string, or undefined if OPENCODE_SERVER_PASSWORD is not set
+ */
+export declare function getServerBasicAuthHeader(): string | undefined;
+/**
+ * Injects HTTP Basic Auth header into the OpenCode SDK client.
+ *
+ * This function accesses the SDK's internal `_client.setConfig()` method.
+ * While `_client` has an underscore prefix (suggesting internal use), this is actually
+ * a stable public API from `@hey-api/openapi-ts` generated client:
+ * - `setConfig()` MERGES headers (does not replace existing ones)
+ * - This is the documented way to update client config at runtime
+ *
+ * @see https://github.com/sst/opencode/blob/main/packages/sdk/js/src/gen/client/client.gen.ts
+ * @throws {Error} If OPENCODE_SERVER_PASSWORD is set but client structure is incompatible
+ */
+export declare function injectServerAuthIntoClient(client: unknown): void;

package/dist/shared/opencode-storage-detection.d.ts

@@ -0,0 +1,2 @@
+export declare function isSqliteBackend(): boolean;
+export declare function resetSqliteBackendCache(): void;

package/dist/shared/opencode-storage-paths.d.ts

@@ -0,0 +1,4 @@
+export declare const OPENCODE_STORAGE: string;
+export declare const MESSAGE_STORAGE: string;
+export declare const PART_STORAGE: string;
+export declare const SESSION_STORAGE: string;

package/dist/shared/opencode-version.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Minimum OpenCode version required for this plugin.
+ * This plugin only supports OpenCode 1.1.1+ which uses the permission system.
+ */
+export declare const MINIMUM_OPENCODE_VERSION = "1.1.1";
+/**
+ * OpenCode version that introduced native AGENTS.md injection.
+ * PR #10678 merged on Jan 26, 2026 - OpenCode now dynamically resolves
+ * AGENTS.md files from subdirectories as the agent explores them.
+ * When this version is detected, the directory-agents-injector hook
+ * is auto-disabled to prevent duplicate AGENTS.md loading.
+ */
+export declare const OPENCODE_NATIVE_AGENTS_INJECTION_VERSION = "1.1.37";
+/**
+ * OpenCode version that introduced SQLite backend for storage.
+ * When this version is detected AND opencode.db exists, SQLite backend is used.
+ */
+export declare const OPENCODE_SQLITE_VERSION = "1.1.53";
+type ExecCommandOptions = {
+    encoding: "utf-8";
+    timeout: number;
+    stdio: ["pipe", "pipe", "pipe"];
+};
+export type OpenCodeVersionDeps = {
+    execCommand: (command: string, options: ExecCommandOptions) => string;
+    getBinaryPath: () => string | null;
+    exists: (filePath: string) => boolean;
+    realpath: (filePath: string) => string;
+    readText: (filePath: string) => string;
+};
+export declare function parseVersion(version: string): number[];
+export declare function compareVersions(a: string, b: string): -1 | 0 | 1;
+export declare function getOpenCodeVersion(deps?: Partial<OpenCodeVersionDeps>): string | null;
+export declare function isOpenCodeVersionAtLeast(version: string): boolean;
+export declare function resetVersionCache(): void;
+export declare function setVersionCache(version: string | null): void;
+export {};

package/dist/shared/parse-tools-config.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Parses a tools configuration value into a boolean record.
+ * Accepts comma-separated strings, string arrays, or unknown values from config files.
+ * Returns undefined when input is empty or invalid.
+ */
+export declare function parseToolsConfig(toolsValue: unknown): Record<string, boolean> | undefined;

package/dist/shared/pattern-matcher.d.ts

@@ -0,0 +1,3 @@
+import type { ClaudeHooksConfig, HookMatcher } from "../hooks/claude-code-hooks/types";
+export declare function matchesToolMatcher(toolName: string, matcher: string): boolean;
+export declare function findMatchingHooks(config: ClaudeHooksConfig, eventName: keyof ClaudeHooksConfig, toolName?: string): HookMatcher[];

package/dist/shared/permission-compat.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Permission system utilities for OpenCode 1.1.1+.
+ * This module only supports the new permission format.
+ */
+export type PermissionValue = "ask" | "allow" | "deny";
+export interface PermissionFormat {
+    permission: Record<string, PermissionValue>;
+}
+/**
+ * Creates tool restrictions that deny specified tools.
+ */
+export declare function createAgentToolRestrictions(denyTools: string[], allowTools?: string[]): PermissionFormat;
+/**
+ * Creates tool restrictions that ONLY allow specified tools.
+ * All other tools are denied by default using `*: deny` pattern.
+ */
+export declare function createAgentToolAllowlist(allowTools: string[]): PermissionFormat;
+/**
+ * Converts legacy tools format to permission format.
+ * For migrating user configs from older versions.
+ */
+export declare function migrateToolsToPermission(tools: Record<string, boolean>): Record<string, PermissionValue>;
+/**
+ * Migrates agent config from legacy tools format to permission format.
+ * If config has `tools`, converts to `permission`.
+ */
+export declare function migrateAgentConfig(config: Record<string, unknown>): Record<string, unknown>;

package/dist/shared/plugin-command-discovery.d.ts

@@ -0,0 +1,6 @@
+import type { CommandDefinition } from "../features/claude-code-command-loader/types";
+export interface PluginCommandDiscoveryOptions {
+    pluginsEnabled?: boolean;
+    enabledPluginsOverride?: Record<string, boolean>;
+}
+export declare function discoverPluginCommandDefinitions(options?: PluginCommandDiscoveryOptions): Record<string, CommandDefinition>;

package/dist/shared/plugin-entry-migrator.d.ts

@@ -0,0 +1,3 @@
+export declare function isLegacyEntry(entry: string): boolean;
+export declare function isCanonicalEntry(entry: string): boolean;
+export declare function toCanonicalEntry(entry: string): string;

package/dist/shared/plugin-identity.d.ts

@@ -0,0 +1,8 @@
+export declare const PLUGIN_NAME = "oh-my-openagent";
+export declare const LEGACY_PLUGIN_NAME = "oh-my-opencode";
+export declare const PUBLISHED_PACKAGE_NAME = "oh-my-opencode";
+export declare const ACCEPTED_PACKAGE_NAMES: readonly ["oh-my-opencode", "oh-my-openagent"];
+export declare const CONFIG_BASENAME = "oh-my-openagent";
+export declare const LEGACY_CONFIG_BASENAME = "oh-my-opencode";
+export declare const LOG_FILENAME = "oh-my-opencode.log";
+export declare const CACHE_DIR_NAME = "oh-my-opencode";

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

@@ -0,0 +1 @@
+export { DEFAULT_SERVER_PORT, findAvailablePort, getAvailableServerPort, isPortAvailable, type AutoPortResult, } from "@oh-my-opencode/utils";

package/dist/shared/posthog-activity-state.d.ts

@@ -0,0 +1,6 @@
+type PostHogActivityCaptureState = {
+    dayUTC: string;
+    captureDaily: boolean;
+};
+export declare function getPostHogActivityCaptureState(now?: Date): PostHogActivityCaptureState;
+export {};

package/dist/shared/posthog.d.ts

@@ -0,0 +1,20 @@
+import os from "os";
+import { getPostHogActivityCaptureState } from "./posthog-activity-state";
+type OsProvider = Pick<typeof os, "arch" | "cpus" | "hostname" | "platform" | "release" | "totalmem" | "type">;
+/** @internal test-only */
+export declare function __setActivityStateProviderForTesting(provider: typeof getPostHogActivityCaptureState): void;
+/** @internal test-only */
+export declare function __resetActivityStateProviderForTesting(): void;
+/** @internal test-only */
+export declare function __setOsProviderForTesting(provider: OsProvider): void;
+/** @internal test-only */
+export declare function __resetOsProviderForTesting(): void;
+type PostHogActivityReason = "run_started";
+type PostHogClient = {
+    trackActive: (distinctId: string, reason: PostHogActivityReason) => void;
+    shutdown: () => Promise<void>;
+};
+export declare function getPostHogDistinctId(): string;
+export declare function createCliPostHog(): PostHogClient;
+export declare function createPluginPostHog(): PostHogClient;
+export {};

package/dist/shared/process-stream-reader.d.ts

@@ -0,0 +1,3 @@
+import { Readable } from "node:stream";
+export type ProcessReadableStream = ReadableStream<Uint8Array> | Readable | null | undefined;
+export declare function readProcessStream(stream: ProcessReadableStream): Promise<string>;

package/dist/shared/project-discovery-dirs.d.ts

@@ -0,0 +1,7 @@
+export declare function clearWorktreeCache(): void;
+export declare function detectWorktreePath(directory: string): string | undefined;
+export declare function findProjectClaudeSkillDirs(startDirectory: string, stopDirectory?: string): string[];
+export declare function findProjectAgentsSkillDirs(startDirectory: string, stopDirectory?: string): string[];
+export declare function findProjectOpencodeSkillDirs(startDirectory: string, stopDirectory?: string): string[];
+export declare function findProjectOpencodeCommandDirs(startDirectory: string, stopDirectory?: string): string[];
+export declare function findProjectOpencodePluginConfigFiles(startDirectory: string, stopDirectory?: string): string[];

package/dist/shared/prompt-async-gate/message-inspection-error.d.ts

@@ -0,0 +1 @@
+export declare function isPromptMessageInspectionAborted(error: unknown): boolean;

package/dist/shared/prompt-async-gate/pending-tool-turn.d.ts

@@ -0,0 +1,11 @@
+import type { PromptDispatchClient, PromptSessionName } from "./types";
+export declare function latestAssistantTurnHasUnansweredQuestion(messages: unknown[]): boolean;
+export declare function latestAssistantTurnBlocksInternalPrompt(messages: unknown[]): boolean;
+export declare function sessionLatestAssistantBlocksInternalPrompt<TInput>(args: {
+    readonly client: PromptDispatchClient;
+    readonly sessionID: string;
+    readonly input: TInput;
+    readonly sessionName: PromptSessionName;
+    readonly source: string;
+    readonly timeoutMs: number;
+}): Promise<boolean>;

package/dist/shared/prompt-async-gate/prompt-message-state.d.ts

@@ -0,0 +1,8 @@
+export declare function messageRole(message: unknown): string | undefined;
+export declare function messageFinish(message: unknown): string | true | undefined;
+export declare function messageCompleted(message: unknown): boolean;
+export declare function messageIsSyntheticOrInternalUser(message: unknown): boolean;
+export declare function messageHasQuestionTool(message: unknown): boolean;
+export declare function messageHasWaitingTool(message: unknown): boolean;
+export declare function messageHasUnresolvedTool(message: unknown): boolean;
+export declare function messageHasSubstantiveAssistantOutput(message: unknown): boolean;

package/dist/shared/prompt-async-gate/queue.d.ts

@@ -0,0 +1,8 @@
+import type { InternalPromptDispatchResult, QueuedInternalPrompt } from "./types";
+export declare function schedulePromptQueueDrain(sessionID: string, delayMs: number): void;
+export declare function getQueuedPromptBlocker(sessionID: string): string | undefined;
+export declare function isPromptQueueDraining(sessionID: string): boolean;
+export declare function nextPromptQueueID(): number;
+export declare function releaseInFlightPromptMatchingDedupe(sessionID: string, dedupeKey: string): void;
+export declare function clearPromptQueueStateForTesting(): void;
+export declare function enqueueInternalPrompt(entry: QueuedInternalPrompt): Promise<InternalPromptDispatchResult>;

package/dist/shared/prompt-async-gate/reservations.d.ts

@@ -0,0 +1,9 @@
+import type { PromptAsyncReservation, PromptAsyncReservationReleaseOptions } from "./types";
+export declare function setExpiredReservationHandler(handler: (sessionID: string) => void): void;
+export declare function getActiveReservation(sessionID: string): PromptAsyncReservation | undefined;
+export declare function getPromptReservation(sessionID: string): PromptAsyncReservation | undefined;
+export declare function setPromptReservation(sessionID: string, reservation: PromptAsyncReservation): void;
+export declare function finishPromptReservation(sessionID: string, reservation: PromptAsyncReservation, dispatchAttempted: boolean, postDispatchHoldMs: number): void;
+export declare function deletePromptReservation(sessionID: string): void;
+export declare function clearPromptReservationsForTesting(): void;
+export declare function reservationSourceMatches(reservationSource: string, expectedSource: string | readonly string[], expectedPrefix?: PromptAsyncReservationReleaseOptions["reservedByPrefix"]): boolean;