opencode-froggy 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,12 +1,12 @@
-import { tool } from "@opencode-ai/plugin";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { loadAgents, loadSkills, loadCommands, loadHooks, mergeHooks, } from "./loaders";
+import { loadAgents, loadCommands, loadHooks, mergeHooks, } from "./loaders";
 import { getGlobalHookDir, getProjectHookDir } from "./config-paths";
 import { hasCodeExtension } from "./code-files";
 import { log } from "./logger";
 import { executeBashAction, DEFAULT_BASH_TIMEOUT, } from "./bash-executor";
-export { parseFrontmatter, loadAgents, loadSkills, loadCommands } from "./loaders";
+import { gitingestTool, createDiffSummaryTool, createPromptSessionTool, createListChildSessionsTool, ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, } from "./tools";
+export { parseFrontmatter, loadAgents, loadCommands } from "./loaders";
 // ============================================================================
 // CONSTANTS
 // ============================================================================
@@ -14,35 +14,42 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const PLUGIN_ROOT = join(__dirname, "..");
 const AGENT_DIR = join(PLUGIN_ROOT, "agent");
-const SKILL_DIR = join(PLUGIN_ROOT, "skill");
 const COMMAND_DIR = join(PLUGIN_ROOT, "command");
 // ============================================================================
 // PLUGIN
 // ============================================================================
 const SmartfrogPlugin = async (ctx) => {
     const agents = loadAgents(AGENT_DIR);
-    const skills = loadSkills(SKILL_DIR);
     const commands = loadCommands(COMMAND_DIR);
     const globalHooks = loadHooks(getGlobalHookDir());
     const projectHooks = loadHooks(getProjectHookDir(ctx.directory));
     const hooks = mergeHooks(globalHooks, projectHooks);
     const modifiedCodeFiles = new Map();
     const pendingToolArgs = new Map();
-    let mainSessionID;
     log("[init] Plugin loaded", {
         agents: Object.keys(agents),
         commands: Object.keys(commands),
-        skills: skills.map(s => s.name),
         hooks: Array.from(hooks.keys()),
+        tools: [
+            "gitingest",
+            "diff-summary",
+            "eth-transaction",
+            "eth-address-txs",
+            "eth-address-balance",
+            "eth-token-transfers",
+        ],
     });
     async function executeHookActions(hook, sessionID, extraLog, options) {
         const prefix = `[hook:${hook.event}]`;
         const canBlock = options?.canBlock ?? false;
         const conditions = hook.conditions ?? [];
         for (const condition of conditions) {
-            if (condition === "isMainSession" && sessionID !== mainSessionID) {
-                log(`${prefix} condition not met, skipping`, { sessionID, condition });
-                return { blocked: false };
+            if (condition === "isMainSession") {
+                const sessionInfo = await ctx.client.session.get({ path: { id: sessionID } });
+                if (sessionInfo.data?.parentID) {
+                    log(`${prefix} condition not met, skipping`, { sessionID, condition });
+                    return { blocked: false };
+                }
             }
             if (condition === "hasCodeChange") {
                 const files = extraLog?.files;
@@ -78,15 +85,6 @@ const SmartfrogPlugin = async (ctx) => {
                     });
                     log(`${prefix} command result`, { command: name, status: result.response?.status, error: result.error });
                 }
-                else if ("skill" in action) {
-                    log(`${prefix} executing skill`, { skill: action.skill });
-                    const result = await ctx.client.session.prompt({
-                        path: { id: sessionID },
-                        body: { parts: [{ type: "text", text: `Use the skill tool to load the "${action.skill}" skill and follow its instructions.` }] },
-                        query: { directory: ctx.directory },
-                    });
-                    log(`${prefix} skill result`, { skill: action.skill, status: result.response?.status, error: result.error });
-                }
                 else if ("tool" in action) {
                     log(`${prefix} executing tool`, { tool: action.tool.name });
                     const result = await ctx.client.session.prompt({
@@ -184,28 +182,14 @@ const SmartfrogPlugin = async (ctx) => {
             }
         },
         tool: {
-            skill: tool({
-                description: `Load a skill to get detailed instructions for a specific task. Skills provide specialized knowledge and step-by-step guidance. Use this when a task matches an available skill's description. <available_skills>${skills.map((s) => `\n  <skill>\n    <name>${s.name}</name>\n    <description>${s.description}</description>\n  </skill>`).join("")}\n</available_skills>`,
-                args: {
-                    name: tool.schema
-                        .string()
-                        .describe("The skill identifier from available_skills (e.g., 'post-change-code-simplification')"),
-                },
-                async execute(args, _context) {
-                    const skill = skills.find((s) => s.name === args.name);
-                    if (!skill) {
-                        const available = skills.map((s) => s.name).join(", ");
-                        throw new Error(`Skill "${args.name}" not found. Available skills: ${available || "none"}`);
-                    }
-                    return [
-                        `## Skill: ${skill.name}`,
-                        "",
-                        `**Base directory**: ${dirname(skill.path)}`,
-                        "",
-                        skill.body,
-                    ].join("\n");
-                },
-            }),
+            gitingest: gitingestTool,
+            "diff-summary": createDiffSummaryTool(ctx.directory),
+            "prompt-session": createPromptSessionTool(ctx.client),
+            "list-child-sessions": createListChildSessionsTool(ctx.client),
+            "eth-transaction": ethTransactionTool,
+            "eth-address-txs": ethAddressTxsTool,
+            "eth-address-balance": ethAddressBalanceTool,
+            "eth-token-transfers": ethTokenTransfersTool,
         },
         "tool.execute.before": async (input, output) => {
             const sessionID = input.sessionID;
@@ -247,7 +231,6 @@ const SmartfrogPlugin = async (ctx) => {
                 if (!sessionID)
                     return;
                 if (!info.parentID) {
-                    mainSessionID = sessionID;
                     log("[event] session.created - main session", { sessionID });
                 }
                 await triggerHooks("session.created", sessionID);
@@ -260,21 +243,13 @@ const SmartfrogPlugin = async (ctx) => {
                 log("[event] session.deleted", { sessionID });
                 await triggerHooks("session.deleted", sessionID);
                 modifiedCodeFiles.delete(sessionID);
-                if (sessionID === mainSessionID) {
-                    mainSessionID = undefined;
-                }
             }
             if (event.type === "session.idle") {
                 const sessionID = props?.sessionID;
-                log("[event] session.idle", { sessionID, mainSessionID });
                 if (!sessionID)
                     return;
-                if (!mainSessionID) {
-                    mainSessionID = sessionID;
-                    log("[event] session.idle - setting mainSessionID from idle event", { sessionID });
-                }
-                const eventHooks = hooks.get("session.idle");
-                if (!eventHooks || eventHooks.length === 0) {
+                log("[event] session.idle", { sessionID });
+                if (!hooks.has("session.idle")) {
                     log("[event] session.idle - no hooks defined, skipping");
                     return;
                 }

package/dist/index.test.js

@@ -113,16 +113,39 @@ Content`;
         expect(result["minimal"]).not.toHaveProperty("tools");
         expect(result["minimal"]).not.toHaveProperty("permissions");
     });
-    it("should convert agent mode to primary", () => {
-        const agentContent = `---
+    it("should use mode value directly (primary, subagent, all)", () => {
+        const primaryContent = `---
 description: Primary agent
-mode: agent
+mode: primary
 ---
 
 Content`;
-        writeFileSync(join(testDir, "primary.md"), agentContent);
+        const subagentContent = `---
+description: Subagent
+mode: subagent
+---
+
+Content`;
+        const allContent = `---
+description: All modes agent
+mode: all
+---
+
+Content`;
+        const noModeContent = `---
+description: No mode specified
+---
+
+Content`;
+        writeFileSync(join(testDir, "primary.md"), primaryContent);
+        writeFileSync(join(testDir, "subagent.md"), subagentContent);
+        writeFileSync(join(testDir, "all.md"), allContent);
+        writeFileSync(join(testDir, "nomode.md"), noModeContent);
         const result = loadAgents(testDir);
         expect(result["primary"].mode).toBe("primary");
+        expect(result["subagent"].mode).toBe("subagent");
+        expect(result["all"].mode).toBe("all");
+        expect(result["nomode"].mode).toBe("all");
     });
     it("should ignore non-markdown files", () => {
         writeFileSync(join(testDir, "not-agent.txt"), "some content");
@@ -286,7 +309,6 @@ hooks:
     conditions: [isMainSession]
     actions:
       - command: simplify-changes
-      - skill: post-change-code-simplification
       - tool:
           name: bash
           args:
@@ -296,10 +318,9 @@ hooks:
         const result = loadHooks(testDir);
         const hooks = result.get("session.idle");
         expect(hooks).toHaveLength(1);
-        expect(hooks[0].actions).toHaveLength(3);
+        expect(hooks[0].actions).toHaveLength(2);
         expect(hooks[0].actions[0]).toEqual({ command: "simplify-changes" });
-        expect(hooks[0].actions[1]).toEqual({ skill: "post-change-code-simplification" });
-        expect(hooks[0].actions[2]).toEqual({
+        expect(hooks[0].actions[1]).toEqual({
             tool: { name: "bash", args: { command: "echo done" } }
         });
     });

package/dist/loaders.d.ts

@@ -1,7 +1,10 @@
 export interface AgentFrontmatter {
     description: string;
-    mode?: "subagent" | "agent";
+    mode?: "primary" | "subagent" | "all";
+    model?: string;
     temperature?: number;
+    maxSteps?: number;
+    disable?: boolean;
     tools?: Record<string, boolean>;
     permission?: Record<string, unknown>;
     permissions?: Record<string, unknown>;
@@ -17,6 +20,7 @@ export interface CommandFrontmatter {
     description: string;
     agent?: string;
     model?: string;
+    subtask?: boolean;
 }
 export interface CommandConfig {
     template: string;
@@ -39,9 +43,6 @@ export interface HookActionCommand {
         args: string;
     };
 }
-export interface HookActionSkill {
-    skill: string;
-}
 export interface HookActionTool {
     tool: {
         name: string;
@@ -54,7 +55,7 @@ export interface HookActionBash {
         timeout?: number;
     };
 }
-export type HookAction = HookActionCommand | HookActionSkill | HookActionTool | HookActionBash;
+export type HookAction = HookActionCommand | HookActionTool | HookActionBash;
 export interface HookConfig {
     event: HookEvent;
     conditions?: HookCondition[];
@@ -63,7 +64,10 @@ export interface HookConfig {
 export interface AgentConfigOutput {
     description: string;
     mode: "subagent" | "primary" | "all";
+    model?: string;
     temperature?: number;
+    maxSteps?: number;
+    disable?: boolean;
     tools?: Record<string, boolean>;
     permissions?: Record<string, unknown>;
     prompt: string;

package/dist/loaders.js

@@ -37,13 +37,16 @@ export function loadAgents(agentDir) {
         const content = readFileSync(filePath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const agentName = basename(file, ".md");
-        const mode = data.mode === "agent" ? "primary" : "subagent";
+        const mode = data.mode ?? "all";
         const permissions = data.permissions ?? data.permission;
         agents[agentName] = {
             description: data.description || "",
             mode,
             prompt: body.trim(),
+            ...(data.model !== undefined && { model: data.model }),
             ...(data.temperature !== undefined && { temperature: data.temperature }),
+            ...(data.maxSteps !== undefined && { maxSteps: data.maxSteps }),
+            ...(data.disable !== undefined && { disable: data.disable }),
             ...(data.tools !== undefined && { tools: data.tools }),
             ...(permissions !== undefined && { permissions }),
         };
@@ -86,6 +89,7 @@ export function loadCommands(commandDir) {
             description: data.description || "",
             agent: data.agent,
             model: data.model,
+            subtask: data.subtask,
             template: body.trim(),
         };
     }

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

@@ -0,0 +1,20 @@
+/**
+ * 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: {
+    description: string;
+    args: {
+        address: import("zod").ZodString;
+        chainId: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        address: string;
+        chainId?: string | undefined;
+    }, context: ToolContext): Promise<string>;
+};

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

@@ -0,0 +1,37 @@
+/**
+ * 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";
+export async function getAddressBalance(address, chainId) {
+    validateAddress(address);
+    const client = new EtherscanClient(undefined, chainId);
+    const balanceWei = await client.getBalance(address);
+    return formatBalance(address, balanceWei);
+}
+export const ethAddressBalanceTool = tool({
+    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),
+    },
+    async execute(args, _context) {
+        try {
+            return await getAddressBalance(args.address, args.chainId);
+        }
+        catch (error) {
+            if (error instanceof EtherscanClientError) {
+                return `Error: ${error.message}`;
+            }
+            throw error;
+        }
+    },
+});

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

@@ -0,0 +1,23 @@
+/**
+ * Tool to list Ethereum transactions for an address
+ */
+import { type ToolContext } from "@opencode-ai/plugin";
+export interface EthAddressTxsArgs {
+    address: string;
+    limit?: number;
+    chainId?: string;
+}
+export declare function getAddressTransactions(address: string, limit?: number, chainId?: string): Promise<string>;
+export declare const ethAddressTxsTool: {
+    description: string;
+    args: {
+        address: import("zod").ZodString;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        chainId: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        address: string;
+        limit?: number | undefined;
+        chainId?: string | undefined;
+    }, context: ToolContext): Promise<string>;
+};

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

@@ -0,0 +1,41 @@
+/**
+ * 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";
+export async function getAddressTransactions(address, limit = DEFAULT_TRANSACTION_LIMIT, chainId) {
+    validateAddress(address);
+    const client = new EtherscanClient(undefined, chainId);
+    const transactions = await client.getTransactions(address, limit);
+    return formatTransactionList(address, transactions);
+}
+export const ethAddressTxsTool = tool({
+    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),
+    },
+    async execute(args, _context) {
+        try {
+            return await getAddressTransactions(args.address, args.limit, args.chainId);
+        }
+        catch (error) {
+            if (error instanceof EtherscanClientError) {
+                return `Error: ${error.message}`;
+            }
+            throw error;
+        }
+    },
+});

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

@@ -0,0 +1,23 @@
+/**
+ * Tool to list ERC-20 token transfers for an address
+ */
+import { type ToolContext } from "@opencode-ai/plugin";
+export interface EthTokenTransfersArgs {
+    address: string;
+    limit?: number;
+    chainId?: string;
+}
+export declare function getTokenTransfers(address: string, limit?: number, chainId?: string): Promise<string>;
+export declare const ethTokenTransfersTool: {
+    description: string;
+    args: {
+        address: import("zod").ZodString;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        chainId: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        address: string;
+        limit?: number | undefined;
+        chainId?: string | undefined;
+    }, context: ToolContext): Promise<string>;
+};

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

@@ -0,0 +1,41 @@
+/**
+ * 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";
+export async function getTokenTransfers(address, limit = DEFAULT_TRANSACTION_LIMIT, chainId) {
+    validateAddress(address);
+    const client = new EtherscanClient(undefined, chainId);
+    const transfers = await client.getTokenTransfers(address, limit);
+    return formatTokenTransferList(address, transfers);
+}
+export const ethTokenTransfersTool = tool({
+    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),
+    },
+    async execute(args, _context) {
+        try {
+            return await getTokenTransfers(args.address, args.limit, args.chainId);
+        }
+        catch (error) {
+            if (error instanceof EtherscanClientError) {
+                return `Error: ${error.message}`;
+            }
+            throw error;
+        }
+    },
+});

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

@@ -0,0 +1,20 @@
+/**
+ * Tool to get Ethereum transaction details by hash
+ */
+import { type ToolContext } from "@opencode-ai/plugin";
+export interface EthTransactionArgs {
+    hash: string;
+    chainId?: string;
+}
+export declare function getTransactionDetails(hash: string, chainId?: string): Promise<string>;
+export declare const ethTransactionTool: {
+    description: string;
+    args: {
+        hash: import("zod").ZodString;
+        chainId: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        hash: string;
+        chainId?: string | undefined;
+    }, context: ToolContext): Promise<string>;
+};

package/dist/tools/blockchain/eth-transaction.js

@@ -0,0 +1,40 @@
+/**
+ * Tool to get Ethereum transaction details by hash
+ */
+import { tool } from "@opencode-ai/plugin";
+import { EtherscanClient, EtherscanClientError, validateTxHash } from "./etherscan-client";
+import { formatTransactionReceipt } from "./formatters";
+import { CHAIN_ID_DESCRIPTION } from "./types";
+export async function getTransactionDetails(hash, chainId) {
+    validateTxHash(hash);
+    const client = new EtherscanClient(undefined, chainId);
+    const receipt = await client.getTransactionReceipt(hash);
+    if (!receipt) {
+        return `Transaction not found: ${hash}`;
+    }
+    return formatTransactionReceipt(hash, receipt);
+}
+export const ethTransactionTool = tool({
+    description: "Get Ethereum transaction details by transaction hash. " +
+        "Returns status, block, addresses, gas costs, and log count.",
+    args: {
+        hash: tool.schema
+            .string()
+            .describe("Transaction hash (0x...)"),
+        chainId: tool.schema
+            .string()
+            .optional()
+            .describe(CHAIN_ID_DESCRIPTION),
+    },
+    async execute(args, _context) {
+        try {
+            return await getTransactionDetails(args.hash, args.chainId);
+        }
+        catch (error) {
+            if (error instanceof EtherscanClientError) {
+                return `Error: ${error.message}`;
+            }
+            throw error;
+        }
+    },
+});

package/dist/tools/blockchain/etherscan-client.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Etherscan API client for Ethereum blockchain queries
+ */
+import { type EthTransaction, type EthTokenTransfer, type EthInternalTransaction } from "./types";
+export declare class EtherscanClientError extends Error {
+    constructor(message: string);
+}
+export declare class EtherscanClient {
+    private readonly apiKey;
+    private readonly chainId;
+    private readonly baseUrl;
+    constructor(apiKey?: string, chainId?: string, baseUrl?: string);
+    private request;
+    getBalance(address: string): Promise<string>;
+    getTransactions(address: string, limit?: number): Promise<EthTransaction[]>;
+    getInternalTransactions(address: string, limit?: number): Promise<EthInternalTransaction[]>;
+    getTokenTransfers(address: string, limit?: number): Promise<EthTokenTransfer[]>;
+    getTransactionByHash(hash: string): Promise<EthTransaction | null>;
+    getTransactionReceipt(hash: string): Promise<Record<string, unknown> | null>;
+}
+export declare function weiToEth(wei: string): string;
+export declare function formatTimestamp(timestamp: string): string;
+export declare function shortenAddress(address: string): string;
+export declare function validateAddress(address: string): void;
+export declare function validateTxHash(hash: string): void;