opencode-froggy 0.3.0 → 0.4.0

package/dist/tools/blockchain/event-decoder.js

@@ -0,0 +1,96 @@
+/**
+ * Event decoder for common ERC-20 and WETH events
+ */
+const EVENT_SIGNATURES = {
+    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef": "Transfer",
+    "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925": "Approval",
+    "0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c": "Deposit",
+    "0x7fcf532c15f0a6db0bd6d0e038bea71d30d808c7d98cb3bf7268a95bf5081b65": "Withdrawal",
+};
+function decodeAddress(topic) {
+    return "0x" + topic.slice(26).toLowerCase();
+}
+function decodeUint256(data) {
+    const hex = data.startsWith("0x") ? data.slice(2) : data;
+    if (hex === "")
+        return "0";
+    return BigInt("0x" + hex).toString();
+}
+export async function decodeEvent(log, resolver) {
+    const topic0 = log.topics[0];
+    const signature = EVENT_SIGNATURES[topic0];
+    if (!signature) {
+        return null;
+    }
+    const contractAddress = await resolver.resolve(log.address);
+    switch (signature) {
+        case "Transfer": {
+            if (log.topics.length < 3)
+                return null;
+            const from = decodeAddress(log.topics[1]);
+            const to = decodeAddress(log.topics[2]);
+            const value = decodeUint256(log.data);
+            return {
+                name: "Transfer",
+                address: contractAddress,
+                params: { from, to, value },
+            };
+        }
+        case "Approval": {
+            if (log.topics.length < 3)
+                return null;
+            const owner = decodeAddress(log.topics[1]);
+            const spender = decodeAddress(log.topics[2]);
+            const value = decodeUint256(log.data);
+            return {
+                name: "Approval",
+                address: contractAddress,
+                params: { owner, spender, value },
+            };
+        }
+        case "Deposit": {
+            if (log.topics.length < 2)
+                return null;
+            const dst = decodeAddress(log.topics[1]);
+            const wad = decodeUint256(log.data);
+            return {
+                name: "Deposit",
+                address: contractAddress,
+                params: { dst, wad },
+            };
+        }
+        case "Withdrawal": {
+            if (log.topics.length < 2)
+                return null;
+            const src = decodeAddress(log.topics[1]);
+            const wad = decodeUint256(log.data);
+            return {
+                name: "Withdrawal",
+                address: contractAddress,
+                params: { src, wad },
+            };
+        }
+        default:
+            return null;
+    }
+}
+export async function decodeEvents(logs, resolver) {
+    const decoded = [];
+    let undecodedCount = 0;
+    for (const log of logs) {
+        const event = await decodeEvent(log, resolver);
+        if (event) {
+            decoded.push(event);
+        }
+        else {
+            undecodedCount++;
+        }
+    }
+    return { decoded, undecodedCount };
+}
+export function isKnownEvent(topic0) {
+    return topic0 in EVENT_SIGNATURES;
+}
+export function getEventName(topic0) {
+    return EVENT_SIGNATURES[topic0] ?? null;
+}

package/dist/tools/blockchain/event-decoder.test.d.ts

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

package/dist/tools/blockchain/event-decoder.test.js

@@ -0,0 +1,197 @@
+import { describe, it, expect } from "vitest";
+import { decodeEvent, decodeEvents, isKnownEvent, getEventName, } from "./event-decoder";
+const mockResolver = {
+    async resolve(address) {
+        return { address, label: null };
+    },
+};
+describe("Event Decoder", () => {
+    describe("isKnownEvent", () => {
+        it("should recognize Transfer event", () => {
+            const topic0 = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+            expect(isKnownEvent(topic0)).toBe(true);
+        });
+        it("should recognize Approval event", () => {
+            const topic0 = "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925";
+            expect(isKnownEvent(topic0)).toBe(true);
+        });
+        it("should recognize Deposit event", () => {
+            const topic0 = "0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c";
+            expect(isKnownEvent(topic0)).toBe(true);
+        });
+        it("should recognize Withdrawal event", () => {
+            const topic0 = "0x7fcf532c15f0a6db0bd6d0e038bea71d30d808c7d98cb3bf7268a95bf5081b65";
+            expect(isKnownEvent(topic0)).toBe(true);
+        });
+        it("should return false for unknown event", () => {
+            const topic0 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+            expect(isKnownEvent(topic0)).toBe(false);
+        });
+    });
+    describe("getEventName", () => {
+        it("should return Transfer for Transfer topic", () => {
+            const topic0 = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+            expect(getEventName(topic0)).toBe("Transfer");
+        });
+        it("should return null for unknown topic", () => {
+            const topic0 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+            expect(getEventName(topic0)).toBe(null);
+        });
+    });
+    describe("decodeEvent", () => {
+        it("should decode Transfer event", async () => {
+            const log = {
+                address: "0x6b175474e89094c44da98b954eedeac495271d0f",
+                topics: [
+                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                    "0x000000000000000000000000ba12222222228d8ba445958a75a0704d566bf2c8",
+                    "0x000000000000000000000000000000002b0184b12e908bf97941f2f5385c9820",
+                ],
+                data: "0x000000000000000000000000000000000000000000000278fd3c000000000000",
+                blockNumber: "0x1234",
+                transactionHash: "0xabc",
+                transactionIndex: "0x0",
+                blockHash: "0xdef",
+                logIndex: "0x0",
+                removed: false,
+            };
+            const result = await decodeEvent(log, mockResolver);
+            expect(result).not.toBeNull();
+            expect(result.name).toBe("Transfer");
+            expect(result.params.from).toBe("0xba12222222228d8ba445958a75a0704d566bf2c8");
+            expect(result.params.to).toBe("0x000000002b0184b12e908bf97941f2f5385c9820");
+            expect(result.params.value).toBe("11676589714374635028480");
+        });
+        it("should decode Approval event", async () => {
+            const log = {
+                address: "0x6b175474e89094c44da98b954eedeac495271d0f",
+                topics: [
+                    "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
+                    "0x0000000000000000000000001111111111111111111111111111111111111111",
+                    "0x0000000000000000000000002222222222222222222222222222222222222222",
+                ],
+                data: "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000",
+                blockNumber: "0x1234",
+                transactionHash: "0xabc",
+                transactionIndex: "0x0",
+                blockHash: "0xdef",
+                logIndex: "0x0",
+                removed: false,
+            };
+            const result = await decodeEvent(log, mockResolver);
+            expect(result).not.toBeNull();
+            expect(result.name).toBe("Approval");
+            expect(result.params.owner).toBe("0x1111111111111111111111111111111111111111");
+            expect(result.params.spender).toBe("0x2222222222222222222222222222222222222222");
+            expect(result.params.value).toBe("1000000000000000000");
+        });
+        it("should decode Deposit event (WETH)", async () => {
+            const log = {
+                address: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                topics: [
+                    "0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c",
+                    "0x0000000000000000000000001111111111111111111111111111111111111111",
+                ],
+                data: "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000",
+                blockNumber: "0x1234",
+                transactionHash: "0xabc",
+                transactionIndex: "0x0",
+                blockHash: "0xdef",
+                logIndex: "0x0",
+                removed: false,
+            };
+            const result = await decodeEvent(log, mockResolver);
+            expect(result).not.toBeNull();
+            expect(result.name).toBe("Deposit");
+            expect(result.params.dst).toBe("0x1111111111111111111111111111111111111111");
+            expect(result.params.wad).toBe("1000000000000000000");
+        });
+        it("should decode Withdrawal event (WETH)", async () => {
+            const log = {
+                address: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                topics: [
+                    "0x7fcf532c15f0a6db0bd6d0e038bea71d30d808c7d98cb3bf7268a95bf5081b65",
+                    "0x0000000000000000000000001111111111111111111111111111111111111111",
+                ],
+                data: "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000",
+                blockNumber: "0x1234",
+                transactionHash: "0xabc",
+                transactionIndex: "0x0",
+                blockHash: "0xdef",
+                logIndex: "0x0",
+                removed: false,
+            };
+            const result = await decodeEvent(log, mockResolver);
+            expect(result).not.toBeNull();
+            expect(result.name).toBe("Withdrawal");
+            expect(result.params.src).toBe("0x1111111111111111111111111111111111111111");
+            expect(result.params.wad).toBe("1000000000000000000");
+        });
+        it("should return null for unknown event", async () => {
+            const log = {
+                address: "0x1234567890123456789012345678901234567890",
+                topics: ["0x0000000000000000000000000000000000000000000000000000000000000000"],
+                data: "0x",
+                blockNumber: "0x1234",
+                transactionHash: "0xabc",
+                transactionIndex: "0x0",
+                blockHash: "0xdef",
+                logIndex: "0x0",
+                removed: false,
+            };
+            const result = await decodeEvent(log, mockResolver);
+            expect(result).toBeNull();
+        });
+    });
+    describe("decodeEvents", () => {
+        it("should decode multiple events and count undecoded", async () => {
+            const logs = [
+                {
+                    address: "0x6b175474e89094c44da98b954eedeac495271d0f",
+                    topics: [
+                        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                        "0x0000000000000000000000001111111111111111111111111111111111111111",
+                        "0x0000000000000000000000002222222222222222222222222222222222222222",
+                    ],
+                    data: "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000",
+                    blockNumber: "0x1234",
+                    transactionHash: "0xabc",
+                    transactionIndex: "0x0",
+                    blockHash: "0xdef",
+                    logIndex: "0x0",
+                    removed: false,
+                },
+                {
+                    address: "0x1234567890123456789012345678901234567890",
+                    topics: ["0x0000000000000000000000000000000000000000000000000000000000000000"],
+                    data: "0x",
+                    blockNumber: "0x1234",
+                    transactionHash: "0xabc",
+                    transactionIndex: "0x0",
+                    blockHash: "0xdef",
+                    logIndex: "0x1",
+                    removed: false,
+                },
+                {
+                    address: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                    topics: [
+                        "0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c",
+                        "0x0000000000000000000000001111111111111111111111111111111111111111",
+                    ],
+                    data: "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000",
+                    blockNumber: "0x1234",
+                    transactionHash: "0xabc",
+                    transactionIndex: "0x0",
+                    blockHash: "0xdef",
+                    logIndex: "0x2",
+                    removed: false,
+                },
+            ];
+            const result = await decodeEvents(logs, mockResolver);
+            expect(result.decoded.length).toBe(2);
+            expect(result.undecodedCount).toBe(1);
+            expect(result.decoded[0].name).toBe("Transfer");
+            expect(result.decoded[1].name).toBe("Deposit");
+        });
+    });
+});

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,4 @@
 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 { 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,4 @@
 export { gitingestTool, fetchGitingest } from "./gitingest";
-export { createDiffSummaryTool, diffSummary } from "./diff-summary";
 export { createPromptSessionTool } from "./prompt-session";
 export { createListChildSessionsTool } from "./list-child-sessions";
 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.4.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 {};