opencode-froggy 0.11.0 → 1.0.0

package/README.md

@@ -56,16 +56,18 @@ Add the plugin to your OpenCode configuration file (`opencode.json`):
 ```json
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugin": ["opencode-froggy"]
+  "plugins": ["opencode-froggy"]
 }
 ```
 
+Requires OpenCode V2.
+
 ### From local files
 
 Alternatively, clone or copy the plugin files to one of these directories:
 
-- **Project-local**: `.opencode/plugin/opencode-froggy/`
-- **Global**: `~/.config/opencode/plugin/opencode-froggy/`
+- **Project-local**: `.opencode/plugins/opencode-froggy/`
+- **Global**: `~/.config/opencode/plugins/opencode-froggy/`
 
 ---
 
@@ -78,6 +80,7 @@ Alternatively, clone or copy the plugin files to one of these directories:
 | `/commit-push` | Stage, commit, and push changes with user confirmation | `build` |
 | `/diff-summary [source] [target]` | Show working tree changes or diff between branches | - |
 | `/doc-changes` | Update documentation based on uncommitted changes (new features only) | `doc-writer` |
+| `/linear-stale-check` | Review open Linear issues for the configured team and report whether they are likely active, uncertain, or obsolete | `plan` |
 | `/review-changes` | Review uncommitted changes (staged, unstaged, untracked) | `code-reviewer` |
 | `/review-pr <source> <target>` | Review diff from source branch into target branch | `code-reviewer` |
 | `/send-to [agent] <message>` | Send a message to a child session (subagent) to continue the conversation | - |
@@ -104,6 +107,24 @@ Shows staged changes, unstaged changes, and untracked file contents.
 ```
 Shows stats overview, commits, files changed, and full diff between branches.
 
+### /linear-stale-check
+
+Analyzes open Linear issues for the team configured in `AGENTS.md` with:
+
+```text
+Linear team: <name>
+```
+
+If no team is configured, the command lists available Linear teams and asks which one to use for the current run.
+
+The command is read-only. It fetches open issues, investigates related code, skips code investigation for issues already `In Progress`, and outputs a single report grouped by verdict:
+
+- 🔴 Likely obsolete
+- 🟡 Uncertain
+- 🟢 Likely active
+
+It does not modify Linear issues, add comments, or update project files.
+
 ---
 
 ## Agents
@@ -121,7 +142,7 @@ Shows stats overview, commits, files changed, and full diff between branches.
 
 ## Skills
 
-Skills are contextual instructions loaded on demand via the `skill` tool. The agent invokes `skill({ name: "skill-name" })` to load the instructions when needed.
+Skills are contextual instructions loaded on demand via the `skill` tool. The agent invokes `skill({ id: "skill-name" })` to load the instructions when needed.
 
 ### Overview
 
@@ -251,7 +272,7 @@ A skill without `name` or `description` will be ignored.
 If a skill defines `use_when`, a directive is injected into the system prompt:
 
 ```
-MANDATORY: Call skill({ name: "my-skill" }) <use_when content>
+MANDATORY: Call skill({ id: "my-skill" }) <use_when content>
 ```
 
 This instructs the agent to load the skill when the specified condition is met.
@@ -342,8 +363,8 @@ promptSession({
 
 #### Behavior
 
-- If `sessionId` is not provided, the tool automatically targets the most recently created child session
-- Returns the text response from the child session
+- If `sessionId` is not provided, the tool targets the most recently created child session tracked since the plugin loaded (pass `sessionId` explicitly for older sessions)
+- Returns a confirmation once the message is admitted to the child session
 - Returns an error message if no child session exists for the current session
 
 ---
@@ -449,8 +470,7 @@ Promote an agent to primary (default) or specify a grade.
 #### Notes
 
 - Only agents from this plugin can be promoted (see [Agents](#agents) table)
-- Changes persist in memory until OpenCode restarts
-- After promotion, use `Tab` or `<leader>a` to select the agent
+- Changes apply immediately and persist across restarts via plugin storage
 
 ---
 

package/command/diff-summary.md

@@ -4,30 +4,49 @@ description: Show working tree changes or diff between branches ($1=source, $2=t
 
 # Diff Summary
 
+Branch arguments (if provided): source=$1 target=$2
+
 !`bash -c '
 SOURCE="$1"
 TARGET="$2"
 TARGET="${TARGET:-HEAD}"
 
+valid_ref() {
+  case "$REF" in
+    ""|-*) return 1 ;;
+  esac
+  git rev-parse --verify --quiet "$REF^{commit}" >/dev/null
+}
+
 if [ -n "$SOURCE" ]; then
+  REF="$SOURCE"
+  if ! valid_ref; then
+    echo "Invalid source ref: $SOURCE"
+    exit 0
+  fi
+  REF="$TARGET"
+  if ! valid_ref; then
+    echo "Invalid target ref: $TARGET"
+    exit 0
+  fi
   echo "## Branch Comparison: $SOURCE → $TARGET"
   echo ""
   git fetch --all --prune 2>/dev/null || true
-  
+
   echo "### Stats Overview"
-  git diff --stat "$TARGET"..."$SOURCE"
-  
+  git diff --stat "$TARGET"..."$SOURCE" --
+
   echo ""
   echo "### Commits"
-  git log --oneline --no-merges "$TARGET".."$SOURCE"
-  
+  git log --oneline --no-merges "$TARGET".."$SOURCE" --
+
   echo ""
   echo "### Files Changed"
-  git diff --name-only "$TARGET"..."$SOURCE"
-  
+  git diff --name-only "$TARGET"..."$SOURCE" --
+
   echo ""
   echo "### Full Diff"
-  git diff "$TARGET"..."$SOURCE"
+  git diff "$TARGET"..."$SOURCE" --
 else
   echo "## Status"
   git status --porcelain

package/command/doc-changes.md

@@ -1,6 +1,7 @@
 ---
 description: Update documentation based on uncommitted changes (new features only)
 agent: doc-writer
+subagent: true
 ---
 
 ## Analysis Phase

package/command/linear-stale-check.md

@@ -0,0 +1,199 @@
+---
+description: Review open Linear issues to check if they are still relevant
+agent: plan
+---
+
+## Your task
+
+Analyze the team's open Linear issues, diagnose each one by combining Linear
+metadata with codebase investigation, and present a single report.
+
+This command is read-only:
+- Do not ask the user questions except when `AGENTS.md` does not define a
+  Linear team.
+- Do not modify any Linear issue.
+- Do not add comments to Linear issues.
+- Do not modify `AGENTS.md` or any other project file.
+- Do not start an iterative review loop.
+
+The user will read the report and decide what to do next.
+
+## 1. Resolve the Linear team
+
+Read `AGENTS.md` from the current project and look for a plain-text line:
+
+```text
+Linear team: <name>
+```
+
+If the line exists, use `<name>` as the Linear team.
+
+If the line does not exist:
+- Use `linear_list_teams` to list available teams.
+- Ask the user to choose one of the available teams with the `question` tool.
+- Use the selected team for this run.
+- Continue the stale-check report normally.
+- Do not write to `AGENTS.md` yourself.
+
+## 2. Fetch open issues
+
+Use `linear_list_issues` for the resolved team:
+- `team`: resolved Linear team name
+- omit `state` entirely; do not pass `uncompleted`, `backlog`, `unstarted`,
+  `started`, an empty string, or any other status-type alias
+- omit `priority` entirely; do not pass `priority: 0` because that filters to
+  issues with no priority
+- `orderBy`: `updatedAt`, oldest first
+- fetch all matching issues by paginating until there are no more pages
+
+Only pass filters that are intentionally active. For unused filters, omit the
+field entirely instead of passing an empty, zero, or placeholder value. In
+particular, `priority: 0` is an active Linear filter for "No priority" and
+will exclude Medium, High, and Urgent issues.
+
+After fetching all team issues, filter locally:
+- keep issues whose `statusType` is not `completed`
+- keep issues whose `statusType` is not `canceled`
+
+Do not rely on Linear state-type aliases for this command. They can return
+incomplete results. Fetch broadly for the team, then filter locally by
+`statusType`.
+
+For each retained issue, load detailed data with `linear_get_issue` and include relations:
+- title
+- description
+- URL
+- state
+- priority
+- assignee
+- labels
+- project
+- createdAt
+- updatedAt
+- blocking and blocked-by relations
+
+## 3. Diagnose each issue
+
+Diagnose every fetched issue before producing the final report.
+
+### Linear signals
+
+Compute these signals for every issue:
+- Days since last update.
+- No assignee.
+- No project.
+- No useful description.
+- `In Progress` but inactive for more than 30 days.
+- Blockers are already closed or canceled.
+
+### Code investigation
+
+Run code investigation for every issue except issues whose state is exactly
+`In Progress`.
+
+For `In Progress` issues, set code signals to:
+
+```text
+skipped (in progress)
+```
+
+For all other issues, investigate the codebase directly with read-only search
+tools and git history commands. Run searches in parallel batches when possible.
+
+For each issue, use:
+- the Linear identifier
+- the title
+- a concise description excerpt
+- candidate keywords from the title and description
+
+Candidate keywords should include:
+- mentioned files or modules
+- function, class, type, command, hook, or config names
+- the Linear identifier itself
+- meaningful product or domain terms
+
+Search for relevance signals and keep the result to 3-5 concise lines:
+- Does the mentioned code or feature still exist?
+- Is the Linear identifier referenced in code, comments, TODOs, branches, or recent commits?
+- Is there recent git activity on related files or symbols?
+- Are there signs the feature was removed, renamed, or replaced?
+
+Summarize the returned investigation as code signals:
+- code or feature found
+- code or feature not found
+- identifier referenced
+- recent git activity found
+- no recent git activity found
+- no code correlation found
+
+## 4. Assign a verdict
+
+Assign exactly one verdict per issue:
+
+- 🔴 Likely obsolete
+- 🟡 Uncertain
+- 🟢 Likely active
+
+Use these rules as guidance, but apply judgment based on the full evidence.
+
+For `In Progress` issues, base the verdict on update age only:
+- updated less than 30 days ago: 🟢 Likely active
+- updated 30-90 days ago: 🟡 Uncertain
+- updated more than 90 days ago: 🔴 Likely obsolete
+
+For other issues:
+- Use 🟢 Likely active when the issue is referenced in code, has recent related git activity, or clearly describes current code.
+- Use 🟡 Uncertain when signals are mixed or weak.
+- Use 🔴 Likely obsolete when mentioned code is missing, the feature appears removed or replaced, or the issue has weak Linear signals and no code correlation.
+
+## 5. Output a single report
+
+Output one report only. Sort by verdict in this order:
+1. 🔴 Likely obsolete
+2. 🟡 Uncertain
+3. 🟢 Likely active
+
+Use this structure:
+
+```markdown
+# Linear Stale-Check Report
+
+Team: <team>
+Issues analyzed: <count>
+
+## 🔴 Likely Obsolete (<count>)
+
+### LIN-123 — Issue title
+
+URL: <Linear URL>
+State: <state> | Priority: <priority> | Assignee: <assignee or none> | Updated: <N>d ago
+Project: <project or none> | Labels: <labels or none>
+
+Summary: <1-2 line summary of the issue>
+
+Linear signals:
+- <signal>
+- <signal>
+
+Code signals:
+- <signal>
+- <signal>
+
+Verdict: 🔴 Likely obsolete — <short reason>
+
+## 🟡 Uncertain (<count>)
+
+...
+
+## 🟢 Likely Active (<count>)
+
+...
+```
+
+Keep each issue concise. Prefer useful evidence over speculation.
+
+End the report with:
+
+```text
+End of report. No issues were modified.
+```

package/command/review-changes.md

@@ -1,6 +1,7 @@
 ---
 description: Review uncommitted changes (staged + unstaged, incl. untracked diffs)
 agent: code-reviewer
+subagent: true
 ---
 
 # Review: Working Tree → HEAD

package/command/review-pr.md

@@ -1,6 +1,7 @@
 ---
 description: Review changes from source branch into target branch
 agent: code-reviewer
+subagent: true
 ---
 
 # Review: $1 → $2

package/command/simplify-changes.md

@@ -1,6 +1,7 @@
 ---
 description: Simplify uncommitted changes (staged + unstaged, incl. untracked diffs)
 agent: code-simplifier
+subagent: true
 ---
 
 # Simplify: Working Tree → HEAD

package/dist/command-installer.d.ts

@@ -0,0 +1,6 @@
+export interface InstallFilesResult {
+    installed: string[];
+    skipped: string[];
+    updated: string[];
+}
+export declare function installBundledFiles(sourceDir: string, targetDir: string): InstallFilesResult;

package/dist/command-installer.js

@@ -0,0 +1,49 @@
+import { constants, copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, } from "node:fs";
+import { join } from "node:path";
+import { log } from "./logger";
+export function installBundledFiles(sourceDir, targetDir) {
+    const installed = [];
+    const skipped = [];
+    const updated = [];
+    if (!existsSync(sourceDir))
+        return { installed, skipped, updated };
+    try {
+        mkdirSync(targetDir, { recursive: true });
+    }
+    catch (error) {
+        log("[commands] failed to prepare target dir", { targetDir, error: String(error) });
+        return { installed, skipped, updated };
+    }
+    let files;
+    try {
+        files = readdirSync(sourceDir);
+    }
+    catch (error) {
+        log("[commands] failed to read bundled files", { sourceDir, error: String(error) });
+        return { installed, skipped, updated };
+    }
+    for (const file of files) {
+        if (!file.endsWith(".md"))
+            continue;
+        const source = join(sourceDir, file);
+        const target = join(targetDir, file);
+        try {
+            const content = readFileSync(source, "utf-8");
+            if (!existsSync(target)) {
+                copyFileSync(source, target, constants.COPYFILE_EXCL);
+                installed.push(file);
+                continue;
+            }
+            if (readFileSync(target, "utf-8") !== content) {
+                copyFileSync(source, target);
+                updated.push(file);
+                continue;
+            }
+            skipped.push(file);
+        }
+        catch (error) {
+            log("[commands] failed to install bundled file", { file, error: String(error) });
+        }
+    }
+    return { installed, skipped, updated };
+}

package/dist/command-installer.test.d.ts

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

package/dist/command-installer.test.js

@@ -0,0 +1,58 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { installBundledFiles } from "./command-installer";
+describe("installBundledFiles", () => {
+    let sourceDir;
+    let targetDir;
+    beforeEach(() => {
+        const base = join(tmpdir(), `froggy-files-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+        sourceDir = join(base, "source");
+        targetDir = join(base, "target");
+        mkdirSync(sourceDir, { recursive: true });
+    });
+    afterEach(() => {
+        rmSync(join(sourceDir, ".."), { recursive: true, force: true });
+    });
+    it("installs missing files", () => {
+        writeFileSync(join(sourceDir, "review-pr.md"), "# review");
+        const result = installBundledFiles(sourceDir, targetDir);
+        expect(result.installed).toEqual(["review-pr.md"]);
+        expect(readFileSync(join(targetDir, "review-pr.md"), "utf-8")).toBe("# review");
+    });
+    it("skips existing files with identical content", () => {
+        writeFileSync(join(sourceDir, "review-pr.md"), "# bundled");
+        mkdirSync(targetDir, { recursive: true });
+        writeFileSync(join(targetDir, "review-pr.md"), "# bundled");
+        const result = installBundledFiles(sourceDir, targetDir);
+        expect(result.skipped).toEqual(["review-pr.md"]);
+        expect(readFileSync(join(targetDir, "review-pr.md"), "utf-8")).toBe("# bundled");
+    });
+    it("updates an existing file when the bundled content differs", () => {
+        writeFileSync(join(sourceDir, "review-pr.md"), "# v2");
+        mkdirSync(targetDir, { recursive: true });
+        writeFileSync(join(targetDir, "review-pr.md"), "# v1");
+        const result = installBundledFiles(sourceDir, targetDir);
+        expect(result.updated).toEqual(["review-pr.md"]);
+        expect(readFileSync(join(targetDir, "review-pr.md"), "utf-8")).toBe("# v2");
+    });
+    it("never deletes a user-customized file", () => {
+        writeFileSync(join(sourceDir, "review-pr.md"), "# bundled");
+        mkdirSync(targetDir, { recursive: true });
+        writeFileSync(join(targetDir, "review-pr.md"), "# user customization");
+        const result = installBundledFiles(sourceDir, targetDir);
+        expect(result.updated).toEqual(["review-pr.md"]);
+        expect(existsSync(join(targetDir, "review-pr.md"))).toBe(true);
+    });
+    it("ignores non-markdown files", () => {
+        writeFileSync(join(sourceDir, "notes.txt"), "notes");
+        const result = installBundledFiles(sourceDir, targetDir);
+        expect(result.installed).toEqual([]);
+        expect(existsSync(join(targetDir, "notes.txt"))).toBe(false);
+    });
+    it("returns empty result for missing source dir", () => {
+        const result = installBundledFiles(join(sourceDir, "missing"), targetDir);
+        expect(result).toEqual({ installed: [], skipped: [], updated: [] });
+    });
+});

package/dist/config-paths.d.ts

@@ -9,3 +9,5 @@
 export declare function getUserConfigDir(): string;
 export declare function getGlobalHookDir(): string;
 export declare function getProjectHookDir(directory: string): string;
+export declare function getGlobalCommandDir(): string;
+export declare function getGlobalAgentDir(): string;

package/dist/config-paths.js

@@ -30,3 +30,9 @@ export function getGlobalHookDir() {
 export function getProjectHookDir(directory) {
     return join(directory, ".opencode", "hook");
 }
+export function getGlobalCommandDir() {
+    return join(getUserConfigDir(), "opencode", "commands");
+}
+export function getGlobalAgentDir() {
+    return join(getUserConfigDir(), "opencode", "agents");
+}

package/dist/config-paths.test.js

@@ -86,6 +86,22 @@ describe("config-paths", () => {
             expect(getGlobalHookDir()).toBe("/custom/config/opencode/hook");
         });
     });
+    describe("getGlobalCommandDir", () => {
+        it("should return correct path on Linux", async () => {
+            Object.defineProperty(process, "platform", { value: "linux" });
+            delete process.env.XDG_CONFIG_HOME;
+            const { getGlobalCommandDir } = await import("./config-paths");
+            expect(getGlobalCommandDir()).toBe(join(homedir(), ".config", "opencode", "commands"));
+        });
+    });
+    describe("getGlobalAgentDir", () => {
+        it("should return correct path on Linux", async () => {
+            Object.defineProperty(process, "platform", { value: "linux" });
+            delete process.env.XDG_CONFIG_HOME;
+            const { getGlobalAgentDir } = await import("./config-paths");
+            expect(getGlobalAgentDir()).toBe(join(homedir(), ".config", "opencode", "agents"));
+        });
+    });
     describe("getProjectHookDir", () => {
         it("should return correct path for project directory", async () => {
             const { getProjectHookDir } = await import("./config-paths");

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { type Plugin } from "@opencode-ai/plugin";
+import { Plugin } from "@opencode/plugin";
 export { parseFrontmatter, loadAgents, loadCommands, type LoadedSkill } from "./loaders";
 export { buildSkillActivationBlock } from "./skill-activation";
-declare const SmartfrogPlugin: Plugin;
-export default SmartfrogPlugin;
+declare const _default: Plugin.Plugin;
+export default _default;