opencode-froggy 0.3.0 → 0.5.0

package/dist/tools/blockchain/types.d.ts

@@ -85,6 +85,70 @@ export interface TransactionLog {
     logIndex: string;
     removed: boolean;
 }
+export interface ContractInfo {
+    SourceCode: string;
+    ABI: string;
+    ContractName: string;
+    CompilerVersion: string;
+    OptimizationUsed: string;
+    Runs: string;
+    ConstructorArguments: string;
+    EVMVersion: string;
+    Library: string;
+    LicenseType: string;
+    Proxy: string;
+    Implementation: string;
+    SwarmSource: string;
+}
+export interface LabeledAddress {
+    address: string;
+    label: string | null;
+}
+export interface TokenMetadata {
+    name: string;
+    symbol: string;
+    decimals: number;
+}
+export interface DecodedEvent {
+    name: string;
+    address: LabeledAddress;
+    params: Record<string, string>;
+}
+export interface TransactionDetails {
+    hash: string;
+    status: "success" | "failed";
+    block: number;
+    timestamp: string | null;
+    from: LabeledAddress;
+    to: LabeledAddress | null;
+    value: string;
+    gas: {
+        used: number;
+        price: string;
+        cost: string;
+    };
+    internalTransactions?: InternalTransactionDetails[];
+    tokenTransfers?: TokenTransferDetails[];
+    decodedEvents?: DecodedEvent[];
+    undecodedEventsCount?: number;
+}
+export interface InternalTransactionDetails {
+    from: LabeledAddress;
+    to: LabeledAddress;
+    value: string;
+    type: string;
+}
+export interface TokenTransferDetails {
+    token: {
+        address: string;
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
+    from: LabeledAddress;
+    to: LabeledAddress;
+    value: string;
+}
 export declare const DEFAULT_TRANSACTION_LIMIT = 20;
 export declare const DEFAULT_CHAIN_ID = "1";
 export declare const CHAIN_ID_DESCRIPTION: string;

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

@@ -0,0 +1,9 @@
+/**
+ * Viem client for EVM RPC calls
+ * Uses public RPCs to avoid Etherscan rate limits
+ */
+import { type TransactionReceipt, type Block } from "viem";
+import { type TokenMetadata } from "./types";
+export declare function getTransactionReceipt(hash: string, chainId?: string): Promise<TransactionReceipt | null>;
+export declare function getBlock(blockNumber: bigint, chainId?: string): Promise<Block | null>;
+export declare function getTokenMetadata(contractAddress: string, chainId?: string): Promise<TokenMetadata>;

package/dist/tools/blockchain/viem-client.js

@@ -0,0 +1,98 @@
+/**
+ * Viem client for EVM RPC calls
+ * Uses public RPCs to avoid Etherscan rate limits
+ */
+import { createPublicClient, http, parseAbi, } from "viem";
+import { mainnet, polygon, arbitrum, optimism, base, bsc, avalanche, fantom, zkSync, gnosis, celo, linea, scroll, mantle, blast, } from "viem/chains";
+import { DEFAULT_CHAIN_ID } from "./types";
+const CHAIN_MAP = {
+    "1": mainnet,
+    "137": polygon,
+    "42161": arbitrum,
+    "10": optimism,
+    "8453": base,
+    "56": bsc,
+    "43114": avalanche,
+    "250": fantom,
+    "324": zkSync,
+    "100": gnosis,
+    "42220": celo,
+    "59144": linea,
+    "534352": scroll,
+    "5000": mantle,
+    "81457": blast,
+};
+const ERC20_ABI = parseAbi([
+    "function name() view returns (string)",
+    "function symbol() view returns (string)",
+    "function decimals() view returns (uint8)",
+]);
+const clientCache = new Map();
+function getClient(chainId) {
+    const cached = clientCache.get(chainId);
+    if (cached) {
+        return cached;
+    }
+    const chain = CHAIN_MAP[chainId] ?? mainnet;
+    const client = createPublicClient({
+        chain,
+        transport: http(),
+        batch: {
+            multicall: true,
+        },
+    });
+    clientCache.set(chainId, client);
+    return client;
+}
+export async function getTransactionReceipt(hash, chainId = DEFAULT_CHAIN_ID) {
+    const client = getClient(chainId);
+    try {
+        return await client.getTransactionReceipt({
+            hash: hash,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+export async function getBlock(blockNumber, chainId = DEFAULT_CHAIN_ID) {
+    const client = getClient(chainId);
+    try {
+        return await client.getBlock({ blockNumber });
+    }
+    catch {
+        return null;
+    }
+}
+export async function getTokenMetadata(contractAddress, chainId = DEFAULT_CHAIN_ID) {
+    const client = getClient(chainId);
+    const address = contractAddress;
+    const [name, symbol, decimals] = await Promise.all([
+        client
+            .readContract({
+            address,
+            abi: ERC20_ABI,
+            functionName: "name",
+        })
+            .catch(() => null),
+        client
+            .readContract({
+            address,
+            abi: ERC20_ABI,
+            functionName: "symbol",
+        })
+            .catch(() => null),
+        client
+            .readContract({
+            address,
+            abi: ERC20_ABI,
+            functionName: "decimals",
+        })
+            .catch(() => null),
+    ]);
+    return {
+        name: name ?? "Unknown",
+        symbol: symbol ?? "???",
+        decimals: decimals ?? 18,
+    };
+}

package/dist/tools/index.d.ts

@@ -1,5 +1,5 @@
 export { gitingestTool, fetchGitingest, type GitingestArgs } from "./gitingest";
-export { createDiffSummaryTool, diffSummary, type DiffSummaryArgs } from "./diff-summary";
 export { createPromptSessionTool, type PromptSessionArgs } from "./prompt-session";
 export { createListChildSessionsTool } from "./list-child-sessions";
+export { createAgentPromoteTool, getPromotedAgents, type AgentPromoteArgs } from "./agent-promote";
 export { ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, EtherscanClient, EtherscanClientError, weiToEth, formatTimestamp, shortenAddress, type EthTransactionArgs, type EthAddressTxsArgs, type EthAddressBalanceArgs, type EthTokenTransfersArgs, } from "./blockchain";

package/dist/tools/index.js

@@ -1,5 +1,5 @@
 export { gitingestTool, fetchGitingest } from "./gitingest";
-export { createDiffSummaryTool, diffSummary } from "./diff-summary";
 export { createPromptSessionTool } from "./prompt-session";
 export { createListChildSessionsTool } from "./list-child-sessions";
+export { createAgentPromoteTool, getPromotedAgents } from "./agent-promote";
 export { ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, EtherscanClient, EtherscanClientError, weiToEth, formatTimestamp, shortenAddress, } from "./blockchain";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-froggy",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "OpenCode plugin with a hook layer (tool.before.*, session.idle...), agents (code-reviewer, doc-writer), and commands (/review-pr, /commit)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -38,7 +38,8 @@
     "url": "https://github.com/smartfrog/opencode-froggy"
   },
   "dependencies": {
-    "js-yaml": "^4.1.0"
+    "js-yaml": "^4.1.0",
+    "viem": "^2.44.1"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "latest",

package/skill/code-simplify/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: code-simplify
+description: Simplify code you just wrote or modified. Load after completing a feature, fix, or refactor to improve clarity while preserving behavior.
+---
+
+Run the `/simplify-changes` command.

package/dist/tools/diff-summary.d.ts

@@ -1,20 +0,0 @@
-import { type ToolContext } from "@opencode-ai/plugin";
-export interface DiffSummaryArgs {
-    source?: string;
-    target?: string;
-    remote?: string;
-}
-export declare function diffSummary(args: DiffSummaryArgs, cwd: string): Promise<string>;
-export declare function createDiffSummaryTool(directory: string): {
-    description: string;
-    args: {
-        source: import("zod").ZodOptional<import("zod").ZodString>;
-        target: import("zod").ZodOptional<import("zod").ZodString>;
-        remote: import("zod").ZodOptional<import("zod").ZodString>;
-    };
-    execute(args: {
-        source?: string | undefined;
-        target?: string | undefined;
-        remote?: string | undefined;
-    }, context: ToolContext): Promise<string>;
-};

package/dist/tools/diff-summary.js

@@ -1,111 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { tool } from "@opencode-ai/plugin";
-import { log } from "../logger";
-const execFileAsync = promisify(execFile);
-const DIFF_CONTEXT_LINES = 5;
-async function git(args, cwd) {
-    try {
-        const result = await execFileAsync("git", args, { cwd, maxBuffer: 10 * 1024 * 1024 });
-        return result.stdout;
-    }
-    catch (error) {
-        const execError = error;
-        if (execError.stdout)
-            return execError.stdout;
-        throw error;
-    }
-}
-async function getDiffSet(cwd, extraArgs = []) {
-    const [stats, files, diff] = await Promise.all([
-        git(["diff", ...extraArgs, "--stat"], cwd),
-        git(["diff", ...extraArgs, "--name-status"], cwd),
-        git(["diff", ...extraArgs, `-U${DIFF_CONTEXT_LINES}`, "--function-context"], cwd),
-    ]);
-    return { stats, files, diff };
-}
-async function getBranchesDiff(source, target, remote, cwd) {
-    const refSource = remote ? `${remote}/${source}` : source;
-    const refTarget = remote ? `${remote}/${target}` : target;
-    const range = `${refTarget}...${refSource}`;
-    const rangeLog = `${refTarget}..${refSource}`;
-    if (remote) {
-        await git(["fetch", remote, source, target, "--prune"], cwd);
-    }
-    const [stats, commits, files, diff] = await Promise.all([
-        git(["diff", "--stat", range], cwd),
-        git(["log", "--oneline", "--no-merges", rangeLog], cwd),
-        git(["diff", "--name-only", range], cwd),
-        git(["diff", `-U${DIFF_CONTEXT_LINES}`, "--function-context", range], cwd),
-    ]);
-    return [
-        "## Stats Overview", "```", stats.trim(), "```",
-        "",
-        "## Commits to Review", "```", commits.trim(), "```",
-        "",
-        "## Files Changed", "```", files.trim(), "```",
-        "",
-        "## Full Diff", "```diff", diff.trim(), "```",
-    ].join("\n\n");
-}
-async function getWorkingTreeDiff(cwd) {
-    const sections = [];
-    const [status, staged, unstaged, untrackedList] = await Promise.all([
-        git(["status", "--porcelain=v1", "-uall"], cwd),
-        getDiffSet(cwd, ["--cached"]),
-        getDiffSet(cwd),
-        git(["ls-files", "--others", "--exclude-standard"], cwd),
-    ]);
-    sections.push("## Status Overview", "```", status.trim() || "(no changes)", "```");
-    if (staged.stats.trim() || staged.files.trim()) {
-        sections.push("## Staged Changes", "### Stats", "```", staged.stats.trim() || "(none)", "```", "### Files", "```", staged.files.trim() || "(none)", "```", "### Diff", "```diff", staged.diff.trim() || "(none)", "```");
-    }
-    if (unstaged.stats.trim() || unstaged.files.trim()) {
-        sections.push("## Unstaged Changes", "### Stats", "```", unstaged.stats.trim() || "(none)", "```", "### Files", "```", unstaged.files.trim() || "(none)", "```", "### Diff", "```diff", unstaged.diff.trim() || "(none)", "```");
-    }
-    const untrackedFiles = untrackedList.trim().split("\n").filter(Boolean);
-    if (untrackedFiles.length > 0) {
-        const untrackedDiffs = [];
-        for (const file of untrackedFiles) {
-            try {
-                const fileDiff = await git(["diff", "--no-index", `-U${DIFF_CONTEXT_LINES}`, "--function-context", "--", "/dev/null", file], cwd);
-                untrackedDiffs.push(`=== NEW: ${file} ===\n${fileDiff.trim()}`);
-            }
-            catch (error) {
-                log("[diff-summary] failed to diff untracked file", { file, error: String(error) });
-                untrackedDiffs.push(`=== NEW: ${file} === (could not diff)`);
-            }
-        }
-        sections.push("## Untracked Files", "```", untrackedFiles.join("\n"), "```", "### Diffs", "```diff", untrackedDiffs.join("\n\n"), "```");
-    }
-    return sections.join("\n\n");
-}
-export async function diffSummary(args, cwd) {
-    const { source, target = "main", remote = "origin" } = args;
-    if (source) {
-        return getBranchesDiff(source, target, remote, cwd);
-    }
-    return getWorkingTreeDiff(cwd);
-}
-export function createDiffSummaryTool(directory) {
-    return tool({
-        description: "Generate a structured summary of git diffs. Use for reviewing branches comparison or working tree changes. Returns stats, commits, files changed, and full diff.",
-        args: {
-            source: tool.schema
-                .string()
-                .optional()
-                .describe("Source branch to compare (e.g., 'feature-branch'). If omitted, analyzes working tree changes."),
-            target: tool.schema
-                .string()
-                .optional()
-                .describe("Target branch to compare against (default: 'main')"),
-            remote: tool.schema
-                .string()
-                .optional()
-                .describe("Git remote name (default: 'origin')"),
-        },
-        async execute(args, _context) {
-            return diffSummary(args, directory);
-        },
-    });
-}

package/dist/tools/reply-child.d.ts

@@ -1,19 +0,0 @@
-import { type ToolContext } from "@opencode-ai/plugin";
-import type { createOpencodeClient } from "@opencode-ai/sdk";
-type Client = ReturnType<typeof createOpencodeClient>;
-export interface ReplyChildArgs {
-    message: string;
-    sessionId?: string;
-}
-export declare function createReplyChildTool(client: Client): {
-    description: string;
-    args: {
-        message: import("zod").ZodString;
-        sessionId: import("zod").ZodOptional<import("zod").ZodString>;
-    };
-    execute(args: {
-        message: string;
-        sessionId?: string | undefined;
-    }, context: ToolContext): Promise<string>;
-};
-export {};

package/dist/tools/reply-child.js

@@ -1,42 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-import { log } from "../logger";
-export function createReplyChildTool(client) {
-    return tool({
-        description: "Send a message to the last child session (subagent) to continue the conversation",
-        args: {
-            message: tool.schema.string().describe("The message to send to the child session"),
-            sessionId: tool.schema.string().optional().describe("The child session ID to target (optional - uses last child if not provided)"),
-        },
-        async execute(args, context) {
-            let targetSessionId = args.sessionId;
-            if (!targetSessionId) {
-                const children = await client.session.children({
-                    path: { id: context.sessionID },
-                });
-                const lastChild = (children.data ?? []).at(-1);
-                if (!lastChild) {
-                    return "Error: No child session found for current session";
-                }
-                targetSessionId = lastChild.id;
-            }
-            log("[reply-child] Sending message to child session", {
-                parentSessionID: context.sessionID,
-                childSessionID: targetSessionId,
-                message: args.message.slice(0, 100),
-            });
-            const response = await client.session.prompt({
-                path: { id: targetSessionId },
-                body: { parts: [{ type: "text", text: args.message }] },
-            });
-            log("[reply-child] Response received", {
-                childSessionID: targetSessionId,
-            });
-            const parts = response.data?.parts ?? [];
-            const textContent = parts
-                .filter((p) => p.type === "text" && p.text)
-                .map((p) => p.text)
-                .join("\n");
-            return textContent || "Message sent to child session";
-        },
-    });
-}