@ahumandev/autocode 0.0.1

package/dist/tools/index.d.ts

@@ -0,0 +1,324 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import type { AutocodeSandboxConfig } from "../config";
+export declare function createTools(client: OpencodeClient, sandboxConfig?: AutocodeSandboxConfig): {
+    autocode_agent_swap: {
+        description: string;
+        args: {
+            agent: import("zod").ZodString;
+            prompt: import("zod").ZodString;
+        };
+        execute(args: {
+            agent: string;
+            prompt: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_concept_create: {
+        description: string;
+        args: {
+            label: import("zod").ZodOptional<import("zod").ZodString>;
+            concept: import("zod").ZodString;
+        };
+        execute(args: {
+            concept: string;
+            label?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_concept_list: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_concept_read: {
+        description: string;
+        args: {
+            label: import("zod").ZodString;
+        };
+        execute(args: {
+            label: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_criteria_accept: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+            actions: import("zod").ZodArray<import("zod").ZodString>;
+            proof: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+            actions: string[];
+            proof: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_criteria_list: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_criteria_remove: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_criteria_set: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+            metric: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+            metric: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_db_schemas: {
+        description: string;
+        args: {
+            db_key: import("zod").ZodString;
+        };
+        execute(args: {
+            db_key: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_db_table_read: {
+        description: string;
+        args: {
+            db_key: import("zod").ZodString;
+            fields: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            filters: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                key: import("zod").ZodString;
+                operator: import("zod").ZodEnum<{
+                    ">": ">";
+                    "=": "=";
+                    "!=": "!=";
+                    "<": "<";
+                    "<=": "<=";
+                    ">=": ">=";
+                    like: "like";
+                    in: "in";
+                    is_null: "is_null";
+                }>;
+                value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>>>;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            schema: import("zod").ZodString;
+            sort_asc: import("zod").ZodOptional<import("zod").ZodString>;
+            sort_desc: import("zod").ZodOptional<import("zod").ZodString>;
+            table: import("zod").ZodString;
+        };
+        execute(args: {
+            db_key: string;
+            schema: string;
+            table: string;
+            fields?: string[] | undefined;
+            filters?: {
+                key: string;
+                operator: ">" | "=" | "!=" | "<" | "<=" | ">=" | "like" | "in" | "is_null";
+                value?: unknown;
+            }[] | undefined;
+            limit?: number | undefined;
+            sort_asc?: string | undefined;
+            sort_desc?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_db_table: {
+        description: string;
+        args: {
+            db_key: import("zod").ZodString;
+            schema: import("zod").ZodString;
+            table: import("zod").ZodString;
+        };
+        execute(args: {
+            db_key: string;
+            schema: string;
+            table: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_db_tables: {
+        description: string;
+        args: {
+            db_key: import("zod").ZodString;
+            schema: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            db_key: string;
+            schema?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_dependencies: {
+        description: string;
+        args: Readonly<{
+            [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+        }>;
+        execute(args: Record<string, unknown>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_job_list: {
+        description: string;
+        args: {
+            filter: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            filter?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_job_execute: {
+        description: string;
+        args: {
+            agent: import("zod").ZodString;
+        };
+        execute(args: {
+            agent: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_job_status: {
+        description: string;
+        args: Readonly<{
+            [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+        }>;
+        execute(args: Record<string, unknown>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_shelve: {
+        description: string;
+        args: Readonly<{
+            [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+        }>;
+        execute(args: Record<string, unknown>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_logo_find: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_plan_read: {
+        description: string;
+        args: Readonly<{
+            [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+        }>;
+        execute(args: Record<string, unknown>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_plan_save: {
+        description: string;
+        args: {
+            problems: import("zod").ZodOptional<import("zod").ZodString>;
+            requirements: import("zod").ZodOptional<import("zod").ZodString>;
+            constraints: import("zod").ZodOptional<import("zod").ZodString>;
+            risks: import("zod").ZodOptional<import("zod").ZodString>;
+            proposal: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            problems?: string | undefined;
+            requirements?: string | undefined;
+            constraints?: string | undefined;
+            risks?: string | undefined;
+            proposal?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_sandbox_cli: {
+        description: string;
+        args: {
+            sandbox_name: import("zod").ZodString;
+            command: import("zod").ZodString;
+            working_dir: import("zod").ZodOptional<import("zod").ZodString>;
+            timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            sandbox_name: string;
+            command: string;
+            working_dir?: string | undefined;
+            timeout?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_sandbox_copy: {
+        description: string;
+        args: Readonly<{
+            [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+        }>;
+        execute(args: Record<string, unknown>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_sandbox_create: {
+        description: string;
+        args: {
+            sandbox_name: import("zod").ZodString;
+            distro: import("zod").ZodOptional<import("zod").ZodString>;
+            internet_enabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            sandbox_name: string;
+            distro?: string | undefined;
+            internet_enabled?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_sandbox_delete: {
+        description: string;
+        args: {
+            sandbox_name: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            sandbox_name?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_sandbox_edit: {
+        description: string;
+        args: Readonly<{
+            [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+        }>;
+        execute(args: Record<string, unknown>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_sandbox_glob: {
+        description: string;
+        args: Readonly<{
+            [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+        }>;
+        execute(args: Record<string, unknown>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_sandbox_grep: {
+        description: string;
+        args: Readonly<{
+            [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+        }>;
+        execute(args: Record<string, unknown>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_sandbox_read: {
+        description: string;
+        args: Readonly<{
+            [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+        }>;
+        execute(args: Record<string, unknown>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    autocode_session_create: {
+        description: string;
+        args: {
+            agent: import("zod").ZodString;
+            prompt: import("zod").ZodString;
+        };
+        execute(args: {
+            agent: string;
+            prompt: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    task_external: {
+        description: string;
+        args: {
+            target_directory: import("zod").ZodString;
+            prompt: import("zod").ZodString;
+        };
+        execute(args: {
+            target_directory: string;
+            prompt: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    task_resume: {
+        description: string;
+        args: {
+            task_id: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            task_id?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACtD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAA;AAuBtD,wBAAgB,WAAW,CAAC,MAAM,EAAE,cAAc,EAAE,aAAa,GAAE,qBAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkC5F"}

package/dist/tools/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/tools/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/tools/index.test.ts"],"names":[],"mappings":""}

package/dist/tools/task_external.d.ts

@@ -0,0 +1,35 @@
+import type { ToolContext } from "@opencode-ai/plugin";
+type TaskProjectDependencies = {
+    stat: (path: string) => Promise<{
+        isDirectory(): boolean;
+    }>;
+    realpath?: (path: string) => Promise<string>;
+    spawn: (command: string, args: string[], options: {
+        stdio: ["ignore", "pipe", "pipe"];
+        env?: NodeJS.ProcessEnv;
+    }) => {
+        stdout: {
+            setEncoding(encoding: BufferEncoding): unknown;
+            on(event: "data", listener: (chunk: string) => void): unknown;
+        };
+        stderr: {
+            setEncoding(encoding: BufferEncoding): unknown;
+            on(event: "data", listener: (chunk: string) => void): unknown;
+        };
+        on(event: "error", listener: (error: Error) => void): unknown;
+        on(event: "close", listener: (exitCode: number | null, signal: NodeJS.Signals | null) => void): unknown;
+    };
+};
+export declare function createTaskProjectTool(deps?: TaskProjectDependencies): {
+    description: string;
+    args: {
+        target_directory: import("zod").ZodString;
+        prompt: import("zod").ZodString;
+    };
+    execute(args: {
+        target_directory: string;
+        prompt: string;
+    }, context: ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};
+export {};
+//# sourceMappingURL=task_external.d.ts.map

package/dist/tools/task_external.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task_external.d.ts","sourceRoot":"","sources":["../../src/tools/task_external.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AActD,KAAK,uBAAuB,GAAG;IAC3B,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,WAAW,IAAI,OAAO,CAAA;KAAE,CAAC,CAAA;IAC3D,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IAC5C,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE;QAAE,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAA;KAAE,KAAK;QACjH,MAAM,EAAE;YACJ,WAAW,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAA;YAC9C,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAA;SAChE,CAAA;QACD,MAAM,EAAE;YACJ,WAAW,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAA;YAC9C,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAA;SAChE,CAAA;QACD,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,OAAO,CAAA;QAC7D,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,KAAK,IAAI,GAAG,OAAO,CAAA;KAC1G,CAAA;CACJ,CAAA;AA8ID,wBAAgB,qBAAqB,CAAC,IAAI,GAAE,uBAA6C;;;;;;;;;;EAiHxF"}

package/dist/tools/task_external.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=task_external.test.d.ts.map

package/dist/tools/task_external.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task_external.test.d.ts","sourceRoot":"","sources":["../../src/tools/task_external.test.ts"],"names":[],"mappings":""}

package/dist/tools/task_resume.d.ts

@@ -0,0 +1,12 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+export type { OpencodeClient };
+export declare function createTaskResumeTool(client: OpencodeClient): {
+    description: string;
+    args: {
+        task_id: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        task_id?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};
+//# sourceMappingURL=task_resume.d.ts.map

package/dist/tools/task_resume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task_resume.d.ts","sourceRoot":"","sources":["../../src/tools/task_resume.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAA6B,cAAc,EAAsD,MAAM,kBAAkB,CAAA;AA6CrI,YAAY,EAAE,cAAc,EAAE,CAAA;AAgW9B,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,cAAc;;;;;;;;EAsF1D"}

package/dist/tools/task_resume.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=task_resume.test.d.ts.map

package/dist/tools/task_resume.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task_resume.test.d.ts","sourceRoot":"","sources":["../../src/tools/task_resume.test.ts"],"names":[],"mappings":""}

package/dist/tools/test_context.d.ts

@@ -0,0 +1,5 @@
+import type { ToolContext } from "@opencode-ai/plugin";
+export declare function createNoopAsk(): ToolContext["ask"];
+export declare function createAskEffect(run: (request: unknown) => void | Promise<void>): ToolContext["ask"];
+export declare function createToolContext(overrides?: Partial<ToolContext>): ToolContext;
+//# sourceMappingURL=test_context.d.ts.map

package/dist/tools/test_context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_context.d.ts","sourceRoot":"","sources":["../../src/tools/test_context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAEtD,wBAAgB,aAAa,IAAI,WAAW,CAAC,KAAK,CAAC,CAElD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC,CAOnG;AAED,wBAAgB,iBAAiB,CAAC,SAAS,GAAE,OAAO,CAAC,WAAW,CAAM,GAAG,WAAW,CAanF"}

package/dist/utils/agent_swap.d.ts

@@ -0,0 +1,56 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import type { ModelTier, TierConfig } from "@/config";
+export declare const allowedAutocodeSessionCreateAgents: readonly ["assist", "auto", "research", "design"];
+export declare const allowedAutocodeSessionCreateAgentsText: string;
+export type AutocodeSessionCreateAgent = typeof allowedAutocodeSessionCreateAgents[number];
+type ValidatedAutocodeSessionCreateInput = {
+    prompt: string;
+    agent: AutocodeSessionCreateAgent;
+    title: string;
+};
+type ValidatedAutocodeAgentSwapInput = {
+    prompt: string;
+    agent: string;
+    title: string;
+};
+type InvalidAutocodeAgentSwapInput = {
+    error: string;
+    instruction: string;
+};
+type AutocodeAgentSessionPromptResult = {
+    sessionID: string;
+};
+type AutocodeAgentPromptDispatchResult = {
+    sessionID: string;
+};
+type ResolvedAgentModel = {
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    variant?: string;
+};
+type ResolvedAutocodeAgentSessionSettings = {
+    resolvedModel: ResolvedAgentModel;
+};
+export type AutocodeSessionClient = Pick<OpencodeClient, "session">;
+type AutocodeSessionApi = {
+    session: {
+        create: OpencodeClient["session"]["create"];
+        update: OpencodeClient["session"]["update"];
+        promptAsync: OpencodeClient["session"]["promptAsync"];
+    };
+};
+export declare function resolveTierModel(tier: ModelTier | undefined, tiers: Partial<Record<ModelTier, TierConfig>>): ResolvedAgentModel;
+export declare function deriveAutocodeAgentSwapTitle(prompt: string): string;
+export declare function validateAutocodeAgentSwapInput(rawPrompt: unknown, rawAgent: unknown): ValidatedAutocodeAgentSwapInput | InvalidAutocodeAgentSwapInput;
+export declare function validateAutocodeSessionCreateInput(rawPrompt: unknown, rawAgent: unknown): ValidatedAutocodeSessionCreateInput | InvalidAutocodeAgentSwapInput;
+export declare function dispatchAutocodeAgentPrompt(client: AutocodeSessionApi, directory: string, sessionID: string, agent: string, prompt: string, resolvedModel?: ResolvedAgentModel): Promise<AutocodeAgentPromptDispatchResult | InvalidAutocodeAgentSwapInput>;
+export declare function resolveAutocodeAgentSessionSettings(agent: string, worktree: string, directory: string): Promise<ResolvedAutocodeAgentSessionSettings | InvalidAutocodeAgentSwapInput>;
+export declare function createAutocodeSession(client: AutocodeSessionApi, directory: string, title: string, agent: string): Promise<AutocodeAgentSessionPromptResult | InvalidAutocodeAgentSwapInput>;
+export declare function createAutocodeSessionPrompt(client: AutocodeSessionApi, directory: string, agent: string, prompt: string, title: string, resolvedModel?: ResolvedAgentModel): Promise<AutocodeAgentSessionPromptResult | InvalidAutocodeAgentSwapInput>;
+export declare function createAutocodeSessionCreateSuccessResponse(agent: string, title: string, sessionID: string): string;
+export declare function createAutocodeAgentSwapSuccessResponse(agent: string, sessionID: string): string;
+export declare function swapCurrentAutocodeSession(client: AutocodeSessionApi, directory: string, sessionID: string, agent: string, prompt: string, resolvedModel?: ResolvedAgentModel): Promise<AutocodeAgentSessionPromptResult | InvalidAutocodeAgentSwapInput>;
+export {};
+//# sourceMappingURL=agent_swap.d.ts.map

package/dist/utils/agent_swap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent_swap.d.ts","sourceRoot":"","sources":["../../src/utils/agent_swap.ts"],"names":[],"mappings":"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"}

package/dist/utils/agent_swap.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=agent_swap.test.d.ts.map

package/dist/utils/agent_swap.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent_swap.test.d.ts","sourceRoot":"","sources":["../../src/utils/agent_swap.test.ts"],"names":[],"mappings":""}

package/dist/utils/autocode_dependencies.d.ts

@@ -0,0 +1,44 @@
+import { type SandboxDependencies } from "@/utils/sandbox";
+export declare const MINIMUM_OPENCODE_VERSION = "1.14.28";
+export type DependencyStatus = "ok" | "upgrade_required" | "missing" | "unknown" | "unsupported" | "unusable";
+export type DependencyReport = Record<string, unknown> & {
+    ok: boolean;
+    status: DependencyStatus;
+    guidance?: string;
+};
+export type DependencyInspectionContext = {
+    directory?: string;
+    worktree?: string;
+};
+export type DependencyDebugEvent = {
+    dependency: string;
+    stage: "path_check" | "config_paths" | "config_file" | "config_match" | "final";
+    status?: string;
+    reason?: string;
+    command?: string;
+    exists?: boolean;
+    path?: string;
+    version?: string;
+    config_path?: string;
+    config_paths?: string[];
+    outcome?: "read" | "missing" | "parse_failed";
+    error?: string;
+    section?: string;
+    key?: string;
+    detection_source?: "config_entry" | "launcher_command";
+    configured_command?: string;
+};
+export type DependencyInspectionOptions = {
+    debug?: boolean;
+    debugLog?: (event: DependencyDebugEvent) => void;
+};
+type Version = {
+    major: number;
+    minor: number;
+    patch: number;
+};
+export declare function parseTolerantSemver(output: string): Version | undefined;
+export declare function isAtLeastMinimumOpencodeVersion(version: Version, minimum?: Version): boolean;
+export declare function inspectAutocodeDependencies(deps?: SandboxDependencies, context?: DependencyInspectionContext, options?: DependencyInspectionOptions): Promise<Record<string, unknown>>;
+export {};
+//# sourceMappingURL=autocode_dependencies.d.ts.map

package/dist/utils/autocode_dependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocode_dependencies.d.ts","sourceRoot":"","sources":["../../src/utils/autocode_dependencies.ts"],"names":[],"mappings":"AAGA,OAAO,EAAgF,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAExI,eAAO,MAAM,wBAAwB,YAAY,CAAA;AAEjD,MAAM,MAAM,gBAAgB,GAAG,IAAI,GAAG,kBAAkB,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,GAAG,UAAU,CAAA;AAE7G,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IACrD,EAAE,EAAE,OAAO,CAAA;IACX,MAAM,EAAE,gBAAgB,CAAA;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACtC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IAC/B,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,YAAY,GAAG,cAAc,GAAG,aAAa,GAAG,cAAc,GAAG,OAAO,CAAA;IAC/E,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;IACvB,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,cAAc,CAAA;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,gBAAgB,CAAC,EAAE,cAAc,GAAG,kBAAkB,CAAA;IACtD,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACtC,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAA;CACnD,CAAA;AA6BD,KAAK,OAAO,GAAG;IACX,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CAChB,CAAA;AAqYD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CASvE;AAMD,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,UAAiD,GAAG,OAAO,CAEnI;AAmXD,wBAAsB,2BAA2B,CAC7C,IAAI,GAAE,mBAAgD,EACtD,OAAO,GAAE,2BAAgC,EACzC,OAAO,GAAE,2BAAgC,GAC1C,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAgClC"}

package/dist/utils/autocode_sandbox_helpers.d.ts

@@ -0,0 +1,12 @@
+import type { SandboxDependencies } from "@/utils/sandbox";
+export declare const bubblewrapQuickRootReadOnlyBinds: readonly ["/bin", "/usr", "/lib", "/lib64", "/sbin", "/etc/alternatives"];
+export declare const bubblewrapHostNetworkReadOnlyBinds: readonly ["/etc/resolv.conf", "/etc/nsswitch.conf", "/etc/hosts", "/etc/ssl", "/etc/pki", "/etc/ca-certificates", "/etc/ssl/certs/ca-certificates.crt"];
+export declare const bubblewrapQuickEtcReadOnlyBinds: readonly ["/etc/resolv.conf", "/etc/nsswitch.conf", "/etc/hosts", "/etc/ssl", "/etc/pki", "/etc/ca-certificates", "/etc/ssl/certs/ca-certificates.crt", "/etc/passwd", "/etc/group"];
+export declare const bubblewrapProxyEnvNames: readonly ["HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "NO_PROXY", "http_proxy", "https_proxy", "all_proxy", "no_proxy"];
+export declare function pathExists(deps: SandboxDependencies, candidatePath: string): Promise<boolean>;
+export declare function optionalPathExists(deps: SandboxDependencies, candidatePath: string): Promise<boolean>;
+export declare function addBubblewrapBind(args: string[], hostPath: string, guestPath: string, readOnly: boolean): void;
+export declare function addOptionalBubblewrapReadOnlyBind(deps: SandboxDependencies, args: string[], hostPath: string, guestPath?: string): Promise<void>;
+export declare function addBubblewrapProxyEnv(args: string[], env: NodeJS.ProcessEnv): void;
+export declare function redactProxyCredentials(input: string, env?: NodeJS.ProcessEnv): string;
+//# sourceMappingURL=autocode_sandbox_helpers.d.ts.map

package/dist/utils/autocode_sandbox_helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocode_sandbox_helpers.d.ts","sourceRoot":"","sources":["../../src/utils/autocode_sandbox_helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAE1D,eAAO,MAAM,gCAAgC,2EAA4E,CAAA;AACzH,eAAO,MAAM,kCAAkC,yJAA0J,CAAA;AACzM,eAAO,MAAM,+BAA+B,sLAAgF,CAAA;AAC5H,eAAO,MAAM,uBAAuB,uHAAwH,CAAA;AAE5J,wBAAsB,UAAU,CAAC,IAAI,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CASnG;AAED,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAS3G;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAE9G;AAED,wBAAsB,iCAAiC,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,GAAE,MAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhK;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,IAAI,CAKlF;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAKlG"}

package/dist/utils/db.d.ts

@@ -0,0 +1,82 @@
+export declare const DB_KEY_PATTERN: RegExp;
+export declare const IDENTIFIER_PATTERN: RegExp;
+export type DbAdapter = "postgres" | "mysql" | "mariadb" | "sqlite";
+export type DbConfig = {
+    adapter: DbAdapter;
+    connection: string;
+    connectionEnvVar: string;
+    dbKey: string;
+    normalizedDbKey: string;
+    password?: string;
+    passwordEnvVar: string;
+    username?: string;
+    usernameEnvVar: string;
+};
+export type DbClient = {
+    close: () => Promise<void>;
+    query: (sql: string, params?: unknown[]) => Promise<Record<string, unknown>[]>;
+};
+export type DbClientFactory = (config: DbConfig) => Promise<DbClient>;
+export type DbFilterOperator = "=" | "!=" | "<" | "<=" | ">" | ">=" | "like" | "in" | "is_null";
+export type DbFilter = {
+    key: string;
+    operator: DbFilterOperator;
+    value?: unknown;
+};
+export type ReadOnlySelectInput = {
+    adapter: DbAdapter;
+    fields?: string[];
+    filters?: DbFilter[];
+    limit: number;
+    schema: string;
+    sortAsc?: string;
+    sortDesc?: string;
+    table: string;
+};
+export type ReadOnlySelectQuery = {
+    params: unknown[];
+    sql: string;
+};
+export type DbTableField = {
+    name: string;
+    nullable?: boolean;
+    type: string;
+};
+export type DbTableRelationship = {
+    foreign_join_field: string;
+    local_join_field: string;
+    table: string;
+};
+export type DbTableMetadata = {
+    fields: DbTableField[];
+    indices: string[][];
+    pk: string[];
+    relationships: DbTableRelationship[];
+    schema: string;
+    table: string;
+};
+export declare function normalizeDbKey(dbKey: string): string;
+export declare function getDbEnvVarNames(normalizedDbKey: string): {
+    connectionEnvVar: string;
+    passwordEnvVar: string;
+    usernameEnvVar: string;
+};
+export declare function normalizeConnectionString(connection: string): string;
+export declare function detectDbAdapter(connection: string): DbAdapter;
+export declare function loadDbConfig(dbKey: string, env?: NodeJS.ProcessEnv): DbConfig;
+export declare function validateIdentifier(identifier: string, label: string): string;
+export declare function quoteIdentifier(adapter: DbAdapter, identifier: string): string;
+export declare function getDefaultSchema(adapter: DbAdapter): string | undefined;
+export declare function getMysqlDefaultSchema(client: DbClient): Promise<string | undefined>;
+export declare function resolveDbSchema(client: DbClient, adapter: DbAdapter, schema?: string): Promise<string>;
+export declare function readDbTables(client: DbClient, adapter: DbAdapter, schema: string): Promise<string[]>;
+export declare function readDbSchemas(client: DbClient, adapter: DbAdapter): Promise<string[]>;
+export declare function readDbTableMetadata(client: DbClient, adapter: DbAdapter, schemaInput: string, tableInput: string): Promise<DbTableMetadata>;
+export declare function createPlaceholder(adapter: DbAdapter, index: number): string;
+export declare function buildReadOnlySelectQuery(input: ReadOnlySelectInput): ReadOnlySelectQuery;
+export declare function defaultDbClientFactory(config: DbConfig): Promise<DbClient>;
+export declare function normalizeJsonValue(value: unknown): unknown;
+export declare function normalizeJsonRows(rows: Record<string, unknown>[]): Record<string, unknown>[];
+export declare function sanitizeDbError(error: unknown, config?: Pick<DbConfig, "connection" | "password" | "username">): unknown;
+export declare function quoteSqliteStringLiteral(value: string): string;
+//# sourceMappingURL=db.d.ts.map