opencode-froggy 0.10.1 → 0.10.2

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,8 @@ 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, createSkillTool, formatPluginSkillsAsXmlItems, getPromotedAgents, ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, } from "./tools";
+import { injectPluginSkillsIntoSystem } from "./skill-injection";
 export { parseFrontmatter, loadAgents, loadCommands } from "./loaders";
 export { buildSkillActivationBlock } from "./skill-activation";
 import { buildSkillActivationBlock } from "./skill-activation";
@@ -37,8 +38,12 @@ const SmartfrogPlugin = async (ctx) => {
     const skillTool = createSkillTool({
         pluginSkills: skills,
         pluginDir: PLUGIN_ROOT,
+        cwd: ctx.directory,
         client: ctx.client,
     });
+    const pluginSkillsXmlItems = skills.length > 0
+        ? formatPluginSkillsAsXmlItems(skills, PLUGIN_ROOT)
+        : null;
     log("[init] Plugin loaded", {
         agents: Object.keys(agents),
         commands: Object.keys(commands),
@@ -284,9 +289,10 @@ const SmartfrogPlugin = async (ctx) => {
             }
         },
         "experimental.chat.system.transform": async (_input, output) => {
-            if (!skillActivationBlock)
-                return;
-            output.system.push(skillActivationBlock);
+            injectPluginSkillsIntoSystem(output.system, pluginSkillsXmlItems);
+            if (skillActivationBlock) {
+                output.system.push(skillActivationBlock);
+            }
         },
     };
 };

package/dist/skill-injection.d.ts

@@ -0,0 +1 @@
+export declare function injectPluginSkillsIntoSystem(system: string[], pluginSkillsXmlItems: string | null): void;

package/dist/skill-injection.js

@@ -0,0 +1,13 @@
+const AVAILABLE_SKILLS_BLOCK_REGEX = /(<available_skills>[\s\S]*?)(<\/available_skills>)/;
+export function injectPluginSkillsIntoSystem(system, pluginSkillsXmlItems) {
+    if (!pluginSkillsXmlItems)
+        return;
+    for (let i = 0; i < system.length; i++) {
+        const segment = system[i];
+        if (AVAILABLE_SKILLS_BLOCK_REGEX.test(segment)) {
+            system[i] = segment.replace(AVAILABLE_SKILLS_BLOCK_REGEX, `$1${pluginSkillsXmlItems}\n$2`);
+            return;
+        }
+    }
+    system.push(`<available_skills>\n${pluginSkillsXmlItems}\n</available_skills>`);
+}

package/dist/skill-injection.test.d.ts

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

package/dist/skill-injection.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect } from "vitest";
+import { injectPluginSkillsIntoSystem } from "./skill-injection";
+const SAMPLE_ITEMS = `  <skill>\n    <name>tdd</name>\n    <description>Apply TDD</description>\n  </skill>`;
+describe("injectPluginSkillsIntoSystem", () => {
+    it("should do nothing when pluginSkillsXmlItems is null", () => {
+        const system = ["some prompt", "<available_skills>\n  <skill><name>x</name></skill>\n</available_skills>"];
+        const before = [...system];
+        injectPluginSkillsIntoSystem(system, null);
+        expect(system).toEqual(before);
+    });
+    it("should inject items inside existing <available_skills> block", () => {
+        const system = [
+            "header text",
+            "<available_skills>\n  <skill>\n    <name>x</name>\n    <description>d</description>\n  </skill>\n</available_skills>",
+            "footer text",
+        ];
+        injectPluginSkillsIntoSystem(system, SAMPLE_ITEMS);
+        expect(system[0]).toBe("header text");
+        expect(system[2]).toBe("footer text");
+        expect(system[1]).toContain("<name>x</name>");
+        expect(system[1]).toContain("<name>tdd</name>");
+        const openCount = (system[1].match(/<available_skills>/g) ?? []).length;
+        const closeCount = (system[1].match(/<\/available_skills>/g) ?? []).length;
+        expect(openCount).toBe(1);
+        expect(closeCount).toBe(1);
+    });
+    it("should inject items before </available_skills>", () => {
+        const system = [
+            "<available_skills>\n  <skill>\n    <name>native</name>\n    <description>n</description>\n  </skill>\n</available_skills>",
+        ];
+        injectPluginSkillsIntoSystem(system, SAMPLE_ITEMS);
+        const nativeIndex = system[0].indexOf("<name>native</name>");
+        const tddIndex = system[0].indexOf("<name>tdd</name>");
+        const closeIndex = system[0].indexOf("</available_skills>");
+        expect(nativeIndex).toBeGreaterThan(-1);
+        expect(tddIndex).toBeGreaterThan(nativeIndex);
+        expect(closeIndex).toBeGreaterThan(tddIndex);
+    });
+    it("should push a standalone block when no <available_skills> exists", () => {
+        const system = ["plain prompt", "another segment"];
+        injectPluginSkillsIntoSystem(system, SAMPLE_ITEMS);
+        expect(system).toHaveLength(3);
+        expect(system[2]).toBe(`<available_skills>\n${SAMPLE_ITEMS}\n</available_skills>`);
+    });
+    it("should only inject into the first matching segment", () => {
+        const system = [
+            "<available_skills>\n  <skill>\n    <name>first</name>\n    <description>d</description>\n  </skill>\n</available_skills>",
+            "<available_skills>\n  <skill>\n    <name>second</name>\n    <description>d</description>\n  </skill>\n</available_skills>",
+        ];
+        injectPluginSkillsIntoSystem(system, SAMPLE_ITEMS);
+        expect(system[0]).toContain("<name>tdd</name>");
+        expect(system[1]).not.toContain("<name>tdd</name>");
+    });
+    it("should do nothing when pluginSkillsXmlItems is empty string", () => {
+        const system = ["<available_skills>\n</available_skills>"];
+        const before = [...system];
+        injectPluginSkillsIntoSystem(system, "");
+        expect(system).toEqual(before);
+    });
+});

package/dist/tools/index.d.ts

@@ -4,5 +4,5 @@ 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 { createSkillTool, discoverAllSkills, formatPluginSkillsAsXmlItems, type CreateSkillToolOptions, type DiscoverAllSkillsOptions, type SkillInfo, type SkillScope, } 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,5 @@ 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 { createSkillTool, discoverAllSkills, formatPluginSkillsAsXmlItems, } from "./skill";
 export { ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, EtherscanClient, EtherscanClientError, weiToEth, formatTimestamp, shortenAddress, } from "./blockchain";

package/dist/tools/skill.d.ts

@@ -2,15 +2,24 @@ 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 type SkillScope = "plugin" | "opencode" | "opencode-project" | "claude" | "claude-project";
 export interface SkillInfo {
     name: string;
     description: string;
     location: string;
-    scope: "plugin" | "opencode" | "opencode-project" | "claude" | "claude-project";
+    scope: SkillScope;
 }
+export interface DiscoverAllSkillsOptions {
+    pluginSkills: LoadedSkill[];
+    pluginDir: string;
+    cwd: string;
+}
+export declare function discoverAllSkills(options: DiscoverAllSkillsOptions): SkillInfo[];
+export declare function formatPluginSkillsAsXmlItems(skills: LoadedSkill[], pluginDir: string): string;
 export interface CreateSkillToolOptions {
     pluginSkills: LoadedSkill[];
     pluginDir: string;
+    cwd: string;
     client: Client;
 }
 export declare function createSkillTool(options: CreateSkillToolOptions): {

package/dist/tools/skill.js

@@ -15,26 +15,25 @@ function discoverSkillsFromDir(skillsDir, scope) {
         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))
+            if (!entry.isDirectory())
+                continue;
+            const skillMdPath = join(skillsDir, entry.name, "SKILL.md");
+            if (!existsSync(skillMdPath))
+                continue;
+            try {
+                const content = readFileSync(skillMdPath, "utf-8");
+                const { data } = parseFrontmatter(content);
+                if (!data.name || !data.description)
                     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
-                }
+                skills.push({
+                    name: data.name,
+                    description: data.description,
+                    location: skillMdPath,
+                    scope,
+                });
+            }
+            catch {
+                // Skip invalid skill files
             }
         }
     }
@@ -43,22 +42,6 @@ function discoverSkillsFromDir(skillsDir, scope) {
     }
     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,
@@ -67,20 +50,42 @@ function pluginSkillsToInfo(skills, pluginDir) {
         scope: "plugin",
     }));
 }
+function formatSkillItems(skills) {
+    return skills
+        .map(skill => [
+        "  <skill>",
+        `    <name>${skill.name}</name>`,
+        `    <description>${skill.description}</description>`,
+        "  </skill>",
+    ].join("\n"))
+        .join("\n");
+}
 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>`;
+    return `<available_skills>\n${formatSkillItems(skills)}\n</available_skills>`;
+}
+export function discoverAllSkills(options) {
+    const { pluginSkills, pluginDir, cwd } = options;
+    // Merge order: plugin < claude global < opencode global < claude project < opencode project
+    // Later entries override earlier on name collision (project > global > plugin)
+    const allSkills = [
+        ...pluginSkillsToInfo(pluginSkills, pluginDir),
+        ...discoverSkillsFromDir(join(homedir(), ".claude", "skills"), "claude"),
+        ...discoverSkillsFromDir(join(homedir(), ".config", "opencode", "skills"), "opencode"),
+        ...discoverSkillsFromDir(join(cwd, ".claude", "skills"), "claude-project"),
+        ...discoverSkillsFromDir(join(cwd, ".opencode", "skills"), "opencode-project"),
+    ];
+    const skillMap = new Map();
+    for (const skill of allSkills) {
+        skillMap.set(skill.name, skill);
+    }
+    return Array.from(skillMap.values());
+}
+export function formatPluginSkillsAsXmlItems(skills, pluginDir) {
+    if (skills.length === 0)
+        return "";
+    return formatSkillItems(pluginSkillsToInfo(skills, pluginDir));
 }
 function loadSkillContent(location) {
     const content = readFileSync(location, "utf-8");
@@ -88,52 +93,19 @@ function loadSkillContent(location) {
     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);
+    const { client, pluginDir, pluginSkills, cwd } = options;
+    const skills = discoverAllSkills({ pluginSkills, pluginDir, cwd });
+    const description = skills.length === 0
+        ? TOOL_DESCRIPTION_NO_SKILLS
+        : `${TOOL_DESCRIPTION_PREFIX}\n\n${formatSkillsXml(skills)}`;
     return tool({
-        get description() {
-            return cachedDescription ?? TOOL_DESCRIPTION_PREFIX;
-        },
+        description,
         args: {
             name: tool.schema
                 .string()
-                .describe("The skill identifier from available_skills (e.g., 'code-review' or 'category/helper')"),
+                .describe("The skill identifier from available_skills (e.g., 'tdd', 'openspec-propose')"),
         },
         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(", ");

package/dist/tools/skill.test.js

@@ -2,230 +2,217 @@ 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;
+import { discoverAllSkills, formatPluginSkillsAsXmlItems, } from "./skill";
+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;
 }
-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", () => {
+describe("formatPluginSkillsAsXmlItems", () => {
+    it("should return empty string for no skills", () => {
+        expect(formatPluginSkillsAsXmlItems([], "/plugin")).toBe("");
+    });
+    it("should format skills without wrapping <available_skills> tags", () => {
+        const skills = [
+            { name: "tdd", description: "Apply TDD", path: "/p/SKILL.md", body: "" },
+        ];
+        const result = formatPluginSkillsAsXmlItems(skills, "/plugin");
+        expect(result).toContain("<skill>");
+        expect(result).toContain("<name>tdd</name>");
+        expect(result).toContain("<description>Apply TDD</description>");
+        expect(result).not.toContain("<available_skills>");
+    });
+    it("should format multiple skills", () => {
+        const skills = [
+            { name: "a", description: "A", path: "/a", body: "" },
+            { name: "b", description: "B", path: "/b", body: "" },
+        ];
+        const result = formatPluginSkillsAsXmlItems(skills, "/plugin");
+        expect(result).toContain("<name>a</name>");
+        expect(result).toContain("<name>b</name>");
+    });
+});
+describe("discoverAllSkills", () => {
     let testDir;
     beforeEach(() => {
-        testDir = join(tmpdir(), `skill-test-${Date.now()}`);
+        testDir = join(tmpdir(), `skill-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
         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 return empty array when no skills and no plugin skills", () => {
+        const result = discoverAllSkills({
+            pluginSkills: [],
+            pluginDir: "/plugin",
+            cwd: testDir,
         });
-        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);
+        expect(result).toEqual([]);
+    });
+    it("should include plugin skills with scope=plugin", () => {
+        const pluginSkills = [
+            { name: "tdd", description: "TDD", path: "/plugin/skill/tdd/SKILL.md", body: "" },
+        ];
+        const result = discoverAllSkills({
+            pluginSkills,
+            pluginDir: "/plugin",
+            cwd: testDir,
         });
-        it("should ignore skills without name", () => {
-            createSkillFile(testDir, "nameless", `---
-description: Has description but no name
+        expect(result).toHaveLength(1);
+        expect(result[0].name).toBe("tdd");
+        expect(result[0].scope).toBe("plugin");
+    });
+    it("should discover .opencode/skills/ in cwd", () => {
+        const opencodeDir = join(testDir, ".opencode", "skills");
+        mkdirSync(opencodeDir, { recursive: true });
+        createSkillFile(opencodeDir, "project-skill", `---
+name: project-skill
+description: From project
 ---
-
-Content`);
-            const result = discoverSkillsFromDir(testDir, "plugin");
-            expect(result).toHaveLength(0);
+Body`);
+        const result = discoverAllSkills({
+            pluginSkills: [],
+            pluginDir: "/plugin",
+            cwd: testDir,
         });
-        it("should ignore skills without description", () => {
-            createSkillFile(testDir, "no-desc", `---
-name: no-desc-skill
+        expect(result).toHaveLength(1);
+        expect(result[0].name).toBe("project-skill");
+        expect(result[0].scope).toBe("opencode-project");
+    });
+    it("should discover .claude/skills/ in cwd", () => {
+        const claudeDir = join(testDir, ".claude", "skills");
+        mkdirSync(claudeDir, { recursive: true });
+        createSkillFile(claudeDir, "claude-skill", `---
+name: claude-skill
+description: From claude
 ---
-
-Content`);
-            const result = discoverSkillsFromDir(testDir, "plugin");
-            expect(result).toHaveLength(0);
+Body`);
+        const result = discoverAllSkills({
+            pluginSkills: [],
+            pluginDir: "/plugin",
+            cwd: testDir,
         });
-        it("should ignore hidden directories", () => {
-            createSkillFile(testDir, ".hidden-skill", `---
-name: hidden
-description: Hidden skill
+        expect(result).toHaveLength(1);
+        expect(result[0].scope).toBe("claude-project");
+    });
+    it("should let project skills override plugin skills with same name", () => {
+        const pluginSkills = [
+            { name: "shared", description: "Plugin version", path: "/p", body: "" },
+        ];
+        const opencodeDir = join(testDir, ".opencode", "skills");
+        mkdirSync(opencodeDir, { recursive: true });
+        createSkillFile(opencodeDir, "shared", `---
+name: shared
+description: Project version
 ---
-
-Content`);
-            const result = discoverSkillsFromDir(testDir, "plugin");
-            expect(result).toHaveLength(0);
+Body`);
+        const result = discoverAllSkills({
+            pluginSkills,
+            pluginDir: "/plugin",
+            cwd: testDir,
         });
-        it("should discover multiple skills", () => {
-            createSkillFile(testDir, "skill-a", `---
-name: skill-a
-description: First skill
+        expect(result).toHaveLength(1);
+        expect(result[0].description).toBe("Project version");
+        expect(result[0].scope).toBe("opencode-project");
+    });
+    it("should ignore directories without SKILL.md", () => {
+        const opencodeDir = join(testDir, ".opencode", "skills");
+        const incompleteDir = join(opencodeDir, "no-skill");
+        mkdirSync(incompleteDir, { recursive: true });
+        writeFileSync(join(incompleteDir, "README.md"), "not a skill");
+        const result = discoverAllSkills({
+            pluginSkills: [],
+            pluginDir: "/plugin",
+            cwd: testDir,
+        });
+        expect(result).toHaveLength(0);
+    });
+    it("should ignore skills missing name or description", () => {
+        const opencodeDir = join(testDir, ".opencode", "skills");
+        mkdirSync(opencodeDir, { recursive: true });
+        createSkillFile(opencodeDir, "no-name", `---
+description: no name
 ---
-Content A`);
-            createSkillFile(testDir, "skill-b", `---
-name: skill-b
-description: Second skill
+Body`);
+        createSkillFile(opencodeDir, "no-desc", `---
+name: no-desc
 ---
-Content B`);
-            const result = discoverSkillsFromDir(testDir, "opencode-project");
-            expect(result).toHaveLength(2);
-            expect(result.map(s => s.name).sort()).toEqual(["skill-a", "skill-b"]);
+Body`);
+        const result = discoverAllSkills({
+            pluginSkills: [],
+            pluginDir: "/plugin",
+            cwd: testDir,
         });
+        expect(result).toHaveLength(0);
     });
-    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");
+    it("should ignore hidden directories", () => {
+        const opencodeDir = join(testDir, ".opencode", "skills");
+        mkdirSync(opencodeDir, { recursive: true });
+        createSkillFile(opencodeDir, ".hidden", `---
+name: hidden
+description: hidden skill
+---
+Body`);
+        const result = discoverAllSkills({
+            pluginSkills: [],
+            pluginDir: "/plugin",
+            cwd: testDir,
         });
+        expect(result).toHaveLength(0);
     });
-    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>");
+    it("should let opencode-project override claude-project with same name", () => {
+        const claudeDir = join(testDir, ".claude", "skills");
+        mkdirSync(claudeDir, { recursive: true });
+        createSkillFile(claudeDir, "shared", `---
+name: shared
+description: Claude version
+---
+Body`);
+        const opencodeDir = join(testDir, ".opencode", "skills");
+        mkdirSync(opencodeDir, { recursive: true });
+        createSkillFile(opencodeDir, "shared", `---
+name: shared
+description: Opencode version
+---
+Body`);
+        const result = discoverAllSkills({
+            pluginSkills: [],
+            pluginDir: "/plugin",
+            cwd: testDir,
         });
+        expect(result).toHaveLength(1);
+        expect(result[0].description).toBe("Opencode version");
+        expect(result[0].scope).toBe("opencode-project");
     });
-    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");
+    it("should aggregate multiple sources", () => {
+        const pluginSkills = [
+            { name: "plugin-only", description: "P", path: "/p", body: "" },
+        ];
+        const opencodeDir = join(testDir, ".opencode", "skills");
+        mkdirSync(opencodeDir, { recursive: true });
+        createSkillFile(opencodeDir, "opencode-only", `---
+name: opencode-only
+description: O
+---
+Body`);
+        const claudeDir = join(testDir, ".claude", "skills");
+        mkdirSync(claudeDir, { recursive: true });
+        createSkillFile(claudeDir, "claude-only", `---
+name: claude-only
+description: C
+---
+Body`);
+        const result = discoverAllSkills({
+            pluginSkills,
+            pluginDir: "/plugin",
+            cwd: testDir,
         });
+        expect(result).toHaveLength(3);
+        const byName = new Map(result.map((s) => [s.name, s]));
+        expect(byName.get("plugin-only")?.scope).toBe("plugin");
+        expect(byName.get("opencode-only")?.scope).toBe("opencode-project");
+        expect(byName.get("claude-only")?.scope).toBe("claude-project");
     });
 });

package/package.json

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