superpowers-opencode-fork-dev-test 1.0.0 → 1.0.1

package/.opencode/plugins/superpowers.js

@@ -83,7 +83,226 @@ ${toolMapping}
 </EXTREMELY_IMPORTANT>`;
   };
 
+  // Platform detection: only run on Linux or macOS
+  const platform = os.platform();
+  const isLinux = platform === 'linux';
+  const isMacOS = platform === 'darwin';
+  const isSupportedPlatform = isLinux || isMacOS;
+
+  // Client detection: only run in OpenCode
+  const isOpencode = client?.app?.name === 'opencode';
+
+  // Helper to read configuration from directory/opencode.json
+  const readConfig = () => {
+    const configPath = path.join(directory, 'opencode.json');
+    
+    if (!fs.existsSync(configPath)) {
+      return {
+        superpowers: {
+          autoupdate: true,
+          autoupdate_notify: true
+        }
+      };
+    }
+
+    try {
+      const configContent = fs.readFileSync(configPath, 'utf8');
+      const config = JSON.parse(configContent);
+      
+      return {
+        superpowers: {
+          autoupdate: config.superpowers?.autoupdate ?? true,
+          autoupdate_notify: config.superpowers?.autoupdate_notify ?? true
+        }
+      };
+    } catch (error) {
+      client.app.log('superpowers: Failed to parse opencode.json, using defaults');
+      return {
+        superpowers: {
+          autoupdate: true,
+          autoupdate_notify: true
+        }
+      };
+    }
+  };
+
+  // Helper to check if superpowers was manually installed
+  const isManualInstall = (superpowersDir) => {
+    const gitConfigPath = path.join(superpowersDir, '.git', 'config');
+    
+    if (!fs.existsSync(gitConfigPath)) {
+      return false;
+    }
+
+    try {
+      const gitConfig = fs.readFileSync(gitConfigPath, 'utf8');
+      const expectedUrls = [
+        'https://github.com/obra/superpowers.git',
+        'git+https://github.com/obra/superpowers.git'
+      ];
+
+      const isExpectedUrl = expectedUrls.some(url => gitConfig.includes(url));
+      return !isExpectedUrl;
+    } catch (error) {
+      return false;
+    }
+  };
+
+  // Autoinstall handler - entry point for all autoinstall logic
+  const handleAutoinstall = async () => {
+    // Exit early on unsupported platforms
+    if (!isSupportedPlatform) {
+      client.app.log('superpowers: Skipping autoinstall - unsupported platform:', platform);
+      return;
+    }
+
+    // Exit early if not running in OpenCode
+    if (!isOpencode) {
+      client.app.log('superpowers: Skipping autoinstall - not running in OpenCode');
+      return;
+    }
+
+    // Read configuration from directory/opencode.json
+    const config = readConfig();
+
+    client.app.log('superpowers: Autoinstall starting...');
+    client.app.log('superpowers: Config directory:', configDir);
+
+    const superpowersDir = path.join(configDir, 'superpowers');
+    const pluginSymlinkPath = path.join(configDir, 'plugins/superpowers.js');
+    const skillsSymlinkPath = path.join(configDir, 'skills/superpowers');
+    const targetPluginPath = path.join(superpowersDir, '.opencode/plugins/superpowers.js');
+    const targetSkillsPath = path.join(superpowersDir, 'skills');
+
+    // Task 4: Implement git clone if not exists
+    if (!fs.existsSync(superpowersDir)) {
+      client.app.log('superpowers: Superpowers directory not found, cloning repository...');
+      try {
+        await $`git clone git+https://github.com/obra/superpowers.git ${superpowersDir}`;
+        client.app.log('superpowers: Successfully cloned superpowers repository');
+      } catch (error) {
+        if (error.message.includes('git')) {
+          client.app.log('superpowers: Error: Git is not installed. Please install git to continue.');
+        } else {
+          client.app.log('superpowers: Failed to clone repository:', error.message);
+        }
+        return;
+      }
+    } else {
+      client.app.log('superpowers: Superpowers directory exists at', superpowersDir);
+    }
+
+    // Task 5: Implement symlink creation/removal (idempotent)
+    const createSymlink = (source, target) => {
+      try {
+        // Remove existing symlink or file if it exists
+        if (fs.existsSync(target) || fs.lstatSync(target).isSymbolicLink()) {
+          client.app.log('superpowers: Removing existing symlink at', target);
+          fs.unlinkSync(target);
+        }
+      } catch (error) {
+        // Ignore errors if target doesn't exist
+      }
+
+      // Ensure parent directory exists
+      const parentDir = path.dirname(target);
+      if (!fs.existsSync(parentDir)) {
+        client.app.log('superpowers: Creating parent directory', parentDir);
+        fs.mkdirSync(parentDir, { recursive: true });
+      }
+
+      // Create symlink
+      try {
+        fs.symlinkSync(source, target);
+        client.app.log('superpowers: Created symlink', target, '→', source);
+      } catch (error) {
+        client.app.log('superpowers: Failed to create symlink', target, '→', source, ':', error.message);
+      }
+    };
+
+    createSymlink(targetPluginPath, pluginSymlinkPath);
+    createSymlink(targetSkillsPath, skillsSymlinkPath);
+
+    // Task 6: Implement update detection and pull
+    const checkForUpdates = async () => {
+      const gitDir = path.join(superpowersDir, '.git');
+      
+      if (!fs.existsSync(gitDir)) {
+        client.app.log('superpowers: Not a git repository, skipping update check');
+        return;
+      }
+
+      // Check for manual install
+      if (isManualInstall(superpowersDir)) {
+        client.app.log('superpowers: Manual installation detected, skipping auto-update');
+        return;
+      }
+
+      // Check autoupdate config
+      if (!config.superpowers.autoupdate) {
+        return;
+      }
+
+      if (config.superpowers.autoupdate_notify) {
+        client.app.log('superpowers: Checking for updates...');
+      }
+
+      try {
+        // Git fetch with timeout
+        await Promise.race([
+          $`git -C ${superpowersDir} fetch origin`,
+          new Promise((_, reject) => 
+            setTimeout(() => reject(new Error('Timeout')), 30000)
+          )
+        ]);
+
+        // Check if local branch is behind remote
+        const localRev = await $`git -C ${superpowersDir} rev-parse HEAD`;
+        const remoteRev = await $`git -C ${superpowersDir} rev-parse @{u}`;
+
+        if (localRev.stdout.trim() !== remoteRev.stdout.trim()) {
+          if (config.superpowers.autoupdate_notify) {
+            client.app.log('superpowers: Updates available, pulling changes...');
+          }
+          await $`git -C ${superpowersDir} pull`;
+          
+          // Get the current version/tag
+          try {
+            const tag = await $`git -C ${superpowersDir} describe --tags --abbrev=0 2>/dev/null`;
+            if (config.superpowers.autoupdate_notify) {
+              client.app.log('superpowers: Updated to version:', tag.stdout.trim());
+            }
+          } catch {
+            if (config.superpowers.autoupdate_notify) {
+              client.app.log('superpowers: Updated successfully (no tag available)');
+            }
+          }
+        } else {
+          if (config.superpowers.autoupdate_notify) {
+            client.app.log('superpowers: Already up to date');
+          }
+        }
+      } catch (error) {
+        if (error.message === 'Timeout') {
+          client.app.log('superpowers: Update check timed out, continuing...');
+        } else {
+          client.app.log('superpowers: Update check failed:', error.message);
+        }
+      }
+    };
+
+    // Run update check in background (non-blocking)
+    setImmediate(() => {
+      checkForUpdates();
+    });
+  };
+
   return {
+    // Autoinstall entry point - triggers on new sessions
+    'session.created': async () => {
+      await handleAutoinstall();
+    },
+
     // Use system prompt transform to inject bootstrap (fixes #226 agent reset bug)
     'experimental.chat.system.transform': async (_input, output) => {
       const bootstrap = getBootstrapContent();

package/README.md

@@ -26,7 +26,7 @@ Thanks!
 
 ## Installation
 
-**Note:** Installation differs by platform. Claude Code has a built-in plugin system. Codex and OpenCode require manual setup.
+**Note:** Installation differs by platform. Claude Code has a built-in plugin system. Codex requires manual setup. OpenCode supports both automatic and manual installation.
 
 ### Claude Code (via Plugin Marketplace)
 
@@ -69,6 +69,20 @@ Fetch and follow instructions from https://raw.githubusercontent.com/obra/superp
 
 ### OpenCode
 
+**Quick Install (npm):**
+
+Add to your opencode.json:
+
+```json
+{
+  "plugin": ["superpowers-opencode-fork-dev-test"]
+}
+```
+
+Superpowers autoinstalls in the background. **Note:** Autoinstall works on Linux and macOS only.
+
+**Manual Installation:**
+
 Tell OpenCode:
 
 ```
@@ -143,12 +157,25 @@ See `skills/writing-skills/SKILL.md` for the complete guide.
 
 ## Updating
 
+### Claude Code
 Skills update automatically when you update the plugin:
 
 ```bash
 /plugin update superpowers
 ```
 
+### OpenCode
+With the npm plugin, updates are handled automatically. Superpowers checks for updates on startup and pulls them in the background (unless disabled in config).
+
+For manual installation, update by running:
+
+```bash
+cd ~/.config/opencode/superpowers
+git pull
+```
+
+Then restart OpenCode.
+
 ## License
 
 MIT License - see LICENSE file for details

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superpowers-opencode-fork-dev-test",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Superpowers plugin for OpenCode.ai - Complete software development workflow with composable skills",
   "type": "module",
   "main": ".opencode/plugins/superpowers.js",
@@ -11,8 +11,7 @@
     }
   },
   "files": [
-    ".opencode/plugins/superpowers.js",
-    "skills/"
+    ".opencode/plugins/superpowers.js"
   ],
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/skills/brainstorming/SKILL.md

@@ -1,54 +0,0 @@
----
-name: brainstorming
-description: "You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation."
----
-
-# Brainstorming Ideas Into Designs
-
-## Overview
-
-Help turn ideas into fully formed designs and specs through natural collaborative dialogue.
-
-Start by understanding the current project context, then ask questions one at a time to refine the idea. Once you understand what you're building, present the design in small sections (200-300 words), checking after each section whether it looks right so far.
-
-## The Process
-
-**Understanding the idea:**
-- Check out the current project state first (files, docs, recent commits)
-- Ask questions one at a time to refine the idea
-- Prefer multiple choice questions when possible, but open-ended is fine too
-- Only one question per message - if a topic needs more exploration, break it into multiple questions
-- Focus on understanding: purpose, constraints, success criteria
-
-**Exploring approaches:**
-- Propose 2-3 different approaches with trade-offs
-- Present options conversationally with your recommendation and reasoning
-- Lead with your recommended option and explain why
-
-**Presenting the design:**
-- Once you believe you understand what you're building, present the design
-- Break it into sections of 200-300 words
-- Ask after each section whether it looks right so far
-- Cover: architecture, components, data flow, error handling, testing
-- Be ready to go back and clarify if something doesn't make sense
-
-## After the Design
-
-**Documentation:**
-- Write the validated design to `docs/plans/YYYY-MM-DD-<topic>-design.md`
-- Use elements-of-style:writing-clearly-and-concisely skill if available
-- Commit the design document to git
-
-**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
-
-## Key Principles
-
-- **One question at a time** - Don't overwhelm with multiple questions
-- **Multiple choice preferred** - Easier to answer than open-ended when possible
-- **YAGNI ruthlessly** - Remove unnecessary features from all designs
-- **Explore alternatives** - Always propose 2-3 approaches before settling
-- **Incremental validation** - Present design in sections, validate each
-- **Be flexible** - Go back and clarify when something doesn't make sense

package/skills/dispatching-parallel-agents/SKILL.md

@@ -1,180 +0,0 @@
----
-name: dispatching-parallel-agents
-description: Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies
----
-
-# Dispatching Parallel Agents
-
-## Overview
-
-When you have multiple unrelated failures (different test files, different subsystems, different bugs), investigating them sequentially wastes time. Each investigation is independent and can happen in parallel.
-
-**Core principle:** Dispatch one agent per independent problem domain. Let them work concurrently.
-
-## When to Use
-
-```dot
-digraph when_to_use {
-    "Multiple failures?" [shape=diamond];
-    "Are they independent?" [shape=diamond];
-    "Single agent investigates all" [shape=box];
-    "One agent per problem domain" [shape=box];
-    "Can they work in parallel?" [shape=diamond];
-    "Sequential agents" [shape=box];
-    "Parallel dispatch" [shape=box];
-
-    "Multiple failures?" -> "Are they independent?" [label="yes"];
-    "Are they independent?" -> "Single agent investigates all" [label="no - related"];
-    "Are they independent?" -> "Can they work in parallel?" [label="yes"];
-    "Can they work in parallel?" -> "Parallel dispatch" [label="yes"];
-    "Can they work in parallel?" -> "Sequential agents" [label="no - shared state"];
-}
-```
-
-**Use when:**
-- 3+ test files failing with different root causes
-- Multiple subsystems broken independently
-- Each problem can be understood without context from others
-- No shared state between investigations
-
-**Don't use when:**
-- Failures are related (fix one might fix others)
-- Need to understand full system state
-- Agents would interfere with each other
-
-## The Pattern
-
-### 1. Identify Independent Domains
-
-Group failures by what's broken:
-- File A tests: Tool approval flow
-- File B tests: Batch completion behavior
-- File C tests: Abort functionality
-
-Each domain is independent - fixing tool approval doesn't affect abort tests.
-
-### 2. Create Focused Agent Tasks
-
-Each agent gets:
-- **Specific scope:** One test file or subsystem
-- **Clear goal:** Make these tests pass
-- **Constraints:** Don't change other code
-- **Expected output:** Summary of what you found and fixed
-
-### 3. Dispatch in Parallel
-
-```typescript
-// In Claude Code / AI environment
-Task("Fix agent-tool-abort.test.ts failures")
-Task("Fix batch-completion-behavior.test.ts failures")
-Task("Fix tool-approval-race-conditions.test.ts failures")
-// All three run concurrently
-```
-
-### 4. Review and Integrate
-
-When agents return:
-- Read each summary
-- Verify fixes don't conflict
-- Run full test suite
-- Integrate all changes
-
-## Agent Prompt Structure
-
-Good agent prompts are:
-1. **Focused** - One clear problem domain
-2. **Self-contained** - All context needed to understand the problem
-3. **Specific about output** - What should the agent return?
-
-```markdown
-Fix the 3 failing tests in src/agents/agent-tool-abort.test.ts:
-
-1. "should abort tool with partial output capture" - expects 'interrupted at' in message
-2. "should handle mixed completed and aborted tools" - fast tool aborted instead of completed
-3. "should properly track pendingToolCount" - expects 3 results but gets 0
-
-These are timing/race condition issues. Your task:
-
-1. Read the test file and understand what each test verifies
-2. Identify root cause - timing issues or actual bugs?
-3. Fix by:
-   - Replacing arbitrary timeouts with event-based waiting
-   - Fixing bugs in abort implementation if found
-   - Adjusting test expectations if testing changed behavior
-
-Do NOT just increase timeouts - find the real issue.
-
-Return: Summary of what you found and what you fixed.
-```
-
-## Common Mistakes
-
-**❌ Too broad:** "Fix all the tests" - agent gets lost
-**✅ Specific:** "Fix agent-tool-abort.test.ts" - focused scope
-
-**❌ No context:** "Fix the race condition" - agent doesn't know where
-**✅ Context:** Paste the error messages and test names
-
-**❌ No constraints:** Agent might refactor everything
-**✅ Constraints:** "Do NOT change production code" or "Fix tests only"
-
-**❌ Vague output:** "Fix it" - you don't know what changed
-**✅ Specific:** "Return summary of root cause and changes"
-
-## When NOT to Use
-
-**Related failures:** Fixing one might fix others - investigate together first
-**Need full context:** Understanding requires seeing entire system
-**Exploratory debugging:** You don't know what's broken yet
-**Shared state:** Agents would interfere (editing same files, using same resources)
-
-## Real Example from Session
-
-**Scenario:** 6 test failures across 3 files after major refactoring
-
-**Failures:**
-- agent-tool-abort.test.ts: 3 failures (timing issues)
-- batch-completion-behavior.test.ts: 2 failures (tools not executing)
-- tool-approval-race-conditions.test.ts: 1 failure (execution count = 0)
-
-**Decision:** Independent domains - abort logic separate from batch completion separate from race conditions
-
-**Dispatch:**
-```
-Agent 1 → Fix agent-tool-abort.test.ts
-Agent 2 → Fix batch-completion-behavior.test.ts
-Agent 3 → Fix tool-approval-race-conditions.test.ts
-```
-
-**Results:**
-- Agent 1: Replaced timeouts with event-based waiting
-- Agent 2: Fixed event structure bug (threadId in wrong place)
-- Agent 3: Added wait for async tool execution to complete
-
-**Integration:** All fixes independent, no conflicts, full suite green
-
-**Time saved:** 3 problems solved in parallel vs sequentially
-
-## Key Benefits
-
-1. **Parallelization** - Multiple investigations happen simultaneously
-2. **Focus** - Each agent has narrow scope, less context to track
-3. **Independence** - Agents don't interfere with each other
-4. **Speed** - 3 problems solved in time of 1
-
-## Verification
-
-After agents return:
-1. **Review each summary** - Understand what changed
-2. **Check for conflicts** - Did agents edit same code?
-3. **Run full suite** - Verify all fixes work together
-4. **Spot check** - Agents can make systematic errors
-
-## Real-World Impact
-
-From debugging session (2025-10-03):
-- 6 failures across 3 files
-- 3 agents dispatched in parallel
-- All investigations completed concurrently
-- All fixes integrated successfully
-- Zero conflicts between agent changes

package/skills/executing-plans/SKILL.md

@@ -1,76 +0,0 @@
----
-name: executing-plans
-description: Use when you have a written implementation plan to execute in a separate session with review checkpoints
----
-
-# Executing Plans
-
-## Overview
-
-Load plan, review critically, execute tasks in batches, report for review between batches.
-
-**Core principle:** Batch execution with checkpoints for architect review.
-
-**Announce at start:** "I'm using the executing-plans skill to implement this plan."
-
-## 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
-
-### 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
-- 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
-- Verification fails repeatedly
-
-**Ask for clarification rather than guessing.**
-
-## 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
-- Reference skills when plan says to
-- Between batches: just report and wait
-- Stop when blocked, don't guess