opencode-froggy 0.10.1 → 0.11.0

package/command/gh-create-pr.md

@@ -10,6 +10,10 @@ agent: build
 
 ## Your task
 
+**If the current branch is `master`, `main`, `develop`, or `dev`:**
+   - Warn the user that committing directly to this branch is discouraged
+   - Propose to create a new feature branch with a suggested name based on the changes
+
 1. /commit-push to commit and push all changes
 2. Once the push is complete, create a PR using `gh pr create`:
    - Use the commit message as PR title

package/dist/index.js

@@ -5,7 +5,7 @@ import { getGlobalHookDir, getProjectHookDir } from "./config-paths";
 import { hasCodeExtension } from "./code-files";
 import { log } from "./logger";
 import { executeBashAction, DEFAULT_BASH_TIMEOUT, } from "./bash-executor";
-import { gitingestTool, pdfToMarkdownTool, createPromptSessionTool, createListChildSessionsTool, createAgentPromoteTool, createSkillTool, getPromotedAgents, ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, } from "./tools";
+import { gitingestTool, pdfToMarkdownTool, createPromptSessionTool, createListChildSessionsTool, createAgentPromoteTool, getPromotedAgents, ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, } from "./tools";
 export { parseFrontmatter, loadAgents, loadCommands } from "./loaders";
 export { buildSkillActivationBlock } from "./skill-activation";
 import { buildSkillActivationBlock } from "./skill-activation";
@@ -34,11 +34,6 @@ const SmartfrogPlugin = async (ctx) => {
     const skillActivationBlock = skillsWithTriggers.length > 0
         ? buildSkillActivationBlock(skillsWithTriggers)
         : null;
-    const skillTool = createSkillTool({
-        pluginSkills: skills,
-        pluginDir: PLUGIN_ROOT,
-        client: ctx.client,
-    });
     log("[init] Plugin loaded", {
         agents: Object.keys(agents),
         commands: Object.keys(commands),
@@ -48,7 +43,6 @@ const SmartfrogPlugin = async (ctx) => {
         tools: [
             "gitingest",
             "pdf-to-markdown",
-            "skill",
             "agent-promote",
             "eth-transaction",
             "eth-address-txs",
@@ -203,11 +197,20 @@ const SmartfrogPlugin = async (ctx) => {
             if (Object.keys(commands).length > 0) {
                 config.command = { ...(config.command ?? {}), ...commands };
             }
+            if (skills.length > 0) {
+                const existingSkills = config.skills ?? {};
+                const existingPaths = Array.isArray(existingSkills.paths) ? existingSkills.paths : [];
+                config.skills = {
+                    ...existingSkills,
+                    paths: existingPaths.includes(SKILL_DIR)
+                        ? existingPaths
+                        : [...existingPaths, SKILL_DIR],
+                };
+            }
         },
         tool: {
             gitingest: gitingestTool,
             "pdf-to-markdown": pdfToMarkdownTool,
-            skill: skillTool,
             "prompt-session": createPromptSessionTool(ctx.client),
             "list-child-sessions": createListChildSessionsTool(ctx.client),
             "agent-promote": createAgentPromoteTool(ctx.client, Object.keys(agents)),
@@ -284,9 +287,11 @@ const SmartfrogPlugin = async (ctx) => {
             }
         },
         "experimental.chat.system.transform": async (_input, output) => {
-            if (!skillActivationBlock)
-                return;
-            output.system.push(skillActivationBlock);
+            // The activation block relies on OpenCode's native `skill` tool after we
+            // expose the plugin's bundled skills through `config.skills.paths`.
+            if (skillActivationBlock) {
+                output.system.push(skillActivationBlock);
+            }
         },
     };
 };

package/dist/tools/index.d.ts

@@ -4,5 +4,4 @@ export { pdfToMarkdownTool } from "./pdf-to-markdown";
 export { createPromptSessionTool, type PromptSessionArgs } from "./prompt-session";
 export { createListChildSessionsTool } from "./list-child-sessions";
 export { createAgentPromoteTool, getPromotedAgents, type AgentPromoteArgs } from "./agent-promote";
-export { createSkillTool, type CreateSkillToolOptions, type SkillInfo } from "./skill";
 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

@@ -4,5 +4,4 @@ export { pdfToMarkdownTool } from "./pdf-to-markdown";
 export { createPromptSessionTool } from "./prompt-session";
 export { createListChildSessionsTool } from "./list-child-sessions";
 export { createAgentPromoteTool, getPromotedAgents } from "./agent-promote";
-export { createSkillTool } from "./skill";
 export { ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, EtherscanClient, EtherscanClientError, weiToEth, formatTimestamp, shortenAddress, } from "./blockchain";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-froggy",
-  "version": "0.10.1",
+  "version": "0.11.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",

package/dist/tools/skill.d.ts

@@ -1,25 +0,0 @@
-import { type ToolContext } from "@opencode-ai/plugin";
-import type { createOpencodeClient } from "@opencode-ai/sdk";
-import { type LoadedSkill } from "../loaders";
-type Client = ReturnType<typeof createOpencodeClient>;
-export interface SkillInfo {
-    name: string;
-    description: string;
-    location: string;
-    scope: "plugin" | "opencode" | "opencode-project" | "claude" | "claude-project";
-}
-export interface CreateSkillToolOptions {
-    pluginSkills: LoadedSkill[];
-    pluginDir: string;
-    client: Client;
-}
-export declare function createSkillTool(options: CreateSkillToolOptions): {
-    description: string;
-    args: {
-        name: import("zod").ZodString;
-    };
-    execute(args: {
-        name: string;
-    }, context: ToolContext): Promise<string>;
-};
-export {};

package/dist/tools/skill.js

@@ -1,165 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { homedir } from "node:os";
-import { parseFrontmatter } from "../loaders";
-import { log } from "../logger";
-const TOOL_DESCRIPTION_PREFIX = `Load a skill to get detailed instructions for a specific task.`;
-const TOOL_DESCRIPTION_NO_SKILLS = `${TOOL_DESCRIPTION_PREFIX} No skills are currently available.`;
-function discoverSkillsFromDir(skillsDir, scope) {
-    if (!existsSync(skillsDir))
-        return [];
-    const skills = [];
-    try {
-        const entries = readdirSync(skillsDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.name.startsWith("."))
-                continue;
-            const entryPath = join(skillsDir, entry.name);
-            if (entry.isDirectory()) {
-                const skillMdPath = join(entryPath, "SKILL.md");
-                if (!existsSync(skillMdPath))
-                    continue;
-                try {
-                    const content = readFileSync(skillMdPath, "utf-8");
-                    const { data } = parseFrontmatter(content);
-                    if (data.name && data.description) {
-                        skills.push({
-                            name: data.name,
-                            description: data.description,
-                            location: skillMdPath,
-                            scope,
-                        });
-                    }
-                }
-                catch {
-                    // Skip invalid skill files
-                }
-            }
-        }
-    }
-    catch {
-        // Directory not accessible
-    }
-    return skills;
-}
-function discoverOpencodeGlobalSkills() {
-    const skillsDir = join(homedir(), ".config", "opencode", "skill");
-    return discoverSkillsFromDir(skillsDir, "opencode");
-}
-function discoverOpencodeProjectSkills(cwd) {
-    const skillsDir = join(cwd, ".opencode", "skill");
-    return discoverSkillsFromDir(skillsDir, "opencode-project");
-}
-function discoverClaudeGlobalSkills() {
-    const skillsDir = join(homedir(), ".claude", "skills");
-    return discoverSkillsFromDir(skillsDir, "claude");
-}
-function discoverClaudeProjectSkills(cwd) {
-    const skillsDir = join(cwd, ".claude", "skills");
-    return discoverSkillsFromDir(skillsDir, "claude-project");
-}
-function pluginSkillsToInfo(skills, pluginDir) {
-    return skills.map(s => ({
-        name: s.name,
-        description: s.description,
-        location: s.path || join(pluginDir, "skill", s.name, "SKILL.md"),
-        scope: "plugin",
-    }));
-}
-function formatSkillsXml(skills) {
-    if (skills.length === 0)
-        return "";
-    const skillsXml = skills
-        .map(skill => {
-        return [
-            "  <skill>",
-            `    <name>${skill.name}</name>`,
-            `    <description>${skill.description}</description>`,
-            "  </skill>",
-        ].join("\n");
-    })
-        .join("\n");
-    return `\n\n<available_skills>\n${skillsXml}\n</available_skills>`;
-}
-function loadSkillContent(location) {
-    const content = readFileSync(location, "utf-8");
-    const { body } = parseFrontmatter(content);
-    return body.trim();
-}
-export function createSkillTool(options) {
-    let cachedSkills = null;
-    let cachedDescription = null;
-    const { client, pluginDir, pluginSkills } = options;
-    const getSkills = (cwd) => {
-        if (cachedSkills)
-            return cachedSkills;
-        // Merge order: plugin defaults < global < project (later entries override earlier on name collision)
-        const allSkills = [
-            ...pluginSkillsToInfo(pluginSkills, pluginDir),
-            ...discoverClaudeGlobalSkills(),
-            ...discoverOpencodeGlobalSkills(),
-            ...discoverClaudeProjectSkills(cwd),
-            ...discoverOpencodeProjectSkills(cwd),
-        ];
-        // Deduplicate by name - last definition wins (project > global > plugin)
-        const skillMap = new Map();
-        for (const skill of allSkills) {
-            skillMap.set(skill.name, skill);
-        }
-        cachedSkills = Array.from(skillMap.values());
-        return cachedSkills;
-    };
-    const getDescription = (cwd) => {
-        if (cachedDescription)
-            return cachedDescription;
-        const skills = getSkills(cwd);
-        cachedDescription =
-            skills.length === 0
-                ? TOOL_DESCRIPTION_NO_SKILLS
-                : TOOL_DESCRIPTION_PREFIX + formatSkillsXml(skills);
-        return cachedDescription;
-    };
-    // Pre-compute with current working directory
-    const cwd = process.cwd();
-    getDescription(cwd);
-    return tool({
-        get description() {
-            return cachedDescription ?? TOOL_DESCRIPTION_PREFIX;
-        },
-        args: {
-            name: tool.schema
-                .string()
-                .describe("The skill identifier from available_skills (e.g., 'code-review' or 'category/helper')"),
-        },
-        async execute(args, _context) {
-            const skills = getSkills(cwd);
-            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"}`);
-            }
-            const body = loadSkillContent(skill.location);
-            const dir = dirname(skill.location);
-            try {
-                await client.tui.showToast({
-                    body: {
-                        message: `Skill "${skill.name}" loaded`,
-                        variant: "info",
-                        duration: 3000,
-                    },
-                });
-            }
-            catch (error) {
-                log("[skill] Failed to show toast", { error: String(error) });
-            }
-            return [
-                `## Skill: ${skill.name}`,
-                "",
-                `**Base directory**: ${dir}`,
-                "",
-                body,
-            ].join("\n");
-        },
-    });
-}

package/dist/tools/skill.test.d.ts

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

package/dist/tools/skill.test.js

@@ -1,231 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { parseFrontmatter } from "../loaders";
-function discoverSkillsFromDir(skillsDir, scope) {
-    const { existsSync, readdirSync, readFileSync } = require("node:fs");
-    if (!existsSync(skillsDir))
-        return [];
-    const skills = [];
-    try {
-        const entries = readdirSync(skillsDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.name.startsWith("."))
-                continue;
-            const entryPath = join(skillsDir, entry.name);
-            if (entry.isDirectory()) {
-                const skillMdPath = join(entryPath, "SKILL.md");
-                if (!existsSync(skillMdPath))
-                    continue;
-                try {
-                    const content = readFileSync(skillMdPath, "utf-8");
-                    const { data } = parseFrontmatter(content);
-                    if (data.name && data.description) {
-                        skills.push({
-                            name: data.name,
-                            description: data.description,
-                            location: skillMdPath,
-                            scope,
-                        });
-                    }
-                }
-                catch {
-                    // Skip invalid skill files
-                }
-            }
-        }
-    }
-    catch {
-        // Directory not accessible
-    }
-    return skills;
-}
-function pluginSkillsToInfo(skills, pluginDir) {
-    return skills.map(s => ({
-        name: s.name,
-        description: s.description,
-        location: s.path || join(pluginDir, "skill", s.name, "SKILL.md"),
-        scope: "plugin",
-    }));
-}
-function formatSkillsXml(skills) {
-    if (skills.length === 0)
-        return "";
-    const skillsXml = skills
-        .map(skill => {
-        return [
-            "  <skill>",
-            `    <name>${skill.name}</name>`,
-            `    <description>${skill.description}</description>`,
-            "  </skill>",
-        ].join("\n");
-    })
-        .join("\n");
-    return `\n\n<available_skills>\n${skillsXml}\n</available_skills>`;
-}
-describe("skill discovery", () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = join(tmpdir(), `skill-test-${Date.now()}`);
-        mkdirSync(testDir, { recursive: true });
-    });
-    afterEach(() => {
-        rmSync(testDir, { recursive: true, force: true });
-    });
-    function createSkillFile(dir, name, content) {
-        const skillDir = join(dir, name);
-        mkdirSync(skillDir, { recursive: true });
-        const skillPath = join(skillDir, "SKILL.md");
-        writeFileSync(skillPath, content);
-        return skillPath;
-    }
-    describe("discoverSkillsFromDir", () => {
-        it("should return empty array for non-existent directory", () => {
-            const result = discoverSkillsFromDir("/non/existent/path", "plugin");
-            expect(result).toEqual([]);
-        });
-        it("should discover valid skill with name and description", () => {
-            createSkillFile(testDir, "my-skill", `---
-name: my-skill
-description: A test skill
----
-
-Skill content here.`);
-            const result = discoverSkillsFromDir(testDir, "opencode");
-            expect(result).toHaveLength(1);
-            expect(result[0].name).toBe("my-skill");
-            expect(result[0].description).toBe("A test skill");
-            expect(result[0].scope).toBe("opencode");
-        });
-        it("should ignore directories without SKILL.md", () => {
-            const skillDir = join(testDir, "no-skill");
-            mkdirSync(skillDir);
-            writeFileSync(join(skillDir, "README.md"), "Not a skill");
-            const result = discoverSkillsFromDir(testDir, "plugin");
-            expect(result).toHaveLength(0);
-        });
-        it("should ignore skills without name", () => {
-            createSkillFile(testDir, "nameless", `---
-description: Has description but no name
----
-
-Content`);
-            const result = discoverSkillsFromDir(testDir, "plugin");
-            expect(result).toHaveLength(0);
-        });
-        it("should ignore skills without description", () => {
-            createSkillFile(testDir, "no-desc", `---
-name: no-desc-skill
----
-
-Content`);
-            const result = discoverSkillsFromDir(testDir, "plugin");
-            expect(result).toHaveLength(0);
-        });
-        it("should ignore hidden directories", () => {
-            createSkillFile(testDir, ".hidden-skill", `---
-name: hidden
-description: Hidden skill
----
-
-Content`);
-            const result = discoverSkillsFromDir(testDir, "plugin");
-            expect(result).toHaveLength(0);
-        });
-        it("should discover multiple skills", () => {
-            createSkillFile(testDir, "skill-a", `---
-name: skill-a
-description: First skill
----
-Content A`);
-            createSkillFile(testDir, "skill-b", `---
-name: skill-b
-description: Second skill
----
-Content B`);
-            const result = discoverSkillsFromDir(testDir, "opencode-project");
-            expect(result).toHaveLength(2);
-            expect(result.map(s => s.name).sort()).toEqual(["skill-a", "skill-b"]);
-        });
-    });
-    describe("pluginSkillsToInfo", () => {
-        it("should convert LoadedSkill array to SkillInfo array", () => {
-            const pluginSkills = [
-                {
-                    name: "test-skill",
-                    description: "A test skill",
-                    path: "/fake/path/SKILL.md",
-                    body: "Test body",
-                },
-            ];
-            const result = pluginSkillsToInfo(pluginSkills, "/plugin/dir");
-            expect(result).toHaveLength(1);
-            expect(result[0].name).toBe("test-skill");
-            expect(result[0].description).toBe("A test skill");
-            expect(result[0].location).toBe("/fake/path/SKILL.md");
-            expect(result[0].scope).toBe("plugin");
-        });
-        it("should use default path when path not provided", () => {
-            const pluginSkills = [
-                {
-                    name: "no-path-skill",
-                    description: "Skill without path",
-                    path: "",
-                    body: "",
-                },
-            ];
-            const result = pluginSkillsToInfo(pluginSkills, "/my/plugin");
-            expect(result[0].location).toBe("/my/plugin/skill/no-path-skill/SKILL.md");
-        });
-    });
-    describe("formatSkillsXml", () => {
-        it("should return empty string for no skills", () => {
-            const result = formatSkillsXml([]);
-            expect(result).toBe("");
-        });
-        it("should format single skill as XML", () => {
-            const skills = [
-                {
-                    name: "my-skill",
-                    description: "My description",
-                    location: "/path",
-                    scope: "plugin",
-                },
-            ];
-            const result = formatSkillsXml(skills);
-            expect(result).toContain("<available_skills>");
-            expect(result).toContain("<name>my-skill</name>");
-            expect(result).toContain("<description>My description</description>");
-            expect(result).toContain("</available_skills>");
-        });
-        it("should format multiple skills", () => {
-            const skills = [
-                { name: "skill-a", description: "Desc A", location: "/a", scope: "plugin" },
-                { name: "skill-b", description: "Desc B", location: "/b", scope: "opencode" },
-            ];
-            const result = formatSkillsXml(skills);
-            expect(result).toContain("<name>skill-a</name>");
-            expect(result).toContain("<name>skill-b</name>");
-        });
-    });
-    describe("skill deduplication", () => {
-        it("should demonstrate last-wins deduplication behavior", () => {
-            // This tests the expected behavior when skills are merged
-            const allSkills = [
-                { name: "shared", description: "Plugin version", location: "/plugin", scope: "plugin" },
-                { name: "shared", description: "Global version", location: "/global", scope: "opencode" },
-                { name: "shared", description: "Project version", location: "/project", scope: "opencode-project" },
-            ];
-            // Simulate deduplication (last wins)
-            const skillMap = new Map();
-            for (const skill of allSkills) {
-                skillMap.set(skill.name, skill);
-            }
-            const deduplicated = Array.from(skillMap.values());
-            expect(deduplicated).toHaveLength(1);
-            expect(deduplicated[0].description).toBe("Project version");
-            expect(deduplicated[0].scope).toBe("opencode-project");
-        });
-    });
-});