goatcode-sh 0.0.1 → 0.1.3

package/dist/plugin/compositor.d.ts

@@ -0,0 +1,9 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { AggregatedPlugins } from "../types/plugin";
+/**
+ * Compose aggregated plugin contributions into a complete OpenCode Hooks instance.
+ * Produces all handler slots (1 tool record + function hooks).
+ * The `config` slot injects agents before delegating to registered hooks.
+ * Slots without registered handlers are defined as no-ops.
+ */
+export declare function compose(aggregated: AggregatedPlugins): Hooks;

package/dist/plugin/index.d.ts

@@ -0,0 +1 @@
+export { compose } from "./compositor";

package/dist/plugin-api/define-plugin.d.ts

@@ -0,0 +1,33 @@
+import type { PluginDefinition } from "../types/plugin";
+/**
+ * Define a GoatCode micro-plugin.
+ *
+ * This is the primary authoring API for creating plugins.
+ * Both internal GoatCode plugins and external plugins use this function.
+ *
+ * @example
+ * ```typescript
+ * import { definePlugin } from "goatcode-sh"
+ *
+ * export default definePlugin({
+ *   name: "my-plugin",
+ *   version: "1.0.0",
+ *   hooks: {
+ *     "tool.execute.before": async (input, output) => {
+ *       // called before every tool execution
+ *     },
+ *   },
+ *   tools: {
+ *     my_tool: {
+ *       description: "Does something useful",
+ *       parameters: { type: "object", properties: {} },
+ *       execute: async (args) => "result",
+ *     },
+ *   },
+ * })
+ * ```
+ *
+ * @param definition - The plugin definition object
+ * @returns The definition unchanged (typed identity function for IDE autocomplete)
+ */
+export declare function definePlugin(definition: PluginDefinition): PluginDefinition;

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

@@ -0,0 +1,3 @@
+export { definePlugin } from "./define-plugin";
+export type { PluginDefinition, AggregatedPlugins, OpenCodeContext, OpenCodePluginInstance, PluginHookHandler, PluginHookContributions, AgentConfig, AgentMode, AgentFactory, BuiltinAgentName, AgentOverrideConfig, ToolDefinition, ToolsRecord, HookEventName, HookHandler, HookPriority, BuiltinCategoryName, CategoryConfig, AvailableCategory, GoatCodeConfig, AgentOverrides, HookName, } from "./types";
+export { HOOK_EVENT_NAMES, HOOK_EVENT_NAMES as HOOK_NAMES } from "./types";

package/dist/plugin-api/types.d.ts

@@ -0,0 +1,10 @@
+export type { PluginDefinition, AggregatedPlugins, OpenCodeContext, OpenCodePluginInstance, PluginHookHandler, } from "../types/plugin";
+export type { PluginHookContributions } from "../types/hook";
+export type { AgentConfig, AgentMode, AgentFactory, BuiltinAgentName, AgentOverrideConfig, } from "../types/agent";
+export type { ToolDefinition, ToolsRecord } from "../types/tool";
+export type { HookEventName, HookHandler, HookPriority } from "../types/hook";
+export { HOOK_EVENT_NAMES } from "../types/hook";
+export { HOOK_EVENT_NAMES as HOOK_NAMES } from "../types/hook";
+export type HookName = import("../types/hook").HookEventName;
+export type { BuiltinCategoryName, CategoryConfig, AvailableCategory } from "../types/category";
+export type { GoatCodeConfig, AgentOverrides } from "../types/config";

package/dist/registry/agent-aggregator.d.ts

@@ -0,0 +1,3 @@
+import type { PluginDefinition } from "../types/plugin";
+import type { PluginAgentContribution } from "../types/agent";
+export declare function aggregateAgents(plugins: PluginDefinition[], disabledAgents?: string[]): Record<string, PluginAgentContribution>;

package/dist/registry/contribution-aggregator.d.ts

@@ -0,0 +1,10 @@
+import type { PluginDefinition } from "../types/plugin";
+type ContributionKey = "agents" | "tools" | "hooks";
+type ConflictMode = "replace" | "append";
+type AggregateResult<K extends ContributionKey, T> = K extends "hooks" ? Map<string, T[]> : Record<string, T>;
+interface AggregateOptions {
+    disabled?: string[];
+    onConflict: ConflictMode;
+}
+export declare function aggregateContributions<K extends ContributionKey, T>(plugins: PluginDefinition[], key: K, options: AggregateOptions): AggregateResult<K, T>;
+export {};

package/dist/registry/dependency-resolver.d.ts

@@ -0,0 +1,3 @@
+import type { PluginDefinition } from "../types/plugin";
+import type { ResolutionResult } from "./types";
+export declare function resolvePluginOrder(plugins: PluginDefinition[]): ResolutionResult;

package/dist/registry/hook-aggregator.d.ts

@@ -0,0 +1,2 @@
+import type { PluginDefinition, PluginHookHandler } from "../types/plugin";
+export declare function aggregateHooks(plugins: PluginDefinition[], disabledHooks?: string[]): Map<string, PluginHookHandler[]>;

package/dist/registry/index.d.ts

@@ -0,0 +1,6 @@
+export { aggregateAgents } from "./agent-aggregator";
+export { resolvePluginOrder } from "./dependency-resolver";
+export { aggregateHooks } from "./hook-aggregator";
+export { PluginRegistry } from "./plugin-registry";
+export { aggregateTools } from "./tool-aggregator";
+export type { ResolutionResult, ResolvedPlugin } from "./types";

package/dist/registry/plugin-registry.d.ts

@@ -0,0 +1,16 @@
+import type { AggregatedPlugins, OpenCodeContext, PluginDefinition } from "../types/plugin";
+export interface AggregateOptions {
+    disabledAgents?: string[];
+    disabledHooks?: string[];
+    disabledTools?: string[];
+}
+export declare class PluginRegistry {
+    private readonly plugins;
+    register(plugin: PluginDefinition): void;
+    resolve(): PluginDefinition[];
+    aggregate(resolvedOrder: PluginDefinition[], options?: AggregateOptions): AggregatedPlugins;
+    setup(resolvedOrder: PluginDefinition[], ctx: OpenCodeContext): Promise<PluginDefinition[]>;
+    teardown(resolvedOrder: PluginDefinition[]): Promise<void>;
+    get registeredNames(): string[];
+    get size(): number;
+}

package/dist/registry/tool-aggregator.d.ts

@@ -0,0 +1,3 @@
+import type { PluginDefinition } from "../types/plugin";
+import type { PluginToolContribution } from "../types/tool";
+export declare function aggregateTools(plugins: PluginDefinition[], disabledTools?: string[]): Record<string, PluginToolContribution>;

package/dist/registry/types.d.ts

@@ -0,0 +1,9 @@
+import type { PluginDefinition } from "../types/plugin";
+export interface ResolvedPlugin {
+    plugin: PluginDefinition;
+    order: number;
+}
+export interface ResolutionResult {
+    order: PluginDefinition[];
+    map: Map<string, ResolvedPlugin>;
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,7 @@
+export { POLLING_INTERVAL_MS, STABILITY_REQUIRED_POLLS, createPollState, checkStability, pollUntilStable, initBackgroundAgent, getBackgroundAgent, resetBackgroundAgent, BackgroundAgentManager, } from "../features/background-agent";
+export type { BackgroundTask, BackgroundTaskStatus, LaunchInput, } from "../features/background-agent";
+export type { PollState, PollSnapshot } from "../features/background-agent/poller";
+export { setSessionState, getSessionState, deleteSessionState, clearSessionStore, consumeNewMessages, resetMessageCursor, setSessionTools, getSessionTools, deleteSessionTools, clearSessionTools, } from "../features/session-state";
+export type { SessionState, CursorMessage } from "../features/session-state";
+export { DEFAULT_CATEGORIES, DEFAULT_CATEGORY_DEFINITIONS, CategoryResolver, resolveCategory, CATEGORY_PROMPT_APPENDS, } from "../features/categories";
+export type { CategoryDefinition, CategoryName, CategoryOverrides } from "../features/categories";

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

@@ -0,0 +1,4 @@
+export declare function getDataDir(): string;
+export declare function getCacheDir(): string;
+export declare function getOpenCodeStorageDir(): string;
+export declare function getGoatCodeCacheDir(): 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/fallback-chain.d.ts

@@ -0,0 +1 @@
+export declare function buildFallbackChain(configFallbacks: string | string[] | undefined, defaultChain: string[]): string[];

package/dist/shared/index.d.ts

@@ -0,0 +1,19 @@
+export { log, getLogFilePath } from "./logger";
+export { deepMerge, isPlainObject } from "./deep-merge";
+export { toSnakeCase } from "./snake-case";
+export { truncateDescription } from "./truncate-description";
+export { getDataDir, getCacheDir, getOpenCodeStorageDir, getGoatCodeCacheDir } from "./data-path";
+export { safeCreateHook } from "./safe-create-hook";
+export { normalizeModel, parseModelId, normalizeAndQualifyModel } from "./model-normalization";
+export { isModelAvailable } from "./model-availability";
+export { buildFallbackChain } from "./fallback-chain";
+export { resolveModel } from "./model-resolution-pipeline";
+export type { ModelResolutionInput, ModelResolutionSource, ModelResolutionResult, } from "./model-resolution-pipeline";
+export { toPlatformModel, toCanonicalModel, registerPlatformMappings, getKnownPlatforms, } from "./model-prefix-map";
+export type { PlatformId, BuiltinPlatformId } from "./model-prefix-map";
+export { resolveProvider, qualifyModel, isQualifiedModel, findProvidersForModel, setProviderPriority, getProviderPriority, setDefaultPreferredProvider, getDefaultPreferredProvider, registerProviderModelMap, unregisterProviderModelMap, resetProviderRegistry, } from "./provider-registry";
+export type { ProviderResolutionResult } from "./provider-registry";
+export { buildDiscoveryIndex, initializeDiscovery, getDiscovery, resetDiscovery, } from "./provider-discovery";
+export type { ProviderListResponse, ProviderModelEntry, DiscoveryResult, } from "./provider-discovery";
+export { buildModelsDevIndex, fetchModelsDevData, resolveWithModelsDevData, createModelsDevCache, } from "./models-dev";
+export type { ModelsDevModel, ModelsDevProvider, ModelsDevIndex, ModelsDevCache, } from "./models-dev";

package/dist/shared/logger.d.ts

@@ -0,0 +1,4 @@
+/** Write a structured log entry to the goatcode log file. */
+export declare function log(message: string, data?: unknown): void;
+/** Returns the absolute path to the log file. */
+export declare function getLogFilePath(): string;

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

@@ -0,0 +1 @@
+export declare function isModelAvailable(model: string, availableModels: Set<string>): boolean;

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

@@ -0,0 +1,6 @@
+export declare function normalizeModel(model: string | undefined): string | undefined;
+export declare function parseModelId(model: string): {
+    provider: string;
+    modelId: string;
+} | undefined;
+export declare function normalizeAndQualifyModel(model: string | undefined, preferredProvider?: string): string | undefined;

package/dist/shared/model-prefix-map.d.ts

@@ -0,0 +1,11 @@
+export type BuiltinPlatformId = "direct" | "zen";
+export type PlatformId = BuiltinPlatformId | (string & {});
+type PrefixMapping = {
+    canonical: string;
+    platform: string;
+};
+export declare function toPlatformModel(canonicalModel: string, platform: PlatformId): string;
+export declare function toCanonicalModel(platformModel: string, platform: PlatformId): string;
+export declare function registerPlatformMappings(platform: string, mappings: PrefixMapping[]): void;
+export declare function getKnownPlatforms(): string[];
+export {};

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

@@ -0,0 +1,14 @@
+export type ModelResolutionInput = {
+    override?: string;
+    categoryDefault?: string;
+    fallbackChain?: string[];
+    systemDefault?: string;
+    availableModels?: Set<string>;
+    preferredProvider?: string;
+};
+export type ModelResolutionSource = "override" | "category-default" | "fallback" | "system-default";
+export type ModelResolutionResult = {
+    model: string;
+    source: ModelResolutionSource;
+};
+export declare function resolveModel(input: ModelResolutionInput): ModelResolutionResult | undefined;

package/dist/shared/models-dev.d.ts

@@ -0,0 +1,29 @@
+export type ModelsDevModel = {
+    id: string;
+    name: string;
+    family?: string;
+    provider?: {
+        npm: string;
+    };
+    [key: string]: unknown;
+};
+export type ModelsDevProvider = {
+    id: string;
+    name: string;
+    npm?: string;
+    models: Record<string, ModelsDevModel>;
+    [key: string]: unknown;
+};
+export type ModelsDevIndex = {
+    byPlatformModel: Map<string, string>;
+    byCanonical: Map<string, Set<string>>;
+    providers: Map<string, ModelsDevProvider>;
+};
+export type ModelsDevCache = {
+    get: () => Promise<ModelsDevIndex>;
+    clear: () => void;
+};
+export declare function buildModelsDevIndex(data: Record<string, ModelsDevProvider>): ModelsDevIndex;
+export declare function fetchModelsDevData(): Promise<ModelsDevIndex>;
+export declare function resolveWithModelsDevData(platformModelId: string, index: ModelsDevIndex): string | undefined;
+export declare function createModelsDevCache(ttlMs?: number, fetchFn?: () => Promise<ModelsDevIndex>): ModelsDevCache;

package/dist/shared/provider-discovery.d.ts

@@ -0,0 +1,28 @@
+export type ProviderListResponse = {
+    readonly all: readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly env: readonly string[];
+        readonly npm?: string;
+        readonly api?: string;
+        readonly models: Record<string, {
+            readonly id: string;
+            readonly name: string;
+        }>;
+    }[];
+    readonly default: Record<string, string>;
+    readonly connected: readonly string[];
+};
+export type ProviderModelEntry = {
+    readonly providerId: string;
+    readonly modelId: string;
+};
+export type DiscoveryResult = {
+    readonly connectedProviders: ReadonlySet<string>;
+    readonly modelIndex: ReadonlyMap<string, ProviderModelEntry[]>;
+    readonly providerModels: ReadonlyMap<string, ReadonlySet<string>>;
+};
+export declare function buildDiscoveryIndex(response: ProviderListResponse): DiscoveryResult;
+export declare function initializeDiscovery(result: DiscoveryResult): void;
+export declare function getDiscovery(): DiscoveryResult | undefined;
+export declare function resetDiscovery(): void;

package/dist/shared/provider-registry.d.ts

@@ -0,0 +1,16 @@
+import { type ProviderModelEntry } from "./provider-discovery";
+export interface ProviderResolutionResult {
+    readonly qualifiedModel: string;
+    readonly providerId: string;
+}
+export declare function setProviderPriority(priority: string[]): void;
+export declare function getProviderPriority(): readonly string[];
+export declare function setDefaultPreferredProvider(provider: string | undefined): void;
+export declare function getDefaultPreferredProvider(): string | undefined;
+export declare function registerProviderModelMap(providerId: string, modelMap: Record<string, string>): void;
+export declare function unregisterProviderModelMap(providerId: string): boolean;
+export declare function isQualifiedModel(model: string): boolean;
+export declare function resetProviderRegistry(): void;
+export declare function findProvidersForModel(bareModel: string): ProviderModelEntry[];
+export declare function resolveProvider(model: string, preferredProvider?: string): ProviderResolutionResult | undefined;
+export declare function qualifyModel(model: string, preferredProvider?: string): string;

package/dist/shared/safe-create-hook.d.ts

@@ -0,0 +1,3 @@
+export declare function safeCreateHook<T>(name: string, factory: () => T, options?: {
+    enabled?: boolean;
+}): T | null;

package/dist/shared/snake-case.d.ts

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

package/dist/shared/truncate-description.d.ts

@@ -0,0 +1 @@
+export declare function truncateDescription(text: string, maxLength?: number): string;

package/dist/test-utils/index.d.ts

@@ -0,0 +1,6 @@
+export { createMockPluginContext } from "./mock-plugin-context";
+export { createMockAgentConfig } from "./mock-agent-config";
+export * from "./mock-hook-inputs";
+export * from "./mock-hook-outputs";
+export { createMockToolContext } from "./mock-tool-context";
+export { createMockSdkClient } from "./mock-sdk-client";

package/dist/test-utils/mock-agent-config.d.ts

@@ -0,0 +1,5 @@
+import type { AgentConfig } from "../types/agent";
+/**
+ * Create a minimal mock AgentConfig for unit testing.
+ */
+export declare function createMockAgentConfig(overrides?: Partial<AgentConfig>): AgentConfig;

package/dist/test-utils/mock-hook-inputs.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Mock factory functions for all 16 hook event input shapes.
+ * Each factory: `make{EventName}Input(overrides?)` returning the typed input object.
+ */
+export declare function makeToolInput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeConfigInput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeChatMessageInput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeChatParamsInput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeChatHeadersInput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeEventInput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeToolExecuteBeforeInput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeToolExecuteAfterInput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeExperimentalChatMessagesTransformInput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeExperimentalChatSystemTransformInput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeToolDefinitionInput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makePermissionAskInput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeCommandExecuteBeforeInput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeShellEnvInput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeExperimentalSessionCompactingInput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeExperimentalTextCompleteInput(overrides?: Record<string, unknown>): Record<string, unknown>;

package/dist/test-utils/mock-hook-outputs.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Mock factory functions for all 16 hook event output shapes.
+ * Outputs are mutable objects that hooks modify in-place.
+ */
+export declare function makeToolOutput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeConfigOutput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeChatMessageOutput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeChatParamsOutput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeChatHeadersOutput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeEventOutput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeToolExecuteBeforeOutput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeToolExecuteAfterOutput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeExperimentalChatMessagesTransformOutput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeExperimentalChatSystemTransformOutput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeToolDefinitionOutput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makePermissionAskOutput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeCommandExecuteBeforeOutput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeShellEnvOutput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeExperimentalSessionCompactingOutput(overrides?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeExperimentalTextCompleteOutput(overrides?: Record<string, unknown>): Record<string, unknown>;

package/dist/test-utils/mock-plugin-context.d.ts

@@ -0,0 +1,6 @@
+import type { OpenCodeContext } from "../types/plugin";
+/**
+ * Create a minimal mock OpenCodeContext for unit testing.
+ * Provides sensible no-op defaults for all required fields.
+ */
+export declare function createMockPluginContext(overrides?: Partial<OpenCodeContext>): OpenCodeContext;

package/dist/test-utils/mock-sdk-client.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Create a minimal mock SDK client for unit testing.
+ * Provides mock methods for all client operations.
+ */
+export declare function createMockSdkClient(overrides?: Record<string, unknown>): {
+    session: {
+        create: import("bun:test").Mock<() => Promise<{
+            data: {
+                id: string;
+            };
+            error: undefined;
+        }>>;
+        promptAsync: import("bun:test").Mock<() => Promise<{
+            data: {};
+            error: undefined;
+        }>>;
+        status: import("bun:test").Mock<() => Promise<{
+            data: {
+                "sync-session-123": {
+                    type: string;
+                };
+            };
+        }>>;
+        messages: import("bun:test").Mock<() => Promise<{
+            data: {
+                role: string;
+                content: string;
+            }[];
+        }>>;
+        delete: import("bun:test").Mock<() => Promise<{}>>;
+    };
+    getProviders: import("bun:test").Mock<() => Promise<never[]>>;
+    getModels: import("bun:test").Mock<() => Promise<never[]>>;
+    getSession: import("bun:test").Mock<() => Promise<null>>;
+    listSessions: import("bun:test").Mock<() => Promise<never[]>>;
+    createSession: import("bun:test").Mock<() => Promise<{
+        id: string;
+        title: string;
+    }>>;
+    sendMessage: import("bun:test").Mock<() => Promise<{}>>;
+};

package/dist/test-utils/mock-tool-context.d.ts

@@ -0,0 +1,6 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+/**
+ * Create a minimal mock tool context for unit testing.
+ * Provides sensible defaults for all required context fields.
+ */
+export declare function createMockToolContext(overrides?: Partial<Parameters<ToolDefinition["execute"]>[1]>): Parameters<ToolDefinition["execute"]>[1];

package/dist/tools/ast-grep/index.d.ts

@@ -0,0 +1,4 @@
+export { astGrepSearchPlugin } from "./search/plugin";
+export { astGrepReplacePlugin } from "./replace/plugin";
+export { createAstGrepSearchTool, executeAstGrepSearch } from "./search/handler";
+export { createAstGrepReplaceTool, executeAstGrepReplace } from "./replace/handler";

package/dist/tools/ast-grep/replace/handler.d.ts

@@ -0,0 +1,7 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import type { CommandRunner } from "../search/handler";
+import type { AstGrepReplaceArgs, AstGrepReplaceOutput } from "./types";
+export declare function executeAstGrepReplace(args: AstGrepReplaceArgs, context: {
+    directory: string;
+}, runner?: CommandRunner): Promise<AstGrepReplaceOutput>;
+export declare function createAstGrepReplaceTool(runner?: CommandRunner): ToolDefinition;

package/dist/tools/ast-grep/replace/plugin.d.ts

@@ -0,0 +1 @@
+export declare const astGrepReplacePlugin: import("../../../plugin-api").PluginDefinition;

package/dist/tools/ast-grep/replace/types.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export declare const astGrepReplaceArgsSchema: {
+    pattern: z.ZodString;
+    rewrite: z.ZodString;
+    lang: z.ZodEnum<{
+        bash: "bash";
+        json: "json";
+        c: "c";
+        cpp: "cpp";
+        csharp: "csharp";
+        css: "css";
+        elixir: "elixir";
+        go: "go";
+        haskell: "haskell";
+        html: "html";
+        java: "java";
+        javascript: "javascript";
+        kotlin: "kotlin";
+        lua: "lua";
+        nix: "nix";
+        php: "php";
+        python: "python";
+        ruby: "ruby";
+        rust: "rust";
+        scala: "scala";
+        solidity: "solidity";
+        swift: "swift";
+        typescript: "typescript";
+        tsx: "tsx";
+        yaml: "yaml";
+    }>;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    globs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+};
+export type AstGrepReplaceArgs = z.infer<z.ZodObject<typeof astGrepReplaceArgsSchema>>;
+export type AstGrepReplaceOutput = string;

package/dist/tools/ast-grep/search/handler.d.ts

@@ -0,0 +1,14 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import type { AstGrepSearchArgs, AstGrepSearchOutput } from "./types";
+type CommandResult = {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+};
+export type CommandRunner = (command: string[], cwd: string) => Promise<CommandResult>;
+export declare function runCommand(command: string[], cwd: string): Promise<CommandResult>;
+export declare function executeAstGrepSearch(args: AstGrepSearchArgs, context: {
+    directory: string;
+}, runner?: CommandRunner): Promise<AstGrepSearchOutput>;
+export declare function createAstGrepSearchTool(runner?: CommandRunner): ToolDefinition;
+export {};

package/dist/tools/ast-grep/search/plugin.d.ts

@@ -0,0 +1 @@
+export declare const astGrepSearchPlugin: import("../../../plugin-api").PluginDefinition;

package/dist/tools/ast-grep/search/types.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export declare const AST_GREP_CLI_LANGUAGES: readonly ["bash", "c", "cpp", "csharp", "css", "elixir", "go", "haskell", "html", "java", "javascript", "json", "kotlin", "lua", "nix", "php", "python", "ruby", "rust", "scala", "solidity", "swift", "typescript", "tsx", "yaml"];
+export declare const astGrepSearchArgsSchema: {
+    pattern: z.ZodString;
+    lang: z.ZodEnum<{
+        bash: "bash";
+        json: "json";
+        c: "c";
+        cpp: "cpp";
+        csharp: "csharp";
+        css: "css";
+        elixir: "elixir";
+        go: "go";
+        haskell: "haskell";
+        html: "html";
+        java: "java";
+        javascript: "javascript";
+        kotlin: "kotlin";
+        lua: "lua";
+        nix: "nix";
+        php: "php";
+        python: "python";
+        ruby: "ruby";
+        rust: "rust";
+        scala: "scala";
+        solidity: "solidity";
+        swift: "swift";
+        typescript: "typescript";
+        tsx: "tsx";
+        yaml: "yaml";
+    }>;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    globs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    context: z.ZodOptional<z.ZodNumber>;
+};
+export type AstGrepSearchArgs = z.infer<z.ZodObject<typeof astGrepSearchArgsSchema>>;
+export type AstGrepSearchOutput = string;

package/dist/tools/background-task/cancel/handler.d.ts

@@ -0,0 +1,4 @@
+import type { OpenCodeContext } from "../../../types/plugin";
+import type { BackgroundAgentManager } from "../../../runtime";
+import type { BackgroundCancelArgs } from "./types";
+export declare function handleBackgroundCancel(manager: BackgroundAgentManager, ctx: OpenCodeContext, args: BackgroundCancelArgs): Promise<string>;

package/dist/tools/background-task/cancel/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../../plugin-api").PluginDefinition;
+export default _default;

package/dist/tools/background-task/cancel/types.d.ts

@@ -0,0 +1,4 @@
+export interface BackgroundCancelArgs {
+    task_id?: string;
+    all?: boolean;
+}

package/dist/tools/background-task/index.d.ts

@@ -0,0 +1,2 @@
+export { default as backgroundOutputPlugin } from "./output/plugin";
+export { default as backgroundCancelPlugin } from "./cancel/plugin";

package/dist/tools/background-task/output/handler.d.ts

@@ -0,0 +1,3 @@
+import type { BackgroundAgentManager } from "../../../runtime";
+import type { BackgroundOutputArgs } from "./types";
+export declare function handleBackgroundOutput(manager: BackgroundAgentManager, args: BackgroundOutputArgs): Promise<string>;

package/dist/tools/background-task/output/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../../plugin-api").PluginDefinition;
+export default _default;

package/dist/tools/background-task/output/types.d.ts

@@ -0,0 +1,11 @@
+export interface BackgroundOutputArgs {
+    task_id: string;
+    block?: boolean;
+    timeout?: number;
+    full_session?: boolean;
+    include_thinking?: boolean;
+    message_limit?: number;
+    since_message_id?: string;
+    include_tool_results?: boolean;
+    thinking_max_chars?: number;
+}

package/dist/tools/bridge.d.ts

@@ -0,0 +1,7 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { PluginToolContribution } from "../types/tool";
+/**
+ * Convert the aggregated tools record into the SDK tool hook shape.
+ * Returns undefined if no tools are registered.
+ */
+export declare function buildToolHook(tools: Record<string, PluginToolContribution>): Hooks["tool"];

package/dist/tools/builtin-tools.d.ts

@@ -0,0 +1,2 @@
+import type { PluginDefinition } from "../types/plugin";
+export declare const BUILTIN_TOOL_PLUGINS: PluginDefinition[];

package/dist/tools/delegate-task/category-resolver.d.ts

@@ -0,0 +1,4 @@
+import type { CategoryConfig } from "../../types/category";
+import { type CategoryOverrides } from "../../runtime";
+export declare function resolveCategory(name: string, configOverrides?: CategoryOverrides): CategoryConfig | undefined;
+export declare function resolveCategoryWithDefaults(name: string, configOverrides?: CategoryOverrides): CategoryConfig | undefined;

package/dist/tools/delegate-task/constants.d.ts

@@ -0,0 +1,3 @@
+import type { CategoryConfig } from "./types";
+export declare const DEFAULT_CATEGORIES: Record<string, CategoryConfig>;
+export declare const CATEGORY_NAMES: string[];