thoth-agents 0.11.0 → 0.13.0

package/dist/opencode/tool-rpc.d.ts

@@ -0,0 +1,428 @@
+/** Portable server/TUI contract: Zod only, no host or filesystem dependencies. */
+import { z } from 'zod';
+export declare const ToolRoleSchema: z.ZodEnum<{
+    explorer: "explorer";
+    librarian: "librarian";
+    oracle: "oracle";
+    designer: "designer";
+    worker: "worker";
+}>;
+export declare const ToolScopeSchema: z.ZodEnum<{
+    global: "global";
+    project: "project";
+}>;
+export declare const ToolEffectSchema: z.ZodEnum<{
+    allow: "allow";
+    ask: "ask";
+    deny: "deny";
+}>;
+export declare const ToolOriginSchema: z.ZodEnum<{
+    default: "default";
+    global: "global";
+    project: "project";
+}>;
+export declare const ActionOverrideSchema: z.ZodObject<{
+    action: z.ZodString;
+    effect: z.ZodEnum<{
+        allow: "allow";
+        ask: "ask";
+        deny: "deny";
+    }>;
+}, z.core.$strip>;
+export declare const ToolStateSchema: z.ZodObject<{
+    specialists: z.ZodArray<z.ZodEnum<{
+        explorer: "explorer";
+        librarian: "librarian";
+        oracle: "oracle";
+        designer: "designer";
+        worker: "worker";
+    }>>;
+    inventory: z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        tools: z.ZodArray<z.ZodString>;
+        locked: z.ZodBoolean;
+    }, z.core.$strip>>;
+    roles: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<{
+            explorer: "explorer";
+            librarian: "librarian";
+            oracle: "oracle";
+            designer: "designer";
+            worker: "worker";
+        }>;
+        effectiveScope: z.ZodEnum<{
+            default: "default";
+            global: "global";
+            project: "project";
+        }>;
+        global: z.ZodObject<{
+            present: z.ZodBoolean;
+            revision: z.ZodString;
+            overrides: z.ZodArray<z.ZodObject<{
+                action: z.ZodString;
+                effect: z.ZodEnum<{
+                    allow: "allow";
+                    ask: "ask";
+                    deny: "deny";
+                }>;
+                matchCount: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        project: z.ZodObject<{
+            present: z.ZodBoolean;
+            revision: z.ZodString;
+            overrides: z.ZodArray<z.ZodObject<{
+                action: z.ZodString;
+                effect: z.ZodEnum<{
+                    allow: "allow";
+                    ask: "ask";
+                    deny: "deny";
+                }>;
+                matchCount: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        actions: z.ZodArray<z.ZodObject<{
+            action: z.ZodString;
+            effect: z.ZodEnum<{
+                allow: "allow";
+                ask: "ask";
+                deny: "deny";
+            }>;
+            baseEffect: z.ZodEnum<{
+                allow: "allow";
+                ask: "ask";
+                deny: "deny";
+            }>;
+            origin: z.ZodEnum<{
+                default: "default";
+                global: "global";
+                project: "project";
+            }>;
+            locked: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const ToolErrorSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        TOOLS_CONFLICT: "TOOLS_CONFLICT";
+        INVALID_REQUEST: "INVALID_REQUEST";
+        OPERATION_FAILED: "OPERATION_FAILED";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare const toolRpc: {
+    readonly id: "thoth-tool-permissions";
+    readonly methods: {
+        readonly state: {
+            readonly input: z.ZodObject<{}, z.core.$strip>;
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                ok: z.ZodLiteral<true>;
+                value: z.ZodObject<{
+                    specialists: z.ZodArray<z.ZodEnum<{
+                        explorer: "explorer";
+                        librarian: "librarian";
+                        oracle: "oracle";
+                        designer: "designer";
+                        worker: "worker";
+                    }>>;
+                    inventory: z.ZodArray<z.ZodObject<{
+                        action: z.ZodString;
+                        tools: z.ZodArray<z.ZodString>;
+                        locked: z.ZodBoolean;
+                    }, z.core.$strip>>;
+                    roles: z.ZodArray<z.ZodObject<{
+                        role: z.ZodEnum<{
+                            explorer: "explorer";
+                            librarian: "librarian";
+                            oracle: "oracle";
+                            designer: "designer";
+                            worker: "worker";
+                        }>;
+                        effectiveScope: z.ZodEnum<{
+                            default: "default";
+                            global: "global";
+                            project: "project";
+                        }>;
+                        global: z.ZodObject<{
+                            present: z.ZodBoolean;
+                            revision: z.ZodString;
+                            overrides: z.ZodArray<z.ZodObject<{
+                                action: z.ZodString;
+                                effect: z.ZodEnum<{
+                                    allow: "allow";
+                                    ask: "ask";
+                                    deny: "deny";
+                                }>;
+                                matchCount: z.ZodNumber;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>;
+                        project: z.ZodObject<{
+                            present: z.ZodBoolean;
+                            revision: z.ZodString;
+                            overrides: z.ZodArray<z.ZodObject<{
+                                action: z.ZodString;
+                                effect: z.ZodEnum<{
+                                    allow: "allow";
+                                    ask: "ask";
+                                    deny: "deny";
+                                }>;
+                                matchCount: z.ZodNumber;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>;
+                        actions: z.ZodArray<z.ZodObject<{
+                            action: z.ZodString;
+                            effect: z.ZodEnum<{
+                                allow: "allow";
+                                ask: "ask";
+                                deny: "deny";
+                            }>;
+                            baseEffect: z.ZodEnum<{
+                                allow: "allow";
+                                ask: "ask";
+                                deny: "deny";
+                            }>;
+                            origin: z.ZodEnum<{
+                                default: "default";
+                                global: "global";
+                                project: "project";
+                            }>;
+                            locked: z.ZodBoolean;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                    warnings: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                ok: z.ZodLiteral<false>;
+                error: z.ZodObject<{
+                    code: z.ZodEnum<{
+                        TOOLS_CONFLICT: "TOOLS_CONFLICT";
+                        INVALID_REQUEST: "INVALID_REQUEST";
+                        OPERATION_FAILED: "OPERATION_FAILED";
+                    }>;
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>], "ok">;
+        };
+        readonly save: {
+            readonly input: z.ZodObject<{
+                scope: z.ZodEnum<{
+                    global: "global";
+                    project: "project";
+                }>;
+                role: z.ZodEnum<{
+                    explorer: "explorer";
+                    librarian: "librarian";
+                    oracle: "oracle";
+                    designer: "designer";
+                    worker: "worker";
+                }>;
+                baseRevision: z.ZodString;
+                overrides: z.ZodArray<z.ZodObject<{
+                    action: z.ZodString;
+                    effect: z.ZodEnum<{
+                        allow: "allow";
+                        ask: "ask";
+                        deny: "deny";
+                    }>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                ok: z.ZodLiteral<true>;
+                value: z.ZodObject<{
+                    specialists: z.ZodArray<z.ZodEnum<{
+                        explorer: "explorer";
+                        librarian: "librarian";
+                        oracle: "oracle";
+                        designer: "designer";
+                        worker: "worker";
+                    }>>;
+                    inventory: z.ZodArray<z.ZodObject<{
+                        action: z.ZodString;
+                        tools: z.ZodArray<z.ZodString>;
+                        locked: z.ZodBoolean;
+                    }, z.core.$strip>>;
+                    roles: z.ZodArray<z.ZodObject<{
+                        role: z.ZodEnum<{
+                            explorer: "explorer";
+                            librarian: "librarian";
+                            oracle: "oracle";
+                            designer: "designer";
+                            worker: "worker";
+                        }>;
+                        effectiveScope: z.ZodEnum<{
+                            default: "default";
+                            global: "global";
+                            project: "project";
+                        }>;
+                        global: z.ZodObject<{
+                            present: z.ZodBoolean;
+                            revision: z.ZodString;
+                            overrides: z.ZodArray<z.ZodObject<{
+                                action: z.ZodString;
+                                effect: z.ZodEnum<{
+                                    allow: "allow";
+                                    ask: "ask";
+                                    deny: "deny";
+                                }>;
+                                matchCount: z.ZodNumber;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>;
+                        project: z.ZodObject<{
+                            present: z.ZodBoolean;
+                            revision: z.ZodString;
+                            overrides: z.ZodArray<z.ZodObject<{
+                                action: z.ZodString;
+                                effect: z.ZodEnum<{
+                                    allow: "allow";
+                                    ask: "ask";
+                                    deny: "deny";
+                                }>;
+                                matchCount: z.ZodNumber;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>;
+                        actions: z.ZodArray<z.ZodObject<{
+                            action: z.ZodString;
+                            effect: z.ZodEnum<{
+                                allow: "allow";
+                                ask: "ask";
+                                deny: "deny";
+                            }>;
+                            baseEffect: z.ZodEnum<{
+                                allow: "allow";
+                                ask: "ask";
+                                deny: "deny";
+                            }>;
+                            origin: z.ZodEnum<{
+                                default: "default";
+                                global: "global";
+                                project: "project";
+                            }>;
+                            locked: z.ZodBoolean;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                    warnings: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                ok: z.ZodLiteral<false>;
+                error: z.ZodObject<{
+                    code: z.ZodEnum<{
+                        TOOLS_CONFLICT: "TOOLS_CONFLICT";
+                        INVALID_REQUEST: "INVALID_REQUEST";
+                        OPERATION_FAILED: "OPERATION_FAILED";
+                    }>;
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>], "ok">;
+        };
+        readonly reset: {
+            readonly input: z.ZodObject<{
+                scope: z.ZodEnum<{
+                    global: "global";
+                    project: "project";
+                }>;
+                role: z.ZodEnum<{
+                    explorer: "explorer";
+                    librarian: "librarian";
+                    oracle: "oracle";
+                    designer: "designer";
+                    worker: "worker";
+                }>;
+                baseRevision: z.ZodString;
+            }, z.core.$strip>;
+            readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                ok: z.ZodLiteral<true>;
+                value: z.ZodObject<{
+                    specialists: z.ZodArray<z.ZodEnum<{
+                        explorer: "explorer";
+                        librarian: "librarian";
+                        oracle: "oracle";
+                        designer: "designer";
+                        worker: "worker";
+                    }>>;
+                    inventory: z.ZodArray<z.ZodObject<{
+                        action: z.ZodString;
+                        tools: z.ZodArray<z.ZodString>;
+                        locked: z.ZodBoolean;
+                    }, z.core.$strip>>;
+                    roles: z.ZodArray<z.ZodObject<{
+                        role: z.ZodEnum<{
+                            explorer: "explorer";
+                            librarian: "librarian";
+                            oracle: "oracle";
+                            designer: "designer";
+                            worker: "worker";
+                        }>;
+                        effectiveScope: z.ZodEnum<{
+                            default: "default";
+                            global: "global";
+                            project: "project";
+                        }>;
+                        global: z.ZodObject<{
+                            present: z.ZodBoolean;
+                            revision: z.ZodString;
+                            overrides: z.ZodArray<z.ZodObject<{
+                                action: z.ZodString;
+                                effect: z.ZodEnum<{
+                                    allow: "allow";
+                                    ask: "ask";
+                                    deny: "deny";
+                                }>;
+                                matchCount: z.ZodNumber;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>;
+                        project: z.ZodObject<{
+                            present: z.ZodBoolean;
+                            revision: z.ZodString;
+                            overrides: z.ZodArray<z.ZodObject<{
+                                action: z.ZodString;
+                                effect: z.ZodEnum<{
+                                    allow: "allow";
+                                    ask: "ask";
+                                    deny: "deny";
+                                }>;
+                                matchCount: z.ZodNumber;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>;
+                        actions: z.ZodArray<z.ZodObject<{
+                            action: z.ZodString;
+                            effect: z.ZodEnum<{
+                                allow: "allow";
+                                ask: "ask";
+                                deny: "deny";
+                            }>;
+                            baseEffect: z.ZodEnum<{
+                                allow: "allow";
+                                ask: "ask";
+                                deny: "deny";
+                            }>;
+                            origin: z.ZodEnum<{
+                                default: "default";
+                                global: "global";
+                                project: "project";
+                            }>;
+                            locked: z.ZodBoolean;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                    warnings: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                ok: z.ZodLiteral<false>;
+                error: z.ZodObject<{
+                    code: z.ZodEnum<{
+                        TOOLS_CONFLICT: "TOOLS_CONFLICT";
+                        INVALID_REQUEST: "INVALID_REQUEST";
+                        OPERATION_FAILED: "OPERATION_FAILED";
+                    }>;
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>], "ok">;
+        };
+    };
+    readonly events: {};
+};
+export type ToolState = z.infer<typeof ToolStateSchema>;
+export type ToolError = z.infer<typeof ToolErrorSchema>;
+export type ToolRpcMethod = keyof typeof toolRpc.methods;
+export type ToolRpcInput<M extends ToolRpcMethod> = z.infer<(typeof toolRpc.methods)[M]['input']>;
+export type ToolRpcOutput<M extends ToolRpcMethod> = z.infer<(typeof toolRpc.methods)[M]['output']>;

package/dist/opencode/tools.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '@opencode/plugin';
+import type { OpenCodeDependencies } from './context';
+export declare function registerTools(ctx: Plugin.Context, _deps: OpenCodeDependencies): Promise<void>;

package/dist/pi.js

@@ -1,17 +1,17 @@
 import {
   formatGateVerdict,
   summarizeGateResult
-} from "./chunk-RWQPMWEM.js";
+} from "./chunk-JLU3FSBT.js";
 import {
   PI_ROOT_END,
   PI_ROOT_START,
   createPiToolsPanelAdapter,
   renderPiRootInstructions,
   syncPiSpecialists
-} from "./chunk-5WPP6IY7.js";
+} from "./chunk-VVYAQTYE.js";
 import {
   findPackageRoot
-} from "./chunk-DNPKVFOB.js";
+} from "./chunk-YCWGTDFE.js";
 
 // src/pi.ts
 import { homedir } from "os";

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

@@ -1,5 +1,6 @@
 import type { CliLanguage, SgResult } from './types';
 export interface RunOptions {
+    signal?: AbortSignal;
     pattern: string;
     lang: CliLanguage;
     paths?: string[];

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

@@ -1,6 +1,112 @@
-import type { ToolDefinition } from '@opencode-ai/plugin';
 import { ast_grep_replace, ast_grep_search } from './tools';
-export declare const builtinTools: Record<string, ToolDefinition>;
+export declare const builtinTools: {
+    ast_grep_search: {
+        name: string;
+        description: string;
+        input: import("zod").ZodObject<{
+            pattern: import("zod").ZodString;
+            lang: import("zod").ZodEnum<{
+                bash: "bash";
+                c: "c";
+                cpp: "cpp";
+                csharp: "csharp";
+                css: "css";
+                elixir: "elixir";
+                go: "go";
+                haskell: "haskell";
+                html: "html";
+                java: "java";
+                javascript: "javascript";
+                json: "json";
+                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: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            globs: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            context: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        execute(input: {
+            pattern: string;
+            lang: "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";
+            paths?: string[] | undefined;
+            globs?: string[] | undefined;
+            context?: number | undefined;
+        }, context: import("@opencode/plugin/promise/tool").ToolContext): Promise<{
+            content: string;
+            metadata: {
+                output: string;
+            };
+        } | {
+            content: string;
+            metadata?: undefined;
+        }>;
+    };
+    ast_grep_replace: {
+        name: string;
+        description: string;
+        input: import("zod").ZodObject<{
+            pattern: import("zod").ZodString;
+            rewrite: import("zod").ZodString;
+            lang: import("zod").ZodEnum<{
+                bash: "bash";
+                c: "c";
+                cpp: "cpp";
+                csharp: "csharp";
+                css: "css";
+                elixir: "elixir";
+                go: "go";
+                haskell: "haskell";
+                html: "html";
+                java: "java";
+                javascript: "javascript";
+                json: "json";
+                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: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            globs: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            dryRun: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>;
+        execute(input: {
+            pattern: string;
+            rewrite: string;
+            lang: "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";
+            paths?: string[] | undefined;
+            globs?: string[] | undefined;
+            dryRun?: boolean | undefined;
+        }, context: import("@opencode/plugin/promise/tool").ToolContext): Promise<{
+            content: string;
+            metadata: {
+                output: string;
+            };
+        } | {
+            content: string;
+            metadata?: undefined;
+        }>;
+    };
+};
 export { ast_grep_search, ast_grep_replace };
 export { ensureCliAvailable, getAstGrepPath, isCliAvailable, startBackgroundInit, } from './cli';
 export type { EnvironmentCheckResult } from './constants';

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

@@ -1,3 +1,107 @@
-import { type ToolDefinition } from '@opencode-ai/plugin/tool';
-export declare const ast_grep_search: ToolDefinition;
-export declare const ast_grep_replace: ToolDefinition;
+import { z } from 'zod';
+export declare const ast_grep_search: {
+    name: string;
+    description: string;
+    input: z.ZodObject<{
+        pattern: z.ZodString;
+        lang: z.ZodEnum<{
+            bash: "bash";
+            c: "c";
+            cpp: "cpp";
+            csharp: "csharp";
+            css: "css";
+            elixir: "elixir";
+            go: "go";
+            haskell: "haskell";
+            html: "html";
+            java: "java";
+            javascript: "javascript";
+            json: "json";
+            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>;
+    }, z.core.$strip>;
+    execute(input: {
+        pattern: string;
+        lang: "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";
+        paths?: string[] | undefined;
+        globs?: string[] | undefined;
+        context?: number | undefined;
+    }, context: import("@opencode/plugin/promise/tool").ToolContext): Promise<{
+        content: string;
+        metadata: {
+            output: string;
+        };
+    } | {
+        content: string;
+        metadata?: undefined;
+    }>;
+};
+export declare const ast_grep_replace: {
+    name: string;
+    description: string;
+    input: z.ZodObject<{
+        pattern: z.ZodString;
+        rewrite: z.ZodString;
+        lang: z.ZodEnum<{
+            bash: "bash";
+            c: "c";
+            cpp: "cpp";
+            csharp: "csharp";
+            css: "css";
+            elixir: "elixir";
+            go: "go";
+            haskell: "haskell";
+            html: "html";
+            java: "java";
+            javascript: "javascript";
+            json: "json";
+            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>;
+    }, z.core.$strip>;
+    execute(input: {
+        pattern: string;
+        rewrite: string;
+        lang: "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";
+        paths?: string[] | undefined;
+        globs?: string[] | undefined;
+        dryRun?: boolean | undefined;
+    }, context: import("@opencode/plugin/promise/tool").ToolContext): Promise<{
+        content: string;
+        metadata: {
+            output: string;
+        };
+    } | {
+        content: string;
+        metadata?: undefined;
+    }>;
+};