opencode-dux 1.0.0

package/dist/discovery/local/types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Type definitions for the discovery module.
+ *
+ * These types describe MCP servers and skills discovered from local
+ * filesystem sources (node_modules, skill directories, etc.).
+ *
+ * @module
+ */
+/**
+ * An MCP server discovered from a local source (e.g., node_modules).
+ */
+export interface DiscoveredMcp {
+    /** Unique name used as the config key (e.g., 'server-github'). */
+    name: string;
+    /** Command to launch the MCP server (e.g., `['npx', '@org/mcp-server']`). */
+    command: string[];
+    /** Human-readable description of what this MCP provides. */
+    description?: string;
+    /** Categorization tags (e.g., 'browser', 'github', 'filesystem'). */
+    tags: string[];
+    /** Source identifier indicating where this was found (e.g., 'node_modules'). */
+    source: string;
+    /** Absolute path to the package.json that defined this MCP. */
+    packageJsonPath: string;
+    /** Version from the package.json, if available. */
+    version?: string;
+}
+/**
+ * A skill discovered from a local source (skill directory, plugin root, etc.).
+ */
+export interface DiscoveredSkill {
+    /** Unique skill name (derived from folder name). */
+    name: string;
+    /** Human-readable description. */
+    description: string;
+    /** Absolute path to the SKILL.md file. */
+    path: string;
+    /** Tags for categorisation and matching. */
+    tags: string[];
+    /** Agents that are recommended to use this skill. */
+    recommendedAgents: string[];
+    /** Source identifier (e.g., 'plugin', 'user-skills-dir'). */
+    source: string;
+    /** Version of the skill, if available. */
+    version?: string;
+}
+/**
+ * Complete result of a local discovery scan.
+ */
+export interface LocalDiscoveryResult {
+    /** Discovered MCP servers. */
+    mcps: DiscoveredMcp[];
+    /** Discovered skills. */
+    skills: DiscoveredSkill[];
+    /** ISO timestamp when the scan was performed. */
+    scannedAt: string;
+    /** How long the scan took in milliseconds. */
+    scanDurationMs: number;
+}
+/**
+ * Options to control the behaviour of a local discovery scan.
+ */
+export interface ScanOptions {
+    /**
+     * Additional directories to scan for skills (absolute paths).
+     * Skills are discovered from each directory using the same SKILL.md
+     * convention as the plugin's built-in skills.
+     */
+    userSkillsDirs?: string[];
+    /**
+     * If true, skip scanning node_modules for MCP servers.
+     * Useful when the caller only needs skill discovery.
+     */
+    skipNodeModules?: boolean;
+    /**
+     * If true, bypass the module-level cache and force a fresh scan.
+     */
+    forceRefresh?: boolean;
+}

package/dist/discovery/local.d.ts

@@ -0,0 +1,73 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+/**
+ * A single MCP server discovered via the OpenCode SDK.
+ */
+export interface DiscoveredMcp {
+    /** Unique name used as the config key (e.g., 'playwright', 'github'). */
+    name: string;
+    /** Current connection status reported by OpenCode. */
+    status: 'connected' | 'disabled' | 'failed' | 'needs_auth' | 'needs_client_registration';
+    /** Human-readable description, may include error details when status is 'failed'. */
+    description?: string;
+    /** Categorization tags derived from the MCP name. */
+    tags: string[];
+    /** Agents that benefit most from this MCP based on defaults. */
+    recommendedAgents: string[];
+}
+/**
+ * A single skill discovered via the OpenCode SDK.
+ */
+export interface DiscoveredSkill {
+    /** Unique skill name. */
+    name: string;
+    /** Human-readable description. */
+    description?: string;
+    /** Filesystem location of the skill (SKILL.md path). */
+    location: string;
+    /** Categorization tags derived from the skill name. */
+    tags: string[];
+    /** Agents that benefit most from this skill based on defaults. */
+    recommendedAgents: string[];
+    /** Whether the skill ships with the plugin or was added by the user. */
+    source: 'bundled' | 'user';
+}
+/**
+ * Complete result of an SDK-based local discovery scan.
+ */
+export interface LocalDiscoveryResult {
+    /** Discovered skills. */
+    skills: DiscoveredSkill[];
+    /** Discovered MCP servers. */
+    mcps: DiscoveredMcp[];
+    /** Unix timestamp (ms) when the scan was performed. */
+    scannedAt: number;
+    /** How long the scan took in milliseconds. */
+    scanDurationMs: number;
+}
+/**
+ * Scan locally configured MCP servers and skills using the OpenCode SDK.
+ *
+ * Calls `ctx.client.mcp.status()` and `ctx.client.instance.skill()` for fast,
+ * authoritative local discovery. Each SDK call is independently wrapped in a
+ * try/catch so that a failure in one does not prevent the other from
+ * succeeding. Empty arrays are returned for any failing SDK call.
+ *
+ * Results are **not** cached by this function – use
+ * {@link getLocalDiscovery} for caching support.
+ *
+ * @param ctx - The OpenCode plugin input context
+ * @returns A {@link LocalDiscoveryResult} with discovered MCPs and skills
+ */
+export declare function scanLocal(ctx: PluginInput): Promise<LocalDiscoveryResult>;
+/**
+ * Get locally discovered resources, using a cached result when available.
+ *
+ * Results are cached for 5 minutes. Call with `forceRefresh = true` to
+ * bypass the cache and perform a fresh scan. The cache lives at module
+ * scope and is shared across all callers within the same plugin instance.
+ *
+ * @param ctx - The OpenCode plugin input context
+ * @param forceRefresh - If `true`, bypass the cache and force a fresh scan
+ * @returns A {@link LocalDiscoveryResult}
+ */
+export declare function getLocalDiscovery(ctx: PluginInput, forceRefresh?: boolean): Promise<LocalDiscoveryResult>;

package/dist/discovery/mcp-servers.d.ts

@@ -0,0 +1,88 @@
+import type { PluginInput, ToolDefinition } from '@opencode-ai/plugin';
+/**
+ * Input parameters for discovering MCP servers online.
+ */
+export interface McpDiscoveryInput {
+    /** Natural-language description of the task at hand. */
+    task_description: string;
+    /** Keywords that characterise the task (used for search queries). */
+    task_keywords: string[];
+    /** The subagent that initiated the discovery request. */
+    agent_name: string;
+    /**
+     * MCP servers already known to be installed.
+     * Recommendations that match by name will be filtered out.
+     */
+    existing_mcp_names?: string[];
+    /** Maximum number of recommendations to return (default: 5). */
+    max_results?: number;
+}
+/**
+ * A single recommendation for an installable MCP server.
+ */
+export interface McpRecommendation {
+    type: 'mcp';
+    /** Canonical name (e.g. 'playwright', 'github'). */
+    name: string;
+    /** Human-readable summary of what the MCP server provides. */
+    description: string;
+    /**
+     * A ready-to-use JSON config block for the user's opencode config,
+     * e.g. `{"mcpServers": {"playwright": {"command": ["npx", "@modelcontextprotocol/server-playwright"]}}}`.
+     */
+    install_command: string;
+    /** Why this recommendation is relevant to the task. */
+    relevance_reason: string;
+    /** Relevance score from 0 (irrelevant) to 1 (perfect match). */
+    relevance_score: number;
+    /** URL to the project's homepage, repository, or package page. */
+    source_url?: string;
+    /** Agent names that are most likely to benefit from this MCP server. */
+    recommended_agents: string[];
+    /** Categorisation tags (e.g. 'browser', 'github', 'filesystem'). */
+    tags: string[];
+    /** Whether the user already has this MCP server installed. */
+    already_installed?: boolean;
+}
+/**
+ * The complete output of an MCP discovery request.
+ */
+export interface McpDiscoveryOutput {
+    /** Ordered list of recommendations, highest relevance first. */
+    recommendations: McpRecommendation[];
+    /** Whether the result was served from cache. */
+    from_cache: boolean;
+    /** The search queries that were executed. */
+    queries_used: string[];
+}
+/**
+ * Run the full MCP discovery flow for a given set of inputs.
+ *
+ * 1. Builds search queries from keywords and agent name
+ * 2. Searches the npm registry for matching MCP packages
+ * 3. Maps results to recommendations with relevance scores
+ * 4. Marks already-installed items with `already_installed: true` and
+ *    only includes them when relevance_score > 0.8
+ * 5. Returns the top N results
+ *
+ * Results are cached on disk for 24 hours.
+ */
+export declare function discoverMcpServers(input: McpDiscoveryInput, ctx: PluginInput): Promise<McpDiscoveryOutput>;
+/**
+ * Create the `discover_mcp_servers` tool that subagents can call to find
+ * installable MCP servers for a given task.
+ *
+ * The tool:
+ * 1. Builds search queries from task keywords and agent name
+ * 2. Searches the npm registry for verified MCP packages
+ * 3. Scores each result by relevance (0-1)
+ * 4. Filters out MCP servers the user already has installed
+ * 5. Returns the top N recommendations with ready-to-use mcpServers JSON config
+ *
+ * Results are cached on disk at `~/.config/opencode/discovery-cache.json`
+ * with a 24-hour TTL and LRU eviction (max 100 entries).
+ *
+ * @param ctx - The OpenCode plugin input (provides client for SDK access)
+ * @returns A `ToolDefinition` ready for registration in the plugin's tool hook
+ */
+export declare function createDiscoverMcpServersTool(ctx: PluginInput): ToolDefinition;

package/dist/discovery/skills.d.ts

@@ -0,0 +1,94 @@
+import type { PluginInput, ToolDefinition } from '@opencode-ai/plugin';
+/**
+ * Input parameters for discovering OpenCode skills online.
+ */
+export interface DiscoverSkillsInput {
+    /** Natural-language description of the task at hand. */
+    task_description: string;
+    /** Keywords that characterise the task (used for search queries). */
+    task_keywords: string[];
+    /** The subagent that initiated the discovery request. */
+    agent_name: string;
+    /**
+     * Skills already known to be installed.
+     * Recommendations that match by name will be filtered out or marked.
+     */
+    existing_skill_names?: string[];
+    /** Maximum number of recommendations to return (default: 5). */
+    max_results?: number;
+}
+/**
+ * A single recommendation for an installable OpenCode skill.
+ */
+export interface SkillRecommendation {
+    type: 'skill';
+    /** Canonical name (e.g. 'ast-grep', 'codemap'). */
+    name: string;
+    /** Human-readable summary of what the skill provides. */
+    description: string;
+    /**
+     * A ready-to-use install command, e.g.
+     * `npx skills add https://github.com/vercel-labs/skills --skill ast-grep`.
+     */
+    install_command: string;
+    /** Why this recommendation is relevant to the task. */
+    relevance_reason: string;
+    /** Relevance score from 0 (irrelevant) to 1 (perfect match). */
+    relevance_score: number;
+    /** GitHub repository URL for the skill. */
+    source_url: string;
+    /** Agent names that are most likely to benefit from this skill. */
+    recommended_agents: string[];
+    /** Categorisation tags (e.g. 'search', 'code', 'ast'). */
+    tags: string[];
+    /** Whether the user already has this skill installed. */
+    already_installed?: boolean;
+}
+/**
+ * The complete output of a skill discovery request.
+ */
+export interface DiscoverSkillsOutput {
+    /** Ordered list of recommendations, highest relevance first. */
+    recommendations: SkillRecommendation[];
+    /** Whether the result was served from cache. */
+    from_cache: boolean;
+    /** The search queries that were executed. */
+    queries_used: string[];
+}
+/**
+ * Run the full skill discovery flow for a given set of inputs.
+ *
+ * 1. Builds search queries from keywords and agent name
+ * 2. Searches the vercel-labs/skills repository for skill definitions
+ * 3. Searches GitHub broadly for opencode skill-related repositories
+ * 4. Tries the OpenCode SDK's skill endpoint (if available)
+ * 5. Merges, deduplicates, and scores results
+ * 6. Returns the top N results
+ *
+ * Does NOT search npm.
+ * Results are cached on disk for 7 days (skills change less often).
+ */
+export declare function discoverSkills(input: DiscoverSkillsInput, ctx: PluginInput): Promise<DiscoverSkillsOutput>;
+/**
+ * Create the `discover_skills_online` tool that subagents can call to find
+ * installable OpenCode skills for a given task.
+ *
+ * The tool:
+ * 1. Builds search queries from task keywords and agent name
+ * 2. Searches the vercel-labs/skills repository and general GitHub for skills
+ * 3. Tries the OpenCode SDK's skill endpoint if available
+ * 4. Scores each result by relevance (0-1)
+ * 5. Marks already-installed skills with `already_installed: true` and
+ *    only includes them when relevance_score > 0.8
+ * 6. Returns the top N recommendations with install commands
+ *
+ * Does NOT search npm. Skills are knowledge/prompt resources separate from
+ * MCP servers (which are tool/capability resources).
+ *
+ * Results are cached on disk at `~/.config/opencode/discovery-cache.json`
+ * with a 7-day TTL and LRU eviction (max 100 entries).
+ *
+ * @param ctx - The OpenCode plugin input (provides client for SDK access)
+ * @returns A `ToolDefinition` ready for registration in the plugin's tool hook
+ */
+export declare function createDiscoverSkillsTool(ctx: PluginInput): ToolDefinition;

package/dist/hooks/apply-patch/codec.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedPatch } from './types';
+export declare function normalizeUnicode(text: string): string;
+export declare function stripHeredoc(input: string): string;
+export declare function normalizePatchText(patchText: string): string;
+export declare function parsePatch(patchText: string): ParsedPatch;
+export declare function parsePatchStrict(patchText: string): ParsedPatch;
+export declare function formatPatch(patch: ParsedPatch): string;

package/dist/hooks/apply-patch/errors.d.ts

@@ -0,0 +1,25 @@
+import type { ApplyPatchErrorCode, ApplyPatchErrorKind } from './types';
+export declare class ApplyPatchError extends Error {
+    readonly kind: ApplyPatchErrorKind;
+    readonly code: ApplyPatchErrorCode;
+    readonly cause?: unknown;
+    constructor(kind: ApplyPatchErrorKind, code: ApplyPatchErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare function getErrorMessage(error: unknown): string;
+export declare function createApplyPatchBlockedError(message: string, cause?: unknown): ApplyPatchError;
+export declare function createApplyPatchValidationError(message: string, cause?: unknown): ApplyPatchError;
+export declare function createApplyPatchVerificationError(message: string, cause?: unknown): ApplyPatchError;
+export declare function createApplyPatchInternalError(message: string, cause?: unknown): ApplyPatchError;
+export declare function isApplyPatchError(error: unknown): error is ApplyPatchError;
+export declare function isApplyPatchBlockedError(error: unknown): boolean;
+export declare function isApplyPatchValidationError(error: unknown): boolean;
+export declare function isApplyPatchVerificationError(error: unknown): boolean;
+export declare function isApplyPatchInternalError(error: unknown): boolean;
+export declare function getApplyPatchErrorDetails(error: unknown): {
+    kind: ApplyPatchErrorKind;
+    code: ApplyPatchErrorCode;
+    message: string;
+} | undefined;
+export declare function ensureApplyPatchError(error: unknown, context: string): ApplyPatchError;

package/dist/hooks/apply-patch/execution-context.d.ts

@@ -0,0 +1,27 @@
+import { resolveUpdateChunksFromText } from './resolution';
+import type { ApplyPatchRuntimeOptions, PatchHunk, UpdatePatchHunk } from './types';
+export type PreparedFileState = {
+    exists: false;
+    derived: boolean;
+} | {
+    exists: true;
+    text: string;
+    mode?: number;
+    derived: boolean;
+};
+export type PatchExecutionContext = {
+    hunks: PatchHunk[];
+    pathsNormalized: boolean;
+    staged: Map<string, PreparedFileState>;
+    getPreparedFileState: (filePath: string, verb: 'update' | 'delete') => Promise<PreparedFileState>;
+    assertPreparedPathMissing: (filePath: string, verb: 'add' | 'move') => Promise<void>;
+};
+export type ResolvedPreparedUpdate = {
+    resolved: Awaited<ReturnType<typeof resolveUpdateChunksFromText>>['resolved'];
+    nextText: string;
+};
+export declare function isMissingPathError(error: unknown): boolean;
+export declare function parseValidatedPatch(patchText: string): PatchHunk[];
+export declare function createPatchExecutionContext(root: string, patchText: string, worktree?: string): Promise<PatchExecutionContext>;
+export declare function resolvePreparedUpdate(filePath: string, currentText: string, hunk: UpdatePatchHunk, cfg: ApplyPatchRuntimeOptions): ResolvedPreparedUpdate;
+export declare function stageAddedText(contents: string): string;

package/dist/hooks/apply-patch/index.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+interface ToolExecuteBeforeInput {
+    tool: string;
+    directory?: string;
+}
+interface ToolExecuteBeforeOutput {
+    args?: {
+        patchText?: unknown;
+        [key: string]: unknown;
+    };
+}
+export declare function createApplyPatchHook(ctx: PluginInput): {
+    'tool.execute.before': (input: ToolExecuteBeforeInput, output: ToolExecuteBeforeOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/apply-patch/matching.d.ts

@@ -0,0 +1,26 @@
+import type { LineComparator, MatchComparatorName, RescueResult, SeekHit } from './types';
+export type PreparedAutoRescueTarget = {
+    exact: string;
+    unicode: string;
+    trimEnd: string;
+    unicodeTrimEnd: string;
+};
+export declare function equalExact(a: string, b: string): boolean;
+export declare function equalUnicodeExact(a: string, b: string): boolean;
+export declare function equalTrimEnd(a: string, b: string): boolean;
+export declare function equalUnicodeTrimEnd(a: string, b: string): boolean;
+export declare function equalTrim(a: string, b: string): boolean;
+export declare function equalUnicodeTrim(a: string, b: string): boolean;
+export declare const autoRescueComparators: LineComparator[];
+export declare function prepareAutoRescueTarget(target: string): PreparedAutoRescueTarget;
+export declare function matchPreparedAutoRescueComparator(candidate: string, target: PreparedAutoRescueTarget): MatchComparatorName | undefined;
+export declare const permissiveComparators: LineComparator[];
+export declare function seekMatch(lines: string[], pattern: string[], start: number, eof?: boolean): SeekHit | undefined;
+export declare function seek(lines: string[], pattern: string[], start: number, eof?: boolean): number;
+export declare function list(lines: string[], pattern: string[], start: number, same: LineComparator): number[];
+export declare function sameRescueLine(a: string, b: string): boolean;
+export declare function prefix(old_lines: string[], new_lines: string[]): number;
+export declare function suffix(old_lines: string[], new_lines: string[], prefixLength: number): number;
+export declare function rescueByPrefixSuffix(lines: string[], old_lines: string[], new_lines: string[], start: number): RescueResult;
+export declare function score(a: string[], b: string[]): number;
+export declare function rescueByLcs(lines: string[], old_lines: string[], new_lines: string[], start: number): RescueResult;

package/dist/hooks/apply-patch/operations.d.ts

@@ -0,0 +1,3 @@
+export { parseValidatedPatch } from './execution-context';
+export { applyPreparedChanges, preparePatchChanges } from './prepared-changes';
+export { rewritePatch, rewritePatchText } from './rewrite';

package/dist/hooks/apply-patch/patch.d.ts

@@ -0,0 +1,2 @@
+export { parsePatch } from './codec';
+export { preparePatchChanges, rewritePatch, rewritePatchText, } from './operations';

package/dist/hooks/apply-patch/prepared-changes.d.ts

@@ -0,0 +1,17 @@
+import type { ApplyPatchRuntimeOptions, PreparedChange } from './types';
+export declare function preparePatchChanges(root: string, patchText: string, cfg: ApplyPatchRuntimeOptions, worktree?: string): Promise<PreparedChange[]>;
+/**
+ * Internal best-effort helper that applies the output of
+ * `preparePatchChanges()`: it snapshots all touched paths first and uses
+ * temp + rename for writes to regular files. It is not a universal multi-file
+ * transaction and is not perfect against concurrent external interference,
+ * but it avoids leaving silent partial states on normal apply failures.
+ *
+ * Contract: although it is exported for local tests/helpers, its expected
+ * input is the already prepared output of `preparePatchChanges()`. If it
+ * receives manual arrays, it revalidates the basic shape
+ * (types/text/normalized absolute paths) and filesystem invariants: it
+ * rejects updates/deletes/moves whose source does not exist, and add/move
+ * operations whose destination is already occupied.
+ */
+export declare function applyPreparedChanges(changes: PreparedChange[]): Promise<void>;

package/dist/hooks/apply-patch/resolution.d.ts

@@ -0,0 +1,19 @@
+import type { ApplyPatchRuntimeOptions, MatchHit, PatchChunk, ResolvedChunk } from './types';
+export declare function readFileLines(file: string): Promise<string[]>;
+export declare function resolveChunkStart(lines: string[], chunk: PatchChunk, start: number): number;
+export declare function locateChunk(lines: string[], file: string, chunk: PatchChunk, start: number, cfg: ApplyPatchRuntimeOptions): ResolvedChunk;
+export declare function applyHits(lines: string[], hits: MatchHit[], eol?: '\n' | '\r\n', hasFinalNewline?: boolean): string;
+export declare function resolveUpdateChunks(file: string, chunks: PatchChunk[], cfg: ApplyPatchRuntimeOptions): Promise<{
+    lines: string[];
+    resolved: ResolvedChunk[];
+    eol: '\n' | '\r\n';
+    hasFinalNewline: boolean;
+}>;
+export declare function deriveNewContentFromText(file: string, text: string, chunks: PatchChunk[], cfg: ApplyPatchRuntimeOptions): string;
+export declare function resolveUpdateChunksFromText(file: string, text: string, chunks: PatchChunk[], cfg: ApplyPatchRuntimeOptions): {
+    lines: string[];
+    resolved: ResolvedChunk[];
+    eol: '\n' | '\r\n';
+    hasFinalNewline: boolean;
+};
+export declare function deriveNewContent(file: string, chunks: PatchChunk[], cfg: ApplyPatchRuntimeOptions): Promise<string>;

package/dist/hooks/apply-patch/rewrite.d.ts

@@ -0,0 +1,7 @@
+import type { ApplyPatchRuntimeOptions } from './types';
+export type RewritePatchResult = {
+    patchText: string;
+    changed: boolean;
+};
+export declare function rewritePatch(root: string, patchText: string, cfg: ApplyPatchRuntimeOptions, worktree?: string): Promise<RewritePatchResult>;
+export declare function rewritePatchText(root: string, patchText: string, cfg: ApplyPatchRuntimeOptions, worktree?: string): Promise<string>;

package/dist/hooks/apply-patch/test-helpers.d.ts

@@ -0,0 +1,6 @@
+import type { ApplyPatchRuntimeOptions } from './types';
+export declare const DEFAULT_OPTIONS: ApplyPatchRuntimeOptions;
+export declare function createTempDir(prefix?: string): Promise<string>;
+export declare function writeFixture(root: string, relativePath: string, contents: string): Promise<void>;
+export declare function readText(root: string, relativePath: string): Promise<string>;
+export declare function applyPatch(root: string, patchText: string, cfg?: ApplyPatchRuntimeOptions): Promise<void>;

package/dist/hooks/apply-patch/types.d.ts

@@ -0,0 +1,80 @@
+export type ApplyPatchRuntimeOptions = {
+    prefixSuffix: boolean;
+    lcsRescue: boolean;
+};
+export type ApplyPatchErrorKind = 'blocked' | 'validation' | 'verification' | 'internal';
+export type ApplyPatchErrorCode = 'malformed_patch' | 'outside_workspace' | 'verification_failed' | 'internal_unexpected';
+export type ApplyPatchRescueStrategy = 'prefix/suffix' | 'lcs' | 'anchor';
+export type MatchComparatorName = 'exact' | 'unicode' | 'trim-end' | 'unicode-trim-end' | 'trim' | 'unicode-trim';
+export type PatchChunk = {
+    old_lines: string[];
+    new_lines: string[];
+    change_context?: string;
+    is_end_of_file?: boolean;
+};
+export type AddPatchHunk = {
+    type: 'add';
+    path: string;
+    contents: string;
+};
+export type DeletePatchHunk = {
+    type: 'delete';
+    path: string;
+};
+export type UpdatePatchHunk = {
+    type: 'update';
+    path: string;
+    move_path?: string;
+    chunks: PatchChunk[];
+};
+export type PatchHunk = AddPatchHunk | DeletePatchHunk | UpdatePatchHunk;
+export type ParsedPatch = {
+    hunks: PatchHunk[];
+};
+export type AddPreparedChange = {
+    type: 'add';
+    file: string;
+    text: string;
+};
+export type DeletePreparedChange = {
+    type: 'delete';
+    file: string;
+};
+export type UpdatePreparedChange = {
+    type: 'update';
+    file: string;
+    move?: string;
+    text: string;
+};
+export type PreparedChange = AddPreparedChange | DeletePreparedChange | UpdatePreparedChange;
+export type MatchHit = {
+    start: number;
+    del: number;
+    add: string[];
+};
+export type SeekHit = {
+    index: number;
+    comparator: MatchComparatorName;
+    exact: boolean;
+};
+export type ResolvedChunk = {
+    hit: MatchHit;
+    old_lines: string[];
+    canonical_old_lines: string[];
+    canonical_new_lines: string[];
+    canonical_change_context?: string;
+    resolved_is_end_of_file: boolean;
+    rewritten: boolean;
+    strategy?: ApplyPatchRescueStrategy;
+    matchComparator?: MatchComparatorName;
+};
+export type RescueResult = {
+    kind: 'miss';
+} | {
+    kind: 'ambiguous';
+    phase: 'prefix_suffix' | 'lcs';
+} | {
+    kind: 'match';
+    hit: MatchHit;
+};
+export type LineComparator = (a: string, b: string) => boolean;

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

@@ -0,0 +1,11 @@
+interface AutoUpdateInstallContext {
+    installDir: string;
+    packageJsonPath: string;
+}
+export declare function resolveInstallContext(runtimePackageJsonPath?: string | null): AutoUpdateInstallContext | null;
+/**
+ * Prepares the current install root for a clean re-install of the target version.
+ * Returns the install directory to run `bun install` in.
+ */
+export declare function preparePackageUpdate(version: string, packageName?: string, runtimePackageJsonPath?: string | null): string | null;
+export {};

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

@@ -0,0 +1,32 @@
+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;
+/**
+ * Resolves the package.json for the currently running plugin bundle.
+ */
+export declare function getCurrentRuntimePackageJsonPath(currentModuleUrl?: 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 = "opencode-dux";
+export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/opencode-dux/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,18 @@
+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 declare function getAutoUpdateInstallDir(): string;
+export type { AutoUpdateCheckerOptions } from './types';