opencode-froggy 0.12.0 → 1.0.0

package/dist/loaders.d.ts

@@ -21,6 +21,7 @@ export interface CommandFrontmatter {
     description: string;
     agent?: string;
     model?: string;
+    subagent?: boolean;
     subtask?: boolean;
 }
 export interface CommandConfig {
@@ -28,6 +29,7 @@ export interface CommandConfig {
     description?: string;
     agent?: string;
     model?: string;
+    subagent?: boolean;
     subtask?: boolean;
 }
 export interface LoadedSkill {

package/dist/loaders.js

@@ -90,6 +90,7 @@ export function loadCommands(commandDir) {
             description: data.description || "",
             agent: data.agent,
             model: data.model,
+            subagent: data.subagent,
             subtask: data.subtask,
             template: body.trim(),
         };

package/dist/session-children.d.ts

@@ -0,0 +1,14 @@
+export interface ChildSessionInfo {
+    id: string;
+    parentID: string;
+    title?: string;
+    created: number;
+    updated: number;
+}
+export declare class ChildSessionTracker {
+    private childrenByParent;
+    trackChild(info: ChildSessionInfo): void;
+    removeSession(sessionID: string): void;
+    listChildren(parentID: string): ChildSessionInfo[];
+    lastChild(parentID: string): ChildSessionInfo | undefined;
+}

package/dist/session-children.js

@@ -0,0 +1,27 @@
+export class ChildSessionTracker {
+    childrenByParent = new Map();
+    trackChild(info) {
+        let children = this.childrenByParent.get(info.parentID);
+        if (!children) {
+            children = new Map();
+            this.childrenByParent.set(info.parentID, children);
+        }
+        children.set(info.id, info);
+    }
+    removeSession(sessionID) {
+        this.childrenByParent.delete(sessionID);
+        for (const children of this.childrenByParent.values()) {
+            children.delete(sessionID);
+        }
+    }
+    listChildren(parentID) {
+        const children = this.childrenByParent.get(parentID);
+        if (!children)
+            return [];
+        return Array.from(children.values()).sort((a, b) => a.created - b.created);
+    }
+    lastChild(parentID) {
+        const list = this.listChildren(parentID);
+        return list.at(-1);
+    }
+}

package/dist/session-children.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/session-children.test.js

@@ -0,0 +1,25 @@
+import { describe, it, expect } from "vitest";
+import { ChildSessionTracker } from "./session-children";
+describe("ChildSessionTracker", () => {
+    it("should return empty list for unknown parent", () => {
+        expect(new ChildSessionTracker().listChildren("ses_unknown")).toEqual([]);
+    });
+    it("should track and list children in creation order", () => {
+        const tracker = new ChildSessionTracker();
+        tracker.trackChild({ id: "ses_b", parentID: "ses_a", created: 2, updated: 2 });
+        tracker.trackChild({ id: "ses_c", parentID: "ses_a", created: 1, updated: 3 });
+        expect(tracker.listChildren("ses_a").map((c) => c.id)).toEqual(["ses_c", "ses_b"]);
+    });
+    it("should return the last child", () => {
+        const tracker = new ChildSessionTracker();
+        tracker.trackChild({ id: "ses_b", parentID: "ses_a", created: 1, updated: 1 });
+        tracker.trackChild({ id: "ses_c", parentID: "ses_a", created: 2, updated: 2 });
+        expect(tracker.lastChild("ses_a")?.id).toBe("ses_c");
+    });
+    it("should remove sessions and their children", () => {
+        const tracker = new ChildSessionTracker();
+        tracker.trackChild({ id: "ses_b", parentID: "ses_a", created: 1, updated: 1 });
+        tracker.removeSession("ses_a");
+        expect(tracker.listChildren("ses_a")).toEqual([]);
+    });
+});

package/dist/skill-activation.js

@@ -2,7 +2,7 @@ function formatTrigger(text) {
     return text.replace(/\s+/g, " ").trim();
 }
 function buildSkillInstruction(skill) {
-    return `MANDATORY: Call skill({ name: "${skill.name}" }) ${formatTrigger(skill.useWhen)}`;
+    return `MANDATORY: Call skill({ id: "${skill.name}" }) ${formatTrigger(skill.useWhen)}`;
 }
 export function buildSkillActivationBlock(skills) {
     if (!Array.isArray(skills) || skills.length === 0)

package/dist/tools/agent-promote.d.ts

@@ -1,19 +1,46 @@
-import { type ToolContext } from "@opencode-ai/plugin";
-import type { createOpencodeClient } from "@opencode-ai/sdk";
 export { type AgentMode, VALID_GRADES, getPromotedAgents, setPromotedAgent, validateGrade, validateAgentName, } from "./agent-promote-core";
-type Client = ReturnType<typeof createOpencodeClient>;
 export interface AgentPromoteArgs {
     name: string;
     grade?: string;
 }
-export declare function createAgentPromoteTool(client: Client, pluginAgentNames: string[]): {
+interface AgentReader {
+    get(input: {
+        agentID: string;
+    }): Promise<{
+        data?: {
+            mode?: string;
+        };
+    } | {
+        mode?: string;
+    }>;
+}
+interface AgentReloader {
+    reload(): Promise<void>;
+}
+interface PluginStorage {
+    set(key: string, value: unknown): Promise<void>;
+}
+declare const STORAGE_KEY = "promoted-agents";
+export declare function createAgentPromoteTool(agent: AgentReader, reloader: AgentReloader, storage: PluginStorage, pluginAgentNames: string[]): {
+    name: string;
     description: string;
-    args: {
-        name: import("zod").ZodString;
-        grade: import("zod").ZodOptional<import("zod").ZodString>;
+    input: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                description: string;
+            };
+            grade: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
     };
-    execute(args: {
-        name: string;
-        grade?: string | undefined;
-    }, context: ToolContext): Promise<string>;
+    execute(input: unknown): Promise<{
+        content: string;
+    }>;
 };
+export { STORAGE_KEY as AGENT_PROMOTE_STORAGE_KEY };

package/dist/tools/agent-promote.js

@@ -1,48 +1,50 @@
-import { tool } from "@opencode-ai/plugin";
 import { log } from "../logger";
-import { VALID_GRADES, setPromotedAgent, validateGrade, validateAgentName, } from "./agent-promote-core";
+import { VALID_GRADES, getPromotedAgents, setPromotedAgent, validateGrade, validateAgentName, } from "./agent-promote-core";
 export { VALID_GRADES, getPromotedAgents, setPromotedAgent, validateGrade, validateAgentName, } from "./agent-promote-core";
-export function createAgentPromoteTool(client, pluginAgentNames) {
-    return tool({
+const STORAGE_KEY = "promoted-agents";
+export function createAgentPromoteTool(agent, reloader, storage, pluginAgentNames) {
+    return {
+        name: "agent-promote",
         description: "Change the type of an agent to primary, subagent or all",
-        args: {
-            name: tool.schema.string().describe("Name of the agent"),
-            grade: tool.schema.string().optional().describe("Target type: 'subagent', 'primary', or 'all' (default: primary)"),
+        input: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Name of the agent" },
+                grade: {
+                    type: "string",
+                    description: "Target type: 'subagent', 'primary', or 'all' (default: primary)",
+                },
+            },
+            required: ["name"],
+            additionalProperties: false,
         },
-        async execute(args, _context) {
+        async execute(input) {
+            const args = input;
             const { name } = args;
             const grade = args.grade?.trim() || "primary";
             if (!validateGrade(grade)) {
-                return `Invalid grade "${grade}". Valid grades: ${VALID_GRADES.join(", ")}`;
+                return { content: `Invalid grade "${grade}". Valid grades: ${VALID_GRADES.join(", ")}` };
             }
             if (!validateAgentName(name, pluginAgentNames)) {
-                return `Agent "${name}" not found in this plugin. Available: ${pluginAgentNames.join(", ")}`;
+                return {
+                    content: `Agent "${name}" not found in this plugin. Available: ${pluginAgentNames.join(", ")}`,
+                };
             }
-            const agentsResp = await client.app.agents();
-            const agents = agentsResp.data ?? [];
-            const existingAgent = agents.find((a) => a.name === name);
-            if (existingAgent && existingAgent.mode === grade) {
-                return `Agent "${name}" is already of type "${grade}"`;
+            const existing = await agent.get({ agentID: name });
+            const currentMode = existing.data?.mode
+                ?? existing.mode;
+            if (currentMode === grade) {
+                return { content: `Agent "${name}" is already of type "${grade}"` };
             }
             setPromotedAgent(name, grade);
             log("[agent-promote] Agent type changed", { name, grade });
-            await client.tui.showToast({
-                body: {
-                    message: `Promoting agent "${name}" to "${grade}"...`,
-                    variant: "success",
-                    duration: 3000,
-                },
-            });
-            setTimeout(() => {
-                void client.instance.dispose().catch((error) => {
-                    log("[agent-promote] Delayed dispose failed", {
-                        name,
-                        grade,
-                        error: String(error),
-                    });
-                });
-            }, 0);
-            return `Agent "${name}" changed to type "${grade}". Use Tab or <leader>a to select it.`;
+            const record = {};
+            for (const [key, value] of getPromotedAgents())
+                record[key] = value;
+            await storage.set(STORAGE_KEY, record);
+            await reloader.reload();
+            return { content: `Agent "${name}" changed to type "${grade}".` };
         },
-    });
+    };
 }
+export { STORAGE_KEY as AGENT_PROMOTE_STORAGE_KEY };

package/dist/tools/blockchain/eth-address-balance.d.ts

@@ -1,20 +1,30 @@
 /**
  * Tool to get Ethereum address balance
  */
-import { type ToolContext } from "@opencode-ai/plugin";
 export interface EthAddressBalanceArgs {
     address: string;
     chainId?: string;
 }
 export declare function getAddressBalance(address: string, chainId?: string): Promise<string>;
 export declare const ethAddressBalanceTool: {
+    name: string;
     description: string;
-    args: {
-        address: import("zod").ZodString;
-        chainId: import("zod").ZodOptional<import("zod").ZodString>;
+    input: {
+        type: string;
+        properties: {
+            address: {
+                type: string;
+                description: string;
+            };
+            chainId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
     };
-    execute(args: {
-        address: string;
-        chainId?: string | undefined;
-    }, context: ToolContext): Promise<string>;
+    execute(input: unknown): Promise<{
+        content: string;
+    }>;
 };

package/dist/tools/blockchain/eth-address-balance.js

@@ -1,7 +1,6 @@
 /**
  * Tool to get Ethereum address balance
  */
-import { tool } from "@opencode-ai/plugin";
 import { EtherscanClient, EtherscanClientError, validateAddress } from "./etherscan-client";
 import { formatBalance } from "./formatters";
 import { CHAIN_ID_DESCRIPTION } from "./types";
@@ -11,27 +10,29 @@ export async function getAddressBalance(address, chainId) {
     const balanceWei = await client.getBalance(address);
     return formatBalance(address, balanceWei);
 }
-export const ethAddressBalanceTool = tool({
+export const ethAddressBalanceTool = {
+    name: "eth-address-balance",
     description: "Get the ETH balance of an Ethereum address. " +
         "Returns balance in both ETH and Wei.",
-    args: {
-        address: tool.schema
-            .string()
-            .describe("Ethereum address (0x...)"),
-        chainId: tool.schema
-            .string()
-            .optional()
-            .describe(CHAIN_ID_DESCRIPTION),
+    input: {
+        type: "object",
+        properties: {
+            address: { type: "string", description: "Ethereum address (0x...)" },
+            chainId: { type: "string", description: CHAIN_ID_DESCRIPTION },
+        },
+        required: ["address"],
+        additionalProperties: false,
     },
-    async execute(args, _context) {
+    async execute(input) {
+        const args = input;
         try {
-            return await getAddressBalance(args.address, args.chainId);
+            return { content: await getAddressBalance(args.address, args.chainId) };
         }
         catch (error) {
             if (error instanceof EtherscanClientError) {
-                return `Error: ${error.message}`;
+                return { content: `Error: ${error.message}` };
             }
             throw error;
         }
     },
-});
+};

package/dist/tools/blockchain/eth-address-txs.d.ts

@@ -1,7 +1,6 @@
 /**
  * Tool to list Ethereum transactions for an address
  */
-import { type ToolContext } from "@opencode-ai/plugin";
 export interface EthAddressTxsArgs {
     address: string;
     limit?: number;
@@ -9,15 +8,28 @@ export interface EthAddressTxsArgs {
 }
 export declare function getAddressTransactions(address: string, limit?: number, chainId?: string): Promise<string>;
 export declare const ethAddressTxsTool: {
+    name: string;
     description: string;
-    args: {
-        address: import("zod").ZodString;
-        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
-        chainId: import("zod").ZodOptional<import("zod").ZodString>;
+    input: {
+        type: string;
+        properties: {
+            address: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            chainId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
     };
-    execute(args: {
-        address: string;
-        limit?: number | undefined;
-        chainId?: string | undefined;
-    }, context: ToolContext): Promise<string>;
+    execute(input: unknown): Promise<{
+        content: string;
+    }>;
 };

package/dist/tools/blockchain/eth-address-txs.js

@@ -1,7 +1,6 @@
 /**
  * Tool to list Ethereum transactions for an address
  */
-import { tool } from "@opencode-ai/plugin";
 import { EtherscanClient, EtherscanClientError, validateAddress } from "./etherscan-client";
 import { formatTransactionList } from "./formatters";
 import { DEFAULT_TRANSACTION_LIMIT, CHAIN_ID_DESCRIPTION } from "./types";
@@ -11,31 +10,33 @@ export async function getAddressTransactions(address, limit = DEFAULT_TRANSACTIO
     const transactions = await client.getTransactions(address, limit);
     return formatTransactionList(address, transactions);
 }
-export const ethAddressTxsTool = tool({
+export const ethAddressTxsTool = {
+    name: "eth-address-txs",
     description: "List Ethereum transactions for an address. " +
         "Shows incoming and outgoing transactions with values, timestamps, and status.",
-    args: {
-        address: tool.schema
-            .string()
-            .describe("Ethereum address (0x...)"),
-        limit: tool.schema
-            .number()
-            .optional()
-            .describe(`Maximum number of transactions to return (default: ${DEFAULT_TRANSACTION_LIMIT})`),
-        chainId: tool.schema
-            .string()
-            .optional()
-            .describe(CHAIN_ID_DESCRIPTION),
+    input: {
+        type: "object",
+        properties: {
+            address: { type: "string", description: "Ethereum address (0x...)" },
+            limit: {
+                type: "number",
+                description: `Maximum number of transactions to return (default: ${DEFAULT_TRANSACTION_LIMIT})`,
+            },
+            chainId: { type: "string", description: CHAIN_ID_DESCRIPTION },
+        },
+        required: ["address"],
+        additionalProperties: false,
     },
-    async execute(args, _context) {
+    async execute(input) {
+        const args = input;
         try {
-            return await getAddressTransactions(args.address, args.limit, args.chainId);
+            return { content: await getAddressTransactions(args.address, args.limit, args.chainId) };
         }
         catch (error) {
             if (error instanceof EtherscanClientError) {
-                return `Error: ${error.message}`;
+                return { content: `Error: ${error.message}` };
             }
             throw error;
         }
     },
-});
+};

package/dist/tools/blockchain/eth-token-transfers.d.ts

@@ -1,7 +1,6 @@
 /**
  * Tool to list ERC-20 token transfers for an address
  */
-import { type ToolContext } from "@opencode-ai/plugin";
 export interface EthTokenTransfersArgs {
     address: string;
     limit?: number;
@@ -9,15 +8,28 @@ export interface EthTokenTransfersArgs {
 }
 export declare function getTokenTransfers(address: string, limit?: number, chainId?: string): Promise<string>;
 export declare const ethTokenTransfersTool: {
+    name: string;
     description: string;
-    args: {
-        address: import("zod").ZodString;
-        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
-        chainId: import("zod").ZodOptional<import("zod").ZodString>;
+    input: {
+        type: string;
+        properties: {
+            address: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            chainId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
     };
-    execute(args: {
-        address: string;
-        limit?: number | undefined;
-        chainId?: string | undefined;
-    }, context: ToolContext): Promise<string>;
+    execute(input: unknown): Promise<{
+        content: string;
+    }>;
 };

package/dist/tools/blockchain/eth-token-transfers.js

@@ -1,7 +1,6 @@
 /**
  * Tool to list ERC-20 token transfers for an address
  */
-import { tool } from "@opencode-ai/plugin";
 import { EtherscanClient, EtherscanClientError, validateAddress } from "./etherscan-client";
 import { formatTokenTransferList } from "./formatters";
 import { DEFAULT_TRANSACTION_LIMIT, CHAIN_ID_DESCRIPTION } from "./types";
@@ -11,31 +10,33 @@ export async function getTokenTransfers(address, limit = DEFAULT_TRANSACTION_LIM
     const transfers = await client.getTokenTransfers(address, limit);
     return formatTokenTransferList(address, transfers);
 }
-export const ethTokenTransfersTool = tool({
+export const ethTokenTransfersTool = {
+    name: "eth-token-transfers",
     description: "List ERC-20 token transfers for an Ethereum address. " +
         "Shows token names, symbols, values, and transaction details.",
-    args: {
-        address: tool.schema
-            .string()
-            .describe("Ethereum address (0x...)"),
-        limit: tool.schema
-            .number()
-            .optional()
-            .describe(`Maximum number of transfers to return (default: ${DEFAULT_TRANSACTION_LIMIT})`),
-        chainId: tool.schema
-            .string()
-            .optional()
-            .describe(CHAIN_ID_DESCRIPTION),
+    input: {
+        type: "object",
+        properties: {
+            address: { type: "string", description: "Ethereum address (0x...)" },
+            limit: {
+                type: "number",
+                description: `Maximum number of transfers to return (default: ${DEFAULT_TRANSACTION_LIMIT})`,
+            },
+            chainId: { type: "string", description: CHAIN_ID_DESCRIPTION },
+        },
+        required: ["address"],
+        additionalProperties: false,
     },
-    async execute(args, _context) {
+    async execute(input) {
+        const args = input;
         try {
-            return await getTokenTransfers(args.address, args.limit, args.chainId);
+            return { content: await getTokenTransfers(args.address, args.limit, args.chainId) };
         }
         catch (error) {
             if (error instanceof EtherscanClientError) {
-                return `Error: ${error.message}`;
+                return { content: `Error: ${error.message}` };
             }
             throw error;
         }
     },
-});
+};

package/dist/tools/blockchain/eth-transaction.d.ts

@@ -1,7 +1,6 @@
 /**
  * Tool to get Ethereum transaction details by hash
  */
-import { type ToolContext } from "@opencode-ai/plugin";
 import { type TransactionDetails } from "./types";
 export interface EthTransactionArgs {
     hash: string;
@@ -16,19 +15,36 @@ export declare function getTransactionDetails(hash: string, chainId?: string, op
     decodeLogs?: boolean;
 }): Promise<TransactionDetails>;
 export declare const ethTransactionTool: {
+    name: string;
     description: string;
-    args: {
-        hash: import("zod").ZodString;
-        chainId: import("zod").ZodOptional<import("zod").ZodString>;
-        includeInternalTxs: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        includeTokenTransfers: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        decodeLogs: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    input: {
+        type: string;
+        properties: {
+            hash: {
+                type: string;
+                description: string;
+            };
+            chainId: {
+                type: string;
+                description: string;
+            };
+            includeInternalTxs: {
+                type: string;
+                description: string;
+            };
+            includeTokenTransfers: {
+                type: string;
+                description: string;
+            };
+            decodeLogs: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
     };
-    execute(args: {
-        hash: string;
-        chainId?: string | undefined;
-        includeInternalTxs?: boolean | undefined;
-        includeTokenTransfers?: boolean | undefined;
-        decodeLogs?: boolean | undefined;
-    }, context: ToolContext): Promise<string>;
+    execute(input: unknown): Promise<{
+        content: string;
+    }>;
 };