opencodekit 0.6.0 → 0.6.1

package/dist/template/.opencode/pickle-thinker.jsonc

@@ -0,0 +1,11 @@
+{
+  // Ultrathink config for pickle-thinker
+  // mode: "lite" keeps the original behavior (prefix user prompts only).
+  // mode: "tool" adds an extra user turn after each tool result to force deeper analysis.
+  // Note: tool mode increases turns/tokens and may impact subscription limits.
+  "enabled": true,
+  // "lite" | "tool"
+  "mode": "tool",
+  // Change the thinking keyword if you like
+  "prefix": "Ultrathink: "
+}

package/dist/template/.opencode/plugin/skill.ts

@@ -0,0 +1,275 @@
+/**
+ * Skills plugin for OpenCode.ai
+ *
+ * Provides custom tools for loading and discovering skills.
+ * Skills are loaded on-demand via use_skill tool, not auto-injected.
+ *
+ * OpenCode Official Skill Locations:
+ * - Project skills: .opencode/skill/
+ * - Personal skills: ~/.opencode/skill/
+ */
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { type Plugin, tool } from "@opencode-ai/plugin";
+
+interface SkillResolution {
+  skillFile: string;
+  sourceType: "project" | "personal";
+  skillPath: string;
+}
+
+interface SkillInfo {
+  path: string;
+  skillFile: string;
+  name: string;
+  description: string;
+  sourceType: "project" | "personal";
+}
+
+interface Frontmatter {
+  name: string;
+  description: string;
+}
+
+// ============================================
+// Skills Core Functions
+// ============================================
+
+function extractFrontmatter(filePath: string): Frontmatter {
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    const lines = content.split("\n");
+
+    let inFrontmatter = false;
+    let name = "";
+    let description = "";
+
+    for (const line of lines) {
+      if (line.trim() === "---") {
+        if (inFrontmatter) break;
+        inFrontmatter = true;
+        continue;
+      }
+
+      if (inFrontmatter) {
+        const match = line.match(/^(\w+):\s*(.*)$/);
+        if (match) {
+          const [, key, value] = match;
+          if (key === "name") name = value.trim();
+          if (key === "description") description = value.trim();
+        }
+      }
+    }
+
+    return { name, description };
+  } catch {
+    return { name: "", description: "" };
+  }
+}
+
+function findSkillsInDir(
+  dir: string,
+  sourceType: "project" | "personal",
+  maxDepth = 3,
+): SkillInfo[] {
+  const skills: SkillInfo[] = [];
+
+  if (!fs.existsSync(dir)) return skills;
+
+  function recurse(currentDir: string, depth: number) {
+    if (depth > maxDepth) return;
+
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+
+      if (entry.isDirectory()) {
+        const skillFile = path.join(fullPath, "SKILL.md");
+        if (fs.existsSync(skillFile)) {
+          const { name, description } = extractFrontmatter(skillFile);
+          skills.push({
+            path: fullPath,
+            skillFile,
+            name: name || entry.name,
+            description: description || "",
+            sourceType,
+          });
+        }
+        recurse(fullPath, depth + 1);
+      }
+    }
+  }
+
+  recurse(dir, 0);
+  return skills;
+}
+
+function stripFrontmatter(content: string): string {
+  const lines = content.split("\n");
+  let inFrontmatter = false;
+  let frontmatterEnded = false;
+  const contentLines: string[] = [];
+
+  for (const line of lines) {
+    if (line.trim() === "---") {
+      if (inFrontmatter) {
+        frontmatterEnded = true;
+        continue;
+      }
+      inFrontmatter = true;
+      continue;
+    }
+
+    if (frontmatterEnded || !inFrontmatter) {
+      contentLines.push(line);
+    }
+  }
+
+  return contentLines.join("\n").trim();
+}
+
+// ============================================
+// Plugin Export
+// ============================================
+
+export const SkillsPlugin: Plugin = async ({ client, directory }) => {
+  const homeDir = os.homedir();
+  const projectSkillsDir = path.join(directory, ".opencode/skill");
+  const personalSkillsDir = path.join(homeDir, ".opencode/skill");
+
+  return {
+    tool: {
+      use_skill: tool({
+        description:
+          "Load and read a specific skill to guide your work. Skills contain proven workflows, mandatory processes, and expert techniques.",
+        args: {
+          skill_name: tool.schema
+            .string()
+            .describe(
+              'Name of skill to load (e.g., "brainstorming", "my-custom-skill", or "project:my-skill")',
+            ),
+        },
+        execute: async (
+          args: { skill_name: string },
+          context: { sessionID: string },
+        ) => {
+          const { skill_name } = args;
+
+          // Resolve with priority: project > personal
+          const forceProject = skill_name.startsWith("project:");
+          const actualSkillName = forceProject
+            ? skill_name.replace(/^project:/, "")
+            : skill_name;
+
+          let resolved: SkillResolution | null = null;
+
+          // Try project skills first
+          if (forceProject) {
+            const projectSkillFile = path.join(
+              projectSkillsDir,
+              actualSkillName,
+              "SKILL.md",
+            );
+            if (fs.existsSync(projectSkillFile)) {
+              resolved = {
+                skillFile: projectSkillFile,
+                sourceType: "project",
+                skillPath: actualSkillName,
+              };
+            }
+          }
+
+          // Fall back to personal resolution
+          if (!resolved && !forceProject) {
+            const personalSkillFile = path.join(
+              personalSkillsDir,
+              skill_name,
+              "SKILL.md",
+            );
+            if (fs.existsSync(personalSkillFile)) {
+              resolved = {
+                skillFile: personalSkillFile,
+                sourceType: "personal",
+                skillPath: skill_name,
+              };
+            }
+          }
+
+          if (!resolved) {
+            return `Error: Skill "${skill_name}" not found.\n\nRun find_skills to see available skills.`;
+          }
+
+          const fullContent = fs.readFileSync(resolved.skillFile, "utf8");
+          const { name, description } = extractFrontmatter(resolved.skillFile);
+          const content = stripFrontmatter(fullContent);
+          const skillDirectory = path.dirname(resolved.skillFile);
+
+          const skillHeader = `# ${name || skill_name}
+# ${description || ""}
+# Supporting tools and docs are in ${skillDirectory}
+# ============================================`;
+
+          // Insert as user message with noReply for persistence across compaction
+          try {
+            await client.session.prompt({
+              path: { id: context.sessionID },
+              body: {
+                noReply: true,
+                parts: [
+                  {
+                    type: "text",
+                    text: `Loading skill: ${name || skill_name}`,
+                  },
+                  { type: "text", text: `${skillHeader}\n\n${content}` },
+                ],
+              },
+            });
+          } catch {
+            // Fallback: return content directly if message insertion fails
+            return `${skillHeader}\n\n${content}`;
+          }
+
+          return `Launching skill: ${name || skill_name}`;
+        },
+      }),
+
+      find_skills: tool({
+        description:
+          "List all available skills in project and personal skill libraries.",
+        args: {},
+        execute: async () => {
+          const projectSkills = findSkillsInDir(projectSkillsDir, "project", 3);
+          const personalSkills = findSkillsInDir(
+            personalSkillsDir,
+            "personal",
+            3,
+          );
+
+          const allSkills = [...projectSkills, ...personalSkills];
+
+          if (allSkills.length === 0) {
+            return `No skills found. Add project skills to .opencode/skill/ or personal skills to ~/.opencode/skill/`;
+          }
+
+          let output = "Available skills:\n\n";
+
+          for (const skill of allSkills) {
+            const namespace = skill.sourceType === "project" ? "project:" : "";
+            const skillName = skill.name || path.basename(skill.path);
+
+            output += `${namespace}${skillName}\n`;
+            if (skill.description) {
+              output += `  ${skill.description}\n`;
+            }
+            output += `  Directory: ${skill.path}\n\n`;
+          }
+
+          return output;
+        },
+      }),
+    },
+  };
+};

package/dist/template/.opencode/{skills → skill}/accessibility-audit/SKILL.md

@@ -1,3 +1,8 @@
+---
+name: accessibility-audit
+description: Use when auditing UI components or pages for accessibility compliance, checking WCAG conformance, identifying keyboard navigation issues, color contrast problems, and pre-launch accessibility verification
+---
+
 # Accessibility Audit Skill
 
 Audit UI accessibility against WCAG 2.1/2.2 guidelines.

package/dist/template/.opencode/{skills → skill}/brainstorming/SKILL.md

@@ -46,8 +46,8 @@ Start by understanding the current project context, then ask questions one at a
 **Implementation (if continuing):**
 
 - Ask: "Ready to set up for implementation?"
-- Use superpowers:using-git-worktrees to create isolated workspace
-- Use superpowers:writing-plans to create detailed implementation plan
+- Use use_skill("using-git-worktrees") to create isolated workspace
+- Use use_skill("writing-plans") to create detailed implementation plan
 
 ## Key Principles
 

package/dist/template/.opencode/{skills → skill}/design-system-audit/SKILL.md

@@ -1,3 +1,8 @@
+---
+name: design-system-audit
+description: Use when auditing existing design systems for consistency, documenting undocumented design tokens, identifying design debt, preparing for design system refactoring, or comparing implementation vs design specs
+---
+
 # Design System Audit Skill
 
 Audit, document, and improve design systems.

package/dist/template/.opencode/{skills → skill}/executing-plans/SKILL.md

@@ -16,28 +16,35 @@ Load plan, review critically, execute tasks in batches, report for review betwee
 ## The Process
 
 ### Step 1: Load and Review Plan
+
 1. Read plan file
 2. Review critically - identify any questions or concerns about the plan
 3. If concerns: Raise them with your human partner before starting
 4. If no concerns: Create TodoWrite and proceed
 
 ### Step 2: Execute Batch
+
 **Default: First 3 tasks**
 
 For each task:
+
 1. Mark as in_progress
 2. Follow each step exactly (plan has bite-sized steps)
 3. Run verifications as specified
 4. Mark as completed
 
 ### Step 3: Report
+
 When batch complete:
+
 - Show what was implemented
 - Show verification output
 - Say: "Ready for feedback."
 
 ### Step 4: Continue
+
 Based on feedback:
+
 - Apply changes if needed
 - Execute next batch
 - Repeat until complete
@@ -45,13 +52,15 @@ Based on feedback:
 ### Step 5: Complete Development
 
 After all tasks complete and verified:
-- Announce: "I'm using the finishing-a-development-branch skill to complete this work."
-- **REQUIRED SUB-SKILL:** Use superpowers:finishing-a-development-branch
+
+- Announce: "I'm using finishing-a-development-branch skill to complete this work."
+- **REQUIRED SUB-SKILL:** Use use_skill("finishing-a-development-branch")
 - Follow that skill to verify tests, present options, execute choice
 
 ## When to Stop and Ask for Help
 
 **STOP executing immediately when:**
+
 - Hit a blocker mid-batch (missing dependency, test fails, instruction unclear)
 - Plan has critical gaps preventing starting
 - You don't understand an instruction
@@ -62,12 +71,14 @@ After all tasks complete and verified:
 ## When to Revisit Earlier Steps
 
 **Return to Review (Step 1) when:**
+
 - Partner updates the plan based on your feedback
 - Fundamental approach needs rethinking
 
 **Don't force through blockers** - stop and ask.
 
 ## Remember
+
 - Review plan critically first
 - Follow plan steps exactly
 - Don't skip verifications

package/dist/template/.opencode/{skills → skill}/frontend-aesthetics/SKILL.md

@@ -1,3 +1,8 @@
+---
+name: frontend-aesthetics
+description: Use when building landing pages, dashboards, forms, or any frontend generation task where you need to prevent generic "AI slop" and create distinctive, intentional designs
+---
+
 # Frontend Aesthetics Skill
 
 Prevent generic "AI slop" frontends. Create distinctive, intentional designs.

package/dist/template/.opencode/{skills → skill}/mockup-to-code/SKILL.md

@@ -1,3 +1,8 @@
+---
+name: mockup-to-code
+description: Use when converting UI mockups, screenshots, Figma/Sketch designs, wireframes, or building component libraries from design systems into production-ready code
+---
+
 # Mockup to Code Skill
 
 Convert UI mockups, screenshots, and designs into production-ready code.

package/dist/template/.opencode/{skills → skill}/requesting-code-review/SKILL.md

@@ -1,22 +1,24 @@
 ---
 name: requesting-code-review
-description: Use when completing tasks, implementing major features, or before merging to verify work meets requirements - dispatches superpowers:code-reviewer subagent to review implementation against plan or requirements before proceeding
+description: Use when completing tasks, implementing major features, or before merging to verify work meets requirements - dispatches review subagent to review implementation against plan or requirements before proceeding
 ---
 
 # Requesting Code Review
 
-Dispatch superpowers:code-reviewer subagent to catch issues before they cascade.
+Dispatch review subagent to catch issues before they cascade.
 
 **Core principle:** Review early, review often.
 
 ## When to Request Review
 
 **Mandatory:**
+
 - After each task in subagent-driven development
 - After completing major feature
 - Before merge to main
 
 **Optional but valuable:**
+
 - When stuck (fresh perspective)
 - Before refactoring (baseline check)
 - After fixing complex bug
@@ -24,16 +26,18 @@ Dispatch superpowers:code-reviewer subagent to catch issues before they cascade.
 ## How to Request
 
 **1. Get git SHAs:**
+
 ```bash
 BASE_SHA=$(git rev-parse HEAD~1)  # or origin/main
 HEAD_SHA=$(git rev-parse HEAD)
 ```
 
-**2. Dispatch code-reviewer subagent:**
+**2. Dispatch review subagent:**
 
-Use Task tool with superpowers:code-reviewer type, fill template at `code-reviewer.md`
+Use Task tool with review agent type, fill template at `review.md`
 
 **Placeholders:**
+
 - `{WHAT_WAS_IMPLEMENTED}` - What you just built
 - `{PLAN_OR_REQUIREMENTS}` - What it should do
 - `{BASE_SHA}` - Starting commit
@@ -41,6 +45,7 @@ Use Task tool with superpowers:code-reviewer type, fill template at `code-review
 - `{DESCRIPTION}` - Brief summary
 
 **3. Act on feedback:**
+
 - Fix Critical issues immediately
 - Fix Important issues before proceeding
 - Note Minor issues for later
@@ -56,7 +61,7 @@ You: Let me request code review before proceeding.
 BASE_SHA=$(git log --oneline | grep "Task 1" | head -1 | awk '{print $1}')
 HEAD_SHA=$(git rev-parse HEAD)
 
-[Dispatch superpowers:code-reviewer subagent]
+[Dispatch review subagent]
   WHAT_WAS_IMPLEMENTED: Verification and repair functions for conversation index
   PLAN_OR_REQUIREMENTS: Task 2 from docs/plans/deployment-plan.md
   BASE_SHA: a7981ec
@@ -77,29 +82,34 @@ You: [Fix progress indicators]
 ## Integration with Workflows
 
 **Subagent-Driven Development:**
+
 - Review after EACH task
 - Catch issues before they compound
 - Fix before moving to next task
 
 **Executing Plans:**
+
 - Review after each batch (3 tasks)
 - Get feedback, apply, continue
 
 **Ad-Hoc Development:**
+
 - Review before merge
 - Review when stuck
 
 ## Red Flags
 
 **Never:**
+
 - Skip review because "it's simple"
 - Ignore Critical issues
 - Proceed with unfixed Important issues
 - Argue with valid technical feedback
 
 **If reviewer wrong:**
+
 - Push back with technical reasoning
 - Show code/tests that prove it works
 - Request clarification
 
-See template at: requesting-code-review/code-reviewer.md
+See template at: requesting-code-review/review.md

package/dist/template/.opencode/{skills → skill}/subagent-driven-development/SKILL.md

@@ -12,17 +12,20 @@ Execute plan by dispatching fresh subagent per task, with code review after each
 ## Overview
 
 **vs. Executing Plans (parallel session):**
+
 - Same session (no context switch)
 - Fresh subagent per task (no context pollution)
 - Code review after each task (catch issues early)
 - Faster iteration (no human-in-loop between tasks)
 
 **When to use:**
+
 - Staying in this session
 - Tasks are mostly independent
 - Want continuous progress with quality gates
 
 **When NOT to use:**
+
 - Need to review plan first (use executing-plans)
 - Tasks are tightly coupled (manual execution better)
 - Plan needs revision (brainstorm first)
@@ -38,6 +41,7 @@ Read plan file, create TodoWrite with all tasks.
 For each task:
 
 **Dispatch fresh subagent:**
+
 ```
 Task tool (general-purpose):
   description: "Implement Task N: [task name]"
@@ -60,16 +64,16 @@ Task tool (general-purpose):
 
 ### 3. Review Subagent's Work
 
-**Dispatch code-reviewer subagent:**
-```
-Task tool (superpowers:code-reviewer):
-  Use template at requesting-code-review/code-reviewer.md
-
-  WHAT_WAS_IMPLEMENTED: [from subagent's report]
-  PLAN_OR_REQUIREMENTS: Task N from [plan-file]
-  BASE_SHA: [commit before task]
-  HEAD_SHA: [current commit]
-  DESCRIPTION: [task summary]
+**Dispatch review subagent:**
+
+Use template at requesting-code-review/review.md
+
+WHAT_WAS_IMPLEMENTED: [from subagent's report]
+PLAN_OR_REQUIREMENTS: Task N from [plan-file]
+BASE_SHA: [commit before task]
+HEAD_SHA: [current commit]
+DESCRIPTION: [task summary]
+
 ```
 
 **Code reviewer returns:** Strengths, Issues (Critical/Important/Minor), Assessment
@@ -77,13 +81,17 @@ Task tool (superpowers:code-reviewer):
 ### 4. Apply Review Feedback
 
 **If issues found:**
+
 - Fix Critical issues immediately
 - Fix Important issues before next task
 - Note Minor issues
 
 **Dispatch follow-up subagent if needed:**
+
 ```
+
 "Fix issues from code review: [list issues]"
+
 ```
 
 ### 5. Mark Complete, Next Task
@@ -94,7 +102,8 @@ Task tool (superpowers:code-reviewer):
 
 ### 6. Final Review
 
-After all tasks complete, dispatch final code-reviewer:
+After all tasks complete, dispatch final review:
+
 - Reviews entire implementation
 - Checks all plan requirements met
 - Validates overall architecture
@@ -102,13 +111,15 @@ After all tasks complete, dispatch final code-reviewer:
 ### 7. Complete Development
 
 After final review passes:
-- Announce: "I'm using the finishing-a-development-branch skill to complete this work."
-- **REQUIRED SUB-SKILL:** Use superpowers:finishing-a-development-branch
+
+- Announce: "I'm using finishing-a-development-branch skill to complete this work."
+- **REQUIRED SUB-SKILL:** Use use_skill("finishing-a-development-branch")
 - Follow that skill to verify tests, present options, execute choice
 
 ## Example Workflow
 
 ```
+
 You: I'm using Subagent-Driven Development to execute this plan.
 
 [Load plan, create TodoWrite]
@@ -118,7 +129,7 @@ Task 1: Hook installation script
 [Dispatch implementation subagent]
 Subagent: Implemented install-hook with tests, 5/5 passing
 
-[Get git SHAs, dispatch code-reviewer]
+[Get git SHAs, dispatch review]
 Reviewer: Strengths: Good test coverage. Issues: None. Ready.
 
 [Mark Task 1 complete]
@@ -128,7 +139,7 @@ Task 2: Recovery modes
 [Dispatch implementation subagent]
 Subagent: Added verify/repair, 8/8 tests passing
 
-[Dispatch code-reviewer]
+[Dispatch review]
 Reviewer: Strengths: Solid. Issues (Important): Missing progress reporting
 
 [Dispatch fix subagent]
@@ -139,51 +150,61 @@ Fix subagent: Added progress every 100 conversations
 ...
 
 [After all tasks]
-[Dispatch final code-reviewer]
+[Dispatch final review]
 Final reviewer: All requirements met, ready to merge
 
 Done!
+
 ```
 
 ## Advantages
 
 **vs. Manual execution:**
+
 - Subagents follow TDD naturally
 - Fresh context per task (no confusion)
 - Parallel-safe (subagents don't interfere)
 
 **vs. Executing Plans:**
+
 - Same session (no handoff)
 - Continuous progress (no waiting)
 - Review checkpoints automatic
 
 **Cost:**
+
 - More subagent invocations
 - But catches issues early (cheaper than debugging later)
 
 ## Red Flags
 
 **Never:**
+
 - Skip code review between tasks
 - Proceed with unfixed Critical issues
 - Dispatch multiple implementation subagents in parallel (conflicts)
 - Implement without reading plan task
 
 **If subagent fails task:**
+
 - Dispatch fix subagent with specific instructions
 - Don't try to fix manually (context pollution)
 
 ## Integration
 
 **Required workflow skills:**
+
 - **writing-plans** - REQUIRED: Creates the plan that this skill executes
 - **requesting-code-review** - REQUIRED: Review after each task (see Step 3)
 - **finishing-a-development-branch** - REQUIRED: Complete development after all tasks (see Step 7)
 
 **Subagents must use:**
+
 - **test-driven-development** - Subagents follow TDD for each task
 
 **Alternative workflow:**
+
 - **executing-plans** - Use for parallel session instead of same-session execution
 
-See code-reviewer template: requesting-code-review/code-reviewer.md
+See review template: requesting-code-review/review.md
+```