opencode-froggy 0.1.0 → 0.2.0

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/diff-summary.d.ts

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,111 @@
+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/gitingest.d.ts

@@ -0,0 +1,26 @@
+import { type ToolContext } from "@opencode-ai/plugin";
+export interface GitingestArgs {
+    url: string;
+    maxFileSize?: number;
+    pattern?: string;
+    patternType?: "include" | "exclude";
+}
+export declare function fetchGitingest(args: GitingestArgs): Promise<string>;
+export declare const gitingestTool: {
+    description: string;
+    args: {
+        url: import("zod").ZodString;
+        maxFileSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+        pattern: import("zod").ZodOptional<import("zod").ZodString>;
+        patternType: import("zod").ZodOptional<import("zod").ZodEnum<{
+            include: "include";
+            exclude: "exclude";
+        }>>;
+    };
+    execute(args: {
+        url: string;
+        maxFileSize?: number | undefined;
+        pattern?: string | undefined;
+        patternType?: "include" | "exclude" | undefined;
+    }, context: ToolContext): Promise<string>;
+};

package/dist/tools/gitingest.js

@@ -0,0 +1,41 @@
+import { tool } from "@opencode-ai/plugin";
+export async function fetchGitingest(args) {
+    const response = await fetch("https://gitingest.com/api/ingest", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            input_text: args.url,
+            max_file_size: args.maxFileSize ?? 50000,
+            pattern: args.pattern ?? "",
+            pattern_type: args.patternType ?? "exclude",
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`gitingest API error: ${response.status} ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return `${data.summary}\n\n${data.tree}\n\n${data.content}`;
+}
+export const gitingestTool = tool({
+    description: "Fetch a GitHub repository's full content via gitingest.com. Returns summary, directory tree, and file contents optimized for LLM analysis. Use when you need to understand an external repository's structure or code.",
+    args: {
+        url: tool.schema
+            .string()
+            .describe("GitHub repository URL (e.g., https://github.com/owner/repo)"),
+        maxFileSize: tool.schema
+            .number()
+            .optional()
+            .describe("Maximum file size in bytes to include (default: 50000)"),
+        pattern: tool.schema
+            .string()
+            .optional()
+            .describe("Glob pattern to filter files (e.g., '*.py' or 'src/*')"),
+        patternType: tool.schema
+            .enum(["include", "exclude"])
+            .optional()
+            .describe("Whether pattern includes or excludes matching files (default: exclude)"),
+    },
+    async execute(args, _context) {
+        return fetchGitingest(args);
+    },
+});

package/dist/tools/index.d.ts

@@ -0,0 +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";

package/dist/tools/index.js

@@ -0,0 +1,4 @@
+export { gitingestTool, fetchGitingest } from "./gitingest";
+export { createDiffSummaryTool, diffSummary } from "./diff-summary";
+export { createPromptSessionTool } from "./prompt-session";
+export { createListChildSessionsTool } from "./list-child-sessions";

package/dist/tools/list-child-sessions.d.ts

@@ -0,0 +1,9 @@
+import { type ToolContext } from "@opencode-ai/plugin";
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+type Client = ReturnType<typeof createOpencodeClient>;
+export declare function createListChildSessionsTool(client: Client): {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: ToolContext): Promise<string>;
+};
+export {};

package/dist/tools/list-child-sessions.js

@@ -0,0 +1,24 @@
+import { tool } from "@opencode-ai/plugin";
+import { log } from "../logger";
+export function createListChildSessionsTool(client) {
+    return tool({
+        description: "List all child sessions (subagents) of the current session",
+        args: {},
+        async execute(_args, context) {
+            const children = await client.session.children({
+                path: { id: context.sessionID },
+            });
+            const childList = children.data ?? [];
+            if (childList.length === 0) {
+                return "No child sessions found";
+            }
+            log("[list-child-sessions] Found child sessions", { count: childList.length });
+            const formatted = childList.map((child, index) => {
+                const created = new Date(child.time.created).toISOString();
+                const updated = new Date(child.time.updated).toISOString();
+                return `${index + 1}. [${child.id}] ${child.title}\n   Created: ${created} | Updated: ${updated}`;
+            }).join("\n\n");
+            return `Child sessions (${childList.length}):\n\n${formatted}`;
+        },
+    });
+}

package/dist/tools/prompt-session.d.ts

@@ -0,0 +1,19 @@
+import { type ToolContext } from "@opencode-ai/plugin";
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+type Client = ReturnType<typeof createOpencodeClient>;
+export interface PromptSessionArgs {
+    message: string;
+    sessionId?: string;
+}
+export declare function createPromptSessionTool(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/prompt-session.js

@@ -0,0 +1,39 @@
+import { tool } from "@opencode-ai/plugin";
+import { log } from "../logger";
+export function createPromptSessionTool(client) {
+    return tool({
+        description: "Send a message to a 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("[prompt-session] Sending message to child session", {
+                parentSessionID: context.sessionID,
+                childSessionID: targetSessionId,
+                messagePreview: args.message.slice(0, 100),
+            });
+            const response = await client.session.prompt({
+                path: { id: targetSessionId },
+                body: { parts: [{ type: "text", text: args.message }] },
+            });
+            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";
+        },
+    });
+}

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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,42 @@
+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";
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-froggy",
-  "version": "0.1.0",
+  "version": "0.2.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",
@@ -9,7 +9,9 @@
     "dist",
     "agent",
     "command",
-    "skill"
+    "skill",
+    "images",
+    "README.md"
   ],
   "scripts": {
     "build": "tsc",

package/command/commit.md

@@ -1,18 +0,0 @@
----
-description: Commit and push
-agent: build
----
-
-## Context
-
-- Current git status: !`git status`
-- Current git diff (staged and unstaged changes): !`git diff HEAD`
-- Current branch: !`git branch --show-current`
-
-## Your task
-
-Based on the above changes:
-1. Create a new branch if on main or master
-2. Create a single commit with an appropriate message
-3. Push the branch to origin
-4. You have the capability to call multiple tools in a single response. You MUST do all of the above in a single message. Do not use any other tools or do anything else. Do not send any other text or messages besides these tool calls.