opencode-plugin-coding 0.1.2

package/.opencode/plugins/opencode-plugin-coding.js

@@ -0,0 +1,211 @@
+/**
+ * opencode-plugin-coding — OpenCode plugin for multi-agent coding workflows.
+ *
+ * Registers skills, commands, and agents dynamically via the config hook.
+ * Agents are registered from workflow.json + guide files — no .opencode/agents/*.md needed.
+ * Install: add to "plugin" array in opencode.json (global or project).
+ */
+
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pluginRoot = path.resolve(__dirname, "../..");
+
+// Simple frontmatter extraction (no external dependencies)
+const extractFrontmatter = (content) => {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) return { meta: {}, body: content };
+
+  const meta = {};
+  for (const line of match[1].split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx > 0) {
+      const key = line.slice(0, idx).trim();
+      const value = line
+        .slice(idx + 1)
+        .trim()
+        .replace(/^["']|["']$/g, "");
+      meta[key] = value;
+    }
+  }
+  return { meta, body: match[2] };
+};
+
+// Load all command .md files from commands/ and register them via config
+const loadCommands = () => {
+  const commandsDir = path.join(pluginRoot, "commands");
+  if (!fs.existsSync(commandsDir)) return {};
+
+  const commands = {};
+  for (const file of fs.readdirSync(commandsDir)) {
+    if (!file.endsWith(".md")) continue;
+    const name = file.replace(/\.md$/, "");
+    const content = fs.readFileSync(path.join(commandsDir, file), "utf8");
+    const { meta, body } = extractFrontmatter(content);
+
+    commands[name] = {
+      description: meta.description || `Run /${name}`,
+      template: body.trim(),
+    };
+    if (meta.agent) commands[name].agent = meta.agent;
+    if (meta.model) commands[name].model = meta.model;
+  }
+  return commands;
+};
+
+// Read a guide file and return its content as a prompt string
+const readGuide = (filename) => {
+  const guidePath = path.join(pluginRoot, "guides", filename);
+  if (!fs.existsSync(guidePath)) return "";
+  return fs.readFileSync(guidePath, "utf8").trim();
+};
+
+// Read workflow.json from the project directory
+const readWorkflowJson = (directory) => {
+  const workflowPath = path.join(directory, ".opencode", "workflow.json");
+  if (!fs.existsSync(workflowPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(workflowPath, "utf8"));
+  } catch {
+    return null;
+  }
+};
+
+// Agent role definitions: guide file, description, and permissions
+const AGENT_ROLES = {
+  coreCoder: {
+    guide: "core-coder-guide.md",
+    description:
+      "Core implementation agent — executes plans, writes code, runs verification, creates PRs.",
+    permission: {
+      edit: "allow",
+      bash: { "*": "allow" },
+      read: "allow",
+      webfetch: "allow",
+    },
+  },
+  coreReviewer: {
+    guide: "core-reviewer-guide.md",
+    description:
+      "Core code reviewer (blocking) — full verification in worktree, reviews all areas.",
+    permission: {
+      edit: "deny",
+      bash: { "*": "allow" },
+      read: "allow",
+      webfetch: "deny",
+    },
+  },
+  reviewer: {
+    guide: "reviewer-guide.md",
+    description:
+      "Code reviewer (non-blocking) — diff-based review on assigned areas.",
+    permission: {
+      edit: "deny",
+      bash: {
+        "*": "deny",
+        "gh api *": "allow",
+        "gh pr diff *": "allow",
+        "gh pr view *": "allow",
+        "gh pr checks *": "allow",
+      },
+      read: "allow",
+      webfetch: "deny",
+    },
+  },
+  securityReviewer: {
+    guide: "security-reviewer-guide.md",
+    description: "Security reviewer — pre-merge security analysis.",
+    permission: {
+      edit: "deny",
+      bash: {
+        "*": "deny",
+        "gh api *": "allow",
+        "gh pr diff *": "allow",
+        "gh pr view *": "allow",
+        "gh pr checks *": "allow",
+      },
+      read: "allow",
+      webfetch: "deny",
+    },
+  },
+};
+
+// Map workflow.json agent fields to their role key
+const FIELD_TO_ROLE = {
+  coreCoder: "coreCoder",
+  coreReviewers: "coreReviewer",
+  reviewers: "reviewer",
+  securityReviewers: "securityReviewer",
+};
+
+// Register agents from workflow.json into cfg.agent
+const registerAgents = (config, directory) => {
+  const workflow = readWorkflowJson(directory);
+  if (!workflow?.agents) return;
+
+  config.agent = config.agent || {};
+
+  for (const [field, roleKey] of Object.entries(FIELD_TO_ROLE)) {
+    const role = AGENT_ROLES[roleKey];
+    const prompt = readGuide(role.guide);
+    const entries = workflow.agents[field];
+    if (!entries) continue;
+
+    // Normalize: coreCoder is a single object, others are arrays
+    const agentList = Array.isArray(entries) ? entries : [entries];
+
+    for (const agent of agentList) {
+      // Support both { name, model } objects and bare strings (backward compat)
+      const name = typeof agent === "string" ? agent : agent.name;
+      const model = typeof agent === "string" ? undefined : agent.model;
+
+      if (!name) continue;
+
+      // Don't override user-defined agents
+      if (config.agent[name]) continue;
+
+      const agentConfig = {
+        description: role.description,
+        mode: "subagent",
+        prompt,
+        permission: role.permission,
+      };
+
+      // Only set model if explicitly provided (non-empty)
+      if (model) {
+        agentConfig.model = model;
+      }
+
+      config.agent[name] = agentConfig;
+    }
+  }
+};
+
+export const ZooplanktonCodingPlugin = async ({ directory }) => {
+  const skillsDir = path.join(pluginRoot, "skills");
+
+  return {
+    config: async (config) => {
+      // Skills — add our skills/ directory to discovery paths
+      config.skills = config.skills || {};
+      config.skills.paths = config.skills.paths || [];
+      if (!config.skills.paths.includes(skillsDir)) {
+        config.skills.paths.push(skillsDir);
+      }
+
+      // Commands — register from commands/*.md
+      config.command = config.command || {};
+      const pluginCommands = loadCommands();
+      for (const [name, cmd] of Object.entries(pluginCommands)) {
+        if (!config.command[name]) {
+          config.command[name] = cmd;
+        }
+      }
+
+      // Agents — register from workflow.json + guide files
+      registerAgents(config, directory);
+    },
+  };
+};

package/README.md

@@ -0,0 +1,132 @@
+# opencode-plugin-coding
+
+A shared [OpenCode](https://opencode.ai) plugin for multi-agent software development workflows. Provides skills, guides, and dynamically registered agents that standardize the full cycle: brainstorm, plan, implement, review, debug, and retrospect.
+
+## Skills
+
+| Skill | Description |
+|-------|-------------|
+| `brainstorm` | Socratic design interview that refines rough ideas into a validated design document |
+| `plan` | Decomposes a design into bite-sized implementation tasks with file paths and acceptance criteria |
+| `orchestrate` | Full multi-agent workflow: implement → review → merge → retrospective |
+| `test-driven-development` | RED-GREEN-REFACTOR cycle enforcement |
+| `systematic-debugging` | 4-phase debugging: reproduce → hypothesize → isolate → fix |
+| `git-worktree` | Create and manage isolated git worktrees for parallel development |
+| `playwright` | Browser automation via Playwright MCP server |
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/zooplankton-coding-init` | Auto-detect project, generate `workflow.json` |
+| `/zooplankton-coding-update` | Check workflow.json schema updates, show plugin changes |
+
+## Guides
+
+Guide files define the prompt and behavior for each agent role. The plugin loads them automatically — they are not installed in consumer projects.
+
+- `guides/core-coder-guide.md` — Instructions for the core implementation agent
+- `guides/core-reviewer-guide.md` — Instructions for core reviewers (worktree + full verification)
+- `guides/reviewer-guide.md` — Instructions for normal reviewers (diff-based review)
+- `guides/security-reviewer-guide.md` — Instructions for the security reviewer (pre-merge)
+
+## Setup
+
+### 1. Install the plugin
+
+Add the plugin to your project's `opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    "opencode-plugin-coding"
+  ]
+}
+```
+
+OpenCode will auto-install the plugin from npm via Bun at startup. The plugin registers all skills, commands, and agents automatically — no symlinks, manual copies, or `.opencode/agents/*.md` files needed.
+
+### Pin a specific version (optional)
+
+```json
+"plugin": ["opencode-plugin-coding@0.1.0"]
+```
+
+### Global installation (optional)
+
+To make the plugin available across all projects without adding it to each project's `opencode.json`, add the same `plugin` entry to `~/.config/opencode/opencode.json`.
+
+### 2. Run /zooplankton-coding-init
+
+From your project root in OpenCode, run:
+
+```
+/zooplankton-coding-init
+```
+
+This will:
+- Auto-detect project settings (language, framework, package manager, commands)
+- Generate `.opencode/workflow.json` with project-specific configuration and agent definitions
+- Update `.gitignore` for ephemeral plugin files
+
+### 3. Configure agents
+
+Review the `agents` section in `.opencode/workflow.json`. Each agent is a `{ name, model }` object. The plugin reads these at startup and dynamically registers agents with the appropriate permissions and prompts from the guide files. To change models or add/remove agents, just edit `workflow.json` and restart OpenCode.
+
+> **How it works:** The plugin uses OpenCode's `config` hook to register agents via `config.agent`, skills via `config.skills.paths`, and commands via `config.command`.
+
+## Project-Level Files
+
+After `/zooplankton-coding-init`, your project will have:
+
+| File | Committed? | Purpose |
+|------|-----------|---------|
+| `.opencode/workflow.json` | Yes | Project configuration + agent definitions |
+| `.opencode/reviewer-knowledge.json` | No (gitignored) | Adaptive reviewer scoring cache |
+| `.opencode/plans/<branch>.md` | No (gitignored) | Ephemeral plan files |
+| `.opencode/retrospectives/<branch>.md` | No (gitignored) | Ephemeral retrospective files |
+
+## Configuration
+
+`workflow.json` schema:
+
+```json
+{
+  "project": {
+    "name": "my-project",
+    "repo": "Org/my-project",
+    "defaultBranch": "master"
+  },
+  "stack": {
+    "language": "typescript",
+    "framework": "react",
+    "packageManager": "yarn"
+  },
+  "commands": {
+    "build": "yarn build",
+    "lint": "yarn lint",
+    "test": "yarn test",
+    "typecheck": "npx tsc --noEmit"
+  },
+  "agents": {
+    "coreCoder": { "name": "core-coder", "model": "github-copilot/claude-opus-4.6" },
+    "coreReviewers": [
+      { "name": "core-reviewer-1", "model": "github-copilot/claude-sonnet-4.6" },
+      { "name": "core-reviewer-2", "model": "github-copilot/gpt-5.4" }
+    ],
+    "reviewers": [
+      { "name": "reviewer-1", "model": "alibaba-coding-plan-cn/glm-5" },
+      { "name": "reviewer-2", "model": "alibaba-coding-plan-cn/MiniMax-M2.5" }
+    ],
+    "securityReviewers": []
+  },
+  "testDrivenDevelopment": { "enabled": false },
+  "docsToRead": ["AGENTS.md"],
+  "reviewFocus": ["type safety", "error handling"]
+}
+```
+
+## License
+
+MIT

package/commands/zooplankton-coding-init.md

@@ -0,0 +1,164 @@
+---
+description: Auto-detect project settings and generate workflow.json for the coding plugin.
+---
+
+# /zooplankton-coding-init — Project Setup
+
+When the user runs `/zooplankton-coding-init`, perform the following steps to bootstrap the opencode-plugin-coding configuration for this project.
+
+## Step 1: Auto-Detect Project Settings
+
+Read the project root and detect:
+
+### Project identity
+
+```bash
+# Get repo name from git remote
+REPO=$(git remote get-url origin 2>/dev/null | sed 's/.*[:/]\([^/]*\/[^/]*\)\.git$/\1/' | sed 's/.*[:/]\([^/]*\/[^/]*\)$/\1/')
+PROJECT_NAME=$(basename "$(pwd)")
+DEFAULT_BRANCH=$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@' || echo "master")
+```
+
+### Stack detection
+
+1. Read `package.json` if it exists:
+   - `language`: "typescript" if `tsconfig.json` exists, else "javascript"
+   - `framework`: detect from dependencies — "react-native", "react", "vue", "next", "nuxt", "express", "koa", "electron", etc.
+   - `packageManager`: check for `yarn.lock` → "yarn", `pnpm-lock.yaml` → "pnpm", `bun.lockb` → "bun", else "npm"
+
+2. If no `package.json`, check for other project types (Python, Go, Rust, etc.) and set accordingly.
+
+### Command detection
+
+Look at `package.json` scripts and detect:
+
+- `build`: prefer `scripts.build` → `"<pm> build"`, else `""`
+- `lint`: prefer `scripts.lint` → `"<pm> lint"`, else check for eslint/stylelint/prettier individually
+- `test`: prefer `scripts.test` → `"<pm> test"`, else `""`
+- `typecheck`: if TypeScript, prefer `scripts.typecheck` → `"<pm> typecheck"`, else `"npx tsc --noEmit"` if `tsconfig.json` exists
+
+### Docs to read
+
+Detect which docs exist and add them:
+
+```bash
+# Check for common doc files
+ls AGENTS.md doc/CODE_STYLE.md doc/UPGRADE_PLAN.md doc/Game.md doc/MODERNIZATION_PLAN.md 2>/dev/null
+```
+
+Add all found files to the `docsToRead` array.
+
+## Step 2: Generate workflow.json
+
+Create `.opencode/workflow.json` with the detected settings. The `agents` section uses `{ name, model }` objects — the plugin reads these to dynamically register agents with the correct model, permissions, and prompt.
+
+```json
+{
+  "project": {
+    "name": "<detected>",
+    "repo": "<detected>",
+    "defaultBranch": "<detected>"
+  },
+  "stack": {
+    "language": "<detected>",
+    "framework": "<detected>",
+    "packageManager": "<detected>"
+  },
+  "commands": {
+    "build": "<detected>",
+    "lint": "<detected>",
+    "test": "<detected>",
+    "typecheck": "<detected>"
+  },
+  "agents": {
+    "coreCoder": { "name": "core-coder", "model": "github-copilot/claude-opus-4.6" },
+    "coreReviewers": [
+      { "name": "core-reviewer-1", "model": "github-copilot/claude-sonnet-4.6" },
+      { "name": "core-reviewer-2", "model": "github-copilot/gpt-5.4" }
+    ],
+    "reviewers": [
+      { "name": "reviewer-1", "model": "alibaba-coding-plan-cn/glm-5" },
+      { "name": "reviewer-2", "model": "alibaba-coding-plan-cn/MiniMax-M2.5" },
+      { "name": "reviewer-3", "model": "alibaba-coding-plan-cn/qwen3.5-plus" },
+      { "name": "reviewer-4", "model": "alibaba-coding-plan-cn/kimi-k2.5" },
+      { "name": "reviewer-5", "model": "volcengine-plan/ark-code-latest" },
+      { "name": "reviewer-6", "model": "volcengine-plan/deepseek-v3.2" }
+    ],
+    "securityReviewers": []
+  },
+  "testDrivenDevelopment": { "enabled": false },
+  "docsToRead": ["<detected>"],
+  "reviewFocus": []
+}
+```
+
+Create the `.opencode/` directory if it doesn't exist:
+
+```bash
+mkdir -p .opencode
+```
+
+Write the file. If `.opencode/workflow.json` already exists, warn the user and ask before overwriting.
+
+**How agents work:** The plugin JS reads `workflow.json` at startup and dynamically registers each agent via OpenCode's `config.agent` API, using the guide files (`guides/*.md`) as prompts and the role-appropriate permissions. No `.opencode/agents/*.md` files are needed in consumer projects — the plugin handles everything.
+
+## Step 3: Update .gitignore
+
+Append these entries to the project's `.gitignore` idempotently (only add lines that are not already present):
+
+```
+# opencode-plugin-coding ephemeral files
+.opencode/reviewer-knowledge.json
+.opencode/plans/
+.opencode/retrospectives/
+.opencode/designs/
+.worktrees/
+```
+
+Check each line before appending — do not create duplicates.
+
+## Step 4: Create Required Directories
+
+```bash
+mkdir -p .opencode/plans
+mkdir -p .opencode/retrospectives
+```
+
+## Step 5: Print Summary
+
+After setup, print a summary:
+
+```
+## /zooplankton-coding-init Complete
+
+**Project:** <name>
+**Repo:** <repo>
+**Stack:** <language> / <framework> / <packageManager>
+
+**Commands detected:**
+- build: `<command>` (or "not detected")
+- lint: `<command>` (or "not detected")
+- test: `<command>` (or "not detected")
+- typecheck: `<command>` (or "not detected")
+
+**Agents configured (via workflow.json):**
+- Core coder: `core-coder` → `github-copilot/claude-opus-4.6`
+- Core reviewers: `core-reviewer-1`, `core-reviewer-2`
+- Normal reviewers: `reviewer-1` ... `reviewer-6`
+- Security reviewers: (none — add to workflow.json to enable)
+
+**Files created/updated:**
+- `.opencode/workflow.json` — project configuration
+- `.gitignore` — updated with plugin ignore patterns
+
+**Manual review checklist:**
+- [ ] Verify detected commands are correct in `.opencode/workflow.json`
+- [ ] Review model assignments in `workflow.json` → `agents` section
+- [ ] Add or remove agents and adjust model IDs as needed
+- [ ] Add entries to `agents.securityReviewers` if security review is needed
+- [ ] Enable `testDrivenDevelopment` if using test-driven development
+- [ ] Set `reviewFocus` entries if this project has specific review emphases
+- [ ] Review `docsToRead` list and add any project-specific docs
+
+> **Note:** Agents are registered dynamically by the plugin from workflow.json — no agent `.md` files needed. To change models or add/remove agents, just edit `workflow.json` and restart OpenCode.
+```

package/commands/zooplankton-coding-update.md

@@ -0,0 +1,93 @@
+---
+description: Check workflow.json for schema updates and show what's new in the plugin.
+---
+
+# /zooplankton-coding-update — Sync Configuration
+
+When the user runs `/zooplankton-coding-update`, check the project's workflow.json against the current plugin schema and report any needed updates.
+
+## Step 1: Read Current Configuration
+
+Read `.opencode/workflow.json` from the project. If it doesn't exist, tell the user to run `/zooplankton-coding-init` first.
+
+## Step 2: Schema Validation
+
+Compare the project's `workflow.json` against the template at `templates/workflow.json`. Check for:
+
+### Missing fields
+
+If the template has fields that the project file lacks, list them:
+
+```
+New fields available:
+- `<field>`: <description> (default: <value>)
+```
+
+Offer to add them with sensible defaults.
+
+### Deprecated fields
+
+If the project file has fields that are no longer in the template, warn:
+
+```
+Deprecated fields found:
+- `<field>`: <reason>
+```
+
+### Agent format migration
+
+If the project's `agents` section uses the old bare-string format:
+
+```json
+"coreCoder": "core-coder"
+```
+
+Offer to migrate to the new `{ name, model }` format:
+
+```json
+"coreCoder": { "name": "core-coder", "model": "" }
+```
+
+Show the proposed migration and ask for confirmation before writing.
+
+## Step 3: Guide Changes Summary
+
+Read the plugin's guide files (`guides/*.md`) and show a brief changelog if significant changes were made since the last update. This is informational only — guides are loaded dynamically by the plugin, so no action is needed from the user.
+
+```
+Plugin guide updates (applied automatically):
+- core-coder-guide.md: <summary of changes, or "no changes">
+- core-reviewer-guide.md: <summary>
+- reviewer-guide.md: <summary>
+- security-reviewer-guide.md: <summary>
+```
+
+## Step 4: Apply Accepted Changes
+
+For each change the user accepts:
+
+1. Update `.opencode/workflow.json` with the new fields/format
+2. Preserve all existing user values
+
+For each change the user rejects:
+
+1. Skip — leave unchanged
+2. Note that the configuration may be outdated
+
+## Step 5: Print Summary
+
+```
+## /zooplankton-coding-update Complete
+
+**Schema updates applied:** <count>
+**Schema updates skipped:** <count>
+
+**Reminder:** Agents are registered dynamically from workflow.json by the plugin.
+To change models or add/remove agents, edit `.opencode/workflow.json` and restart OpenCode.
+```
+
+## Rules
+
+- **Never overwrite user values** without confirmation — model assignments, agent names, project settings are user customizations
+- **Preserve comments** if the file has any (though JSON doesn't support comments, some users use JSONC)
+- If no updates are needed, say so clearly and exit