@ikieaneh/opencode-kit 0.6.1 → 0.6.3

package/.opencode/plugins/opencode-kit.js

@@ -73,33 +73,38 @@ const resolveConfigPath = (projectDir, relPath) => {
 
 // --- Auto-init contract.json if missing ---
 const ensureContract = (projectDir) => {
-  const homeDir = os.homedir();
-  const globalDir = path.join(homeDir, '.config/opencode-kit');
-  const contractPath = path.join(projectDir, '.opencode', 'orchestration', 'contract.json');
-
-  // Already exists — nothing to do
-  if (fs.existsSync(contractPath)) return contractPath;
-
-  // Check global config first
-  const globalContract = path.join(globalDir, 'orchestration', 'contract.json');
-  if (fs.existsSync(globalContract)) {
-    fs.mkdirSync(path.dirname(contractPath), { recursive: true });
-    fs.copyFileSync(globalContract, contractPath);
-    log('info', `Auto-initialized contract from global config: ${contractPath}`);
-    return contractPath;
-  }
+  try {
+    const homeDir = os.homedir();
+    const globalDir = path.join(homeDir, '.config/opencode-kit');
+    const contractPath = path.join(projectDir, '.opencode', 'orchestration', 'contract.json');
+
+    // Already exists — nothing to do
+    if (fs.existsSync(contractPath)) return contractPath;
+
+    // Check global config first
+    const globalContract = path.join(globalDir, 'orchestration', 'contract.json');
+    if (fs.existsSync(globalContract)) {
+      fs.mkdirSync(path.dirname(contractPath), { recursive: true });
+      fs.copyFileSync(globalContract, contractPath);
+      log('info', `Auto-initialized contract from global config: ${contractPath}`);
+      return contractPath;
+    }
 
-  // Scaffold from plugin template
-  const templatePath = path.join(TEMPLATES_DIR, 'contract.json');
-  if (fs.existsSync(templatePath)) {
-    fs.mkdirSync(path.dirname(contractPath), { recursive: true });
-    fs.copyFileSync(templatePath, contractPath);
-    log('info', `Auto-initialized contract from plugin template: ${contractPath}`);
-    return contractPath;
-  }
+    // Scaffold from plugin template
+    const templatePath = path.join(TEMPLATES_DIR, 'contract.json');
+    if (fs.existsSync(templatePath)) {
+      fs.mkdirSync(path.dirname(contractPath), { recursive: true });
+      fs.copyFileSync(templatePath, contractPath);
+      log('info', `Auto-initialized contract from plugin template: ${contractPath}`);
+      return contractPath;
+    }
 
-  log('warn', 'Could not auto-initialize contract — no template found');
-  return null;
+    log('warn', 'Could not auto-initialize contract — no template found');
+    return null;
+  } catch (err) {
+    log('error', `Failed to auto-init contract: ${err.message}`);
+    return null;
+  }
 };
 
 // --- Load bootstrap content (cached) ---
@@ -160,86 +165,98 @@ export const OpencodeKitPlugin = async ({ client, directory }) => {
   ensureContract(projectDir);
 
   // Ensure global config directory exists
-  fs.mkdirSync(path.join(globalConfigDir, 'orchestration'), { recursive: true });
-  fs.mkdirSync(path.join(globalConfigDir, 'rules'), { recursive: true });
+  try {
+    fs.mkdirSync(path.join(globalConfigDir, 'orchestration'), { recursive: true });
+    fs.mkdirSync(path.join(globalConfigDir, 'rules'), { recursive: true });
+  } catch (err) {
+    log('warn', `Failed to create global config dirs: ${err.message}`);
+  }
 
   return {
     // Skill resolution order (first match wins):
     //   1. .opencode/skills/<name>/  (user project — highest priority)
     //   2. plugin skills/<name>/     (opencode-kit defaults — fallback)
     config: async (config) => {
-      config.skills = config.skills || {};
-      config.skills.paths = config.skills.paths || [];
-
-      // Detect if other plugins might conflict with opencode-kit's system prompt
-      if (config.plugins && Array.isArray(config.plugins)) {
-        const kitIndex = config.plugins.findIndex(p =>
-          typeof p === 'string' && p.includes('opencode-kit')
-        );
-        if (kitIndex > 0) {
-          const firstPlugin = config.plugins[0];
-          log('warn', `Plugin ordering conflict: opencode-kit should be FIRST, but found '${firstPlugin}' at position 0 and opencode-kit at position ${kitIndex}`);
+      try {
+        config.skills = config.skills || {};
+        config.skills.paths = config.skills.paths || [];
+
+        // Detect if other plugins might conflict with opencode-kit's system prompt
+        if (config.plugins && Array.isArray(config.plugins)) {
+          const kitIndex = config.plugins.findIndex(p =>
+            typeof p === 'string' && p.includes('opencode-kit')
+          );
+          if (kitIndex > 0) {
+            const firstPlugin = config.plugins[0];
+            log('warn', `Plugin ordering conflict: opencode-kit should be FIRST, but found '${firstPlugin}' at position 0 and opencode-kit at position ${kitIndex}`);
+          }
         }
-      }
 
-      // Register user project skills FIRST (higher priority)
-      const userSkillsDir = path.join(projectDir, '.opencode/skills');
-      if (fs.existsSync(userSkillsDir) && !config.skills.paths.includes(userSkillsDir)) {
-        config.skills.paths.push(userSkillsDir);
-        log('info', `Registered user skills: ${userSkillsDir}`);
-      }
+        // Register user project skills FIRST (higher priority)
+        const userSkillsDir = path.join(projectDir, '.opencode/skills');
+        if (fs.existsSync(userSkillsDir) && !config.skills.paths.includes(userSkillsDir)) {
+          config.skills.paths.push(userSkillsDir);
+          log('info', `Registered user skills: ${userSkillsDir}`);
+        }
 
-      // Register plugin skills SECOND (fallback)
-      if (!config.skills.paths.includes(SKILLS_DIR)) {
-        config.skills.paths.push(SKILLS_DIR);
-        log('info', `Registered plugin skills: ${SKILLS_DIR}`);
-      }
+        // Register plugin skills SECOND (fallback)
+        if (!config.skills.paths.includes(SKILLS_DIR)) {
+          config.skills.paths.push(SKILLS_DIR);
+          log('info', `Registered plugin skills: ${SKILLS_DIR}`);
+        }
 
-      // Register global config skills path
-      if (!config.skills.paths.includes(globalConfigDir)) {
-        if (fs.existsSync(globalConfigDir)) {
-          config.skills.paths.push(globalConfigDir);
+        // Register global config skills path
+        if (!config.skills.paths.includes(globalConfigDir)) {
+          if (fs.existsSync(globalConfigDir)) {
+            config.skills.paths.push(globalConfigDir);
+          }
         }
-      }
 
-      // Provide default contract key hint for agents
-      config.contractKey = contractKey;
+        // Provide default contract key hint for agents
+        config.contractKey = contractKey;
+      } catch (err) {
+        log('error', `config hook failed: ${err.message}`);
+      }
     },
 
     'experimental.chat.messages.transform': async (_input, output) => {
-      const bootstrap = getBootstrapContent();
-      if (!bootstrap || !output.messages.length) return;
-
-      // Check contract for rule_overrides and inject them into bootstrap
-      const contractPath = path.join(projectDir, '.opencode', 'orchestration', 'contract.json');
-      let finalBootstrap = bootstrap;
-      if (fs.existsSync(contractPath)) {
-        try {
-          const contractRaw = fs.readFileSync(contractPath, 'utf8');
-          const contract = JSON.parse(contractRaw);
-          if (contract.validation && contract.validation.rule_overrides) {
-            const overrides = contract.validation.rule_overrides;
-            const overrideKeys = Object.keys(overrides);
-            if (overrideKeys.length > 0) {
-              const overrideText = overrideKeys
-                .map(id => `  - ${id}: action → ${overrides[id]}`)
-                .join('\n');
-              finalBootstrap = bootstrap + `\n## Rule Overrides (from contract)\n\nThe following rule severities have been overridden:\n${overrideText}\n`;
+      try {
+        const bootstrap = getBootstrapContent();
+        if (!bootstrap || !output.messages.length) return;
+
+        // Check contract for rule_overrides and inject them into bootstrap
+        const contractPath = path.join(projectDir, '.opencode', 'orchestration', 'contract.json');
+        let finalBootstrap = bootstrap;
+        if (fs.existsSync(contractPath)) {
+          try {
+            const contractRaw = fs.readFileSync(contractPath, 'utf8');
+            const contract = JSON.parse(contractRaw);
+            if (contract.validation && contract.validation.rule_overrides) {
+              const overrides = contract.validation.rule_overrides;
+              const overrideKeys = Object.keys(overrides);
+              if (overrideKeys.length > 0) {
+                const overrideText = overrideKeys
+                  .map(id => `  - ${id}: action → ${overrides[id]}`)
+                  .join('\n');
+                finalBootstrap = bootstrap + `\n## Rule Overrides (from contract)\n\nThe following rule severities have been overridden:\n${overrideText}\n`;
+              }
             }
+          } catch (err) {
+            log('warn', `Failed to parse contract for rule_overrides: ${err.message}`);
           }
-        } catch (err) {
-          log('warn', `Failed to parse contract for rule_overrides: ${err.message}`);
         }
-      }
 
-      const firstUser = output.messages.find(m => m.info.role === 'user');
-      if (!firstUser || !firstUser.parts.length) return;
+        const firstUser = output.messages.find(m => m.info.role === 'user');
+        if (!firstUser || !firstUser.parts.length) return;
 
-      // Guard: skip if already injected
-      if (firstUser.parts.some(p => p.type === 'text' && p.text.includes('opencode-kit'))) return;
+        // Guard: skip if already injected
+        if (firstUser.parts.some(p => p.type === 'text' && p.text.includes('opencode-kit'))) return;
 
-      const ref = firstUser.parts[0];
-      firstUser.parts.unshift({ ...ref, type: 'text', text: finalBootstrap });
+        const ref = firstUser.parts[0];
+        firstUser.parts.unshift({ ...ref, type: 'text', text: finalBootstrap });
+      } catch (err) {
+        log('error', `messages.transform hook failed: ${err.message}`);
+      }
     }
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikieaneh/opencode-kit",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Standardized OpenCode orchestration framework — contract-based, rules-enforced, zero-touch agent workflow. Install as plugin.",
   "license": "MIT",
   "author": "RizkiRachman",
@@ -16,12 +16,13 @@
   },
   "files": [
     ".opencode/plugins/",
-    ".claude-plugin/",
-    "src/",
-    "rules/",
     "templates/",
     "skills/",
-    "docs/"
+    "rules/",
+    "src/cli.js",
+    "src/init.sh",
+    "LICENSE",
+    "README.md"
   ],
   "publishConfig": {
     "access": "public"
@@ -42,8 +43,9 @@
     "url": "git+https://github.com/RizkiRachman/opencode-kit.git"
   },
   "scripts": {
-    "lint": "eslint src/ test/",
-    "format": "prettier --check src/ test/"
+    "postinstall": "git config core.hooksPath .githooks 2>/dev/null || true",
+    "lint": "shellcheck src/*.sh rules/*.sh 2>/dev/null || true",
+    "format": "echo 'Formatting: not configured yet'"
   },
   "bugs": {
     "url": "https://github.com/RizkiRachman/opencode-kit/issues"

package/src/init.sh

@@ -83,8 +83,8 @@ if [ -d ".opencode" ]; then
     echo "  ✅ Backed up to $BACKUP"
   else
     echo ""
-    echo -e "${YELLOW}⚠️  .opencode/ already exists. Use --force to overwrite (backup + clean scaffold).${NC}"
-    echo "  Missing files will be added. Existing files will NOT be overwritten."
+    echo -e "${YELLOW}⚠️  .opencode/ already exists. Use --force to re-scaffold (backup + clean).${NC}"
+    echo "  Skipping — existing .opencode/ preserved."
   fi
 fi
 

package/templates/opencode-kit.schema.json

@@ -3,6 +3,7 @@
   "title": "opencode-kit Plugin Config",
   "description": "Configuration schema for @ikieaneh/opencode-kit plugin. Add to your opencode.json to enable orchestration agents.",
   "type": "object",
+  "additionalProperties": false,
   "properties": {
     "plugin": {
       "type": "array",

package/templates/superpowers-contract.json

@@ -1,5 +1,6 @@
 {
   "version": "0.1.0",
+  "template_version": "0.6.2",
   "description": "Superpowers & MCP registry for opencode-kit",
   "plugins": ["superpowers"],
   "mcps": ["gitnexus", "graphify", "lean-ctx", "context7"],

package/.claude-plugin/plugin.json

@@ -1,23 +0,0 @@
-{
-  "name": "opencode-kit",
-  "description": "Standardized orchestration framework — contract-based, rules-enforced, zero-touch agent workflow",
-  "version": "0.6.1",
-  "author": {
-    "name": "Rizki Rachman",
-    "url": "https://github.com/RizkiRachman"
-  },
-  "homepage": "https://github.com/RizkiRachman/opencode-kit",
-  "repository": "https://github.com/RizkiRachman/opencode-kit",
-  "license": "MIT",
-  "keywords": [
-    "opencode",
-    "opencode-plugin",
-    "orchestration",
-    "workflow",
-    "agents",
-    "enforcement",
-    "contract",
-    "scoring",
-    "adr"
-  ]
-}

package/docs/examples/QUICKSTART.md

@@ -1,123 +0,0 @@
-# Quickstart: Using opencode-kit as a Plugin
-
-This guide creates a new project from scratch with opencode-kit as an OpenCode plugin.
-
-## Step 1: Create a project
-
-```sh
-mkdir my-agent-project
-cd my-agent-project
-git init
-```
-
-## Step 2: Install the plugin
-
-```sh
-npm install @ikieaneh/opencode-kit
-```
-
-## Step 3: Configure OpenCode
-
-Create `opencode.json`:
-
-```json
-{
-  "model": "your-model",
-  "plugin": [
-    "@ikieaneh/opencode-kit",
-    "superpowers"
-  ],
-  "agent": {
-    "orchestrator": {
-      "model": "your-model",
-      "skills": [
-        "orchestration-template",
-        "scoring-pipeline",
-        "verification-before-completion"
-      ],
-      "steps": 50,
-      "fallback_models": ["your-fallback-model"]
-    },
-    "planner": {
-      "model": "your-model",
-      "skills": ["brainstorming", "writing-plans", "system-analyst"],
-      "steps": 80,
-      "fallback_models": ["your-fallback-model"]
-    },
-    "task-manager": {
-      "model": "your-model",
-      "skills": ["subagent-driven-development", "executing-plans", "test-driven-development"],
-      "steps": 100,
-      "fallback_models": ["your-fallback-model"]
-    },
-    "code-reviewer": {
-      "model": "your-model",
-      "skills": ["qa-expert", "security-expert"],
-      "steps": 80,
-      "fallback_models": ["your-fallback-model"]
-    },
-    "explorer": {
-      "model": "your-model",
-      "steps": 30,
-      "tools": { "postgres_*": false, "memory_*": false, "context7_*": false }
-    },
-    "librarian": {
-      "model": "your-model",
-      "steps": 30,
-      "tools": { "postgres_*": false, "memory_*": false, "graphify_*": false }
-    },
-    "leaner": {
-      "model": "your-model",
-      "skills": ["verification-before-completion", "qa-expert"]
-    }
-  }
-}
-```
-
-## Step 4: Start working
-
-Open the project in OpenCode. The plugin auto-loads:
-
-1. 8 skills registered automatically
-2. Orchestration contract injected into every session
-3. Pre-flight enforcement active (branch check, contract load)
-4. Scoring pipeline available after every delegation
-5. ADR generator for architectural decisions
-6. Telemetry tracking elapsed time per phase
-
-## Step 5: Set a goal
-
-Edit `.opencode/orchestration/contract.json`:
-
-```json
-{
-  "state": "INIT",
-  "requirements": {
-    "goal": "Add user authentication with JWT",
-    "acceptance_criteria": ["Users can register", "Users can login", "Tokens expire after 24h"]
-  }
-}
-```
-
-## Step 6: Workflow runs itself
-
-```
-INIT → PLAN → PLAN_SCORED → EXECUTE → EXECUTE_SCORED → REVIEW → REVIEW_SCORED → COMPLETE
-```
-
-Each phase transition requires score ≥ 70. Score < 50 → BLOCKED.
-
-## What you get
-
-| Feature | Provider |
-|---------|----------|
-| Contract protocol | orchestration-template skill |
-| Scoring pipeline | scoring-pipeline skill |
-| ADR records | adr-generator skill |
-| QA standards | qa-expert skill |
-| Impact analysis | system-analyst skill |
-| Token optimization | token-optimize skill |
-| Verification gates | verification-before-completion skill |
-| Post-task learning | learner skill |
-| Telemetry | src/telemetry.sh |
-| Rules enforcement | rules.json + validation.sh |

package/docs/examples/extension-skill-template.md

@@ -1,108 +0,0 @@
-# Extension Skill Template
-
-Create project-specific skills in `.opencode/skills/` to extend opencode-kit.
-
-## Resolution Order
-
-1. `.opencode/skills/<name>/SKILL.md` — user project skill (highest priority)
-2. `node_modules/@ikieaneh/opencode-kit/skills/<name>/SKILL.md` — plugin skill (fallback)
-
-If a user skill and plugin skill have the **same name**, the user's version takes priority.
-
-## Example: Java/Spring Conventions
-
-Create `.opencode/skills/java-conventions/SKILL.md`:
-
-```markdown
----
-description: Java 21 + Spring Boot 3.4 conventions for this project.
----
-
-# Java Conventions
-
-## Build & Test
-
-| Command | Action |
-|---------|--------|
-| `mvn spotless:apply` | Format (Google Java Style) |
-| `mvn test` | ArchUnit + unit tests |
-| `mvn verify` | SpotBugs + PMD CPD |
-
-## Hexagonal Architecture
-
-```
-application/      → domain model, ports, services (no Spring/JPA)
-infrastructure/   → web adapters, persistence, events
-```
-
-## Writing Order
-
-Port → Service → Mapper → Adapter → Constants → Events → Tests
-
-## Naming Rules
-
-| Concern | Suffix | Example |
-|---------|--------|---------|
-| API DTO | none | `Product` |
-| Domain Model | `Domain` | `ProductDomain` |
-| JPA Entity | `Entity` | `ProductEntity` |
-
-## ArchUnit Rules (7)
-
-1. domainMustNotDependOnInfrastructure
-2. domainModelsMustNotHaveJpaAnnotations
-3. portsMustNotReturnOptional
-4. entitiesMustNotUseJpaRelationshipAnnotations
-5. layeredArchitectureShouldRespectHexagonalBoundaries
-6. domainServicesMustBeAnnotatedWithService
-7. repositoryAdaptersMustBeAnnotatedWithComponent
-```
-
-## Example: Python/Django Conventions
-
-Create `.opencode/skills/python-conventions/SKILL.md`:
-
-```markdown
----
-description: Django REST Framework conventions for this project.
----
-
-# Python Conventions
-
-## Build & Test
-
-| Command | Action |
-|---------|--------|
-| `black .` | Format code |
-| `ruff check .` | Lint |
-| `pytest` | Run tests |
-| `mypy .` | Type check |
-
-## Architecture
-
-Apps follow clean architecture:
-- `models/` — domain models with business logic
-- `serializers/` — input/output validation
-- `views/` — HTTP handlers (thin)
-- `services/` — business logic layer
-- `tests/` — mirrors app structure
-```
-
-## How to Load
-
-In `opencode.json`, add to any agent's skills array:
-
-```json
-{
-  "agent": {
-    "task-manager": {
-      "skills": [
-        "verification-before-completion",
-        "java-conventions"
-      ]
-    }
-  }
-}
-```
-
-Or load it ad-hoc with: `/skill java-conventions`

package/docs/examples/model-configs.md

@@ -1,117 +0,0 @@
-# Model Provider Configurations
-
-Add these to your `opencode.json` to configure AI models for opencode-kit agents.
-
-## DeepSeek (via Sumopod)
-
-```json
-{
-  "model": "sumopod/deepseek-v4-flash",
-  "provider": {
-    "sumopod": {
-      "npm": "@ai-sdk/openai-compatible",
-      "name": "Sumopod AI",
-      "options": {
-        "baseURL": "https://ai.sumopod.com/v1",
-        "apiKey": "sk-your-key"
-      },
-      "models": {
-        "deepseek-v4-flash": {
-          "name": "DeepSeek V4 Flash",
-          "options": {
-            "reasoningEffort": "high",
-            "textVerbosity": "low"
-          }
-        }
-      }
-    }
-  }
-}
-```
-
-## OpenAI
-
-```json
-{
-  "model": "gpt-4o",
-  "provider": {
-    "openai": {
-      "npm": "@ai-sdk/openai",
-      "models": {
-        "gpt-4o": { "name": "GPT-4o" },
-        "gpt-4o-mini": { "name": "GPT-4o Mini" }
-      }
-    }
-  }
-}
-```
-
-## Anthropic (Claude)
-
-```json
-{
-  "model": "claude-sonnet-4-20250514",
-  "provider": {
-    "anthropic": {
-      "npm": "@ai-sdk/anthropic",
-      "models": {
-        "claude-sonnet-4-20250514": { "name": "Claude Sonnet 4" },
-        "claude-haiku-3-5-20241022": { "name": "Claude Haiku 3.5" }
-      }
-    }
-  }
-}
-```
-
-## Google (Gemini)
-
-```json
-{
-  "model": "gemini-2.5-flash",
-  "provider": {
-    "google": {
-      "npm": "@ai-sdk/google",
-      "models": {
-        "gemini-2.5-flash": { "name": "Gemini 2.5 Flash" },
-        "gemini-2.5-pro": { "name": "Gemini 2.5 Pro" }
-      }
-    }
-  }
-}
-```
-
-## Agent Assignment Strategy
-
-Use **cheaper models** for simple agents, **better models** for complex reasoning:
-
-| Agent | Recommended Model | Why |
-|-------|------------------|-----|
-| orchestrator | Cheaper (orchestration, not deep thinking) | Delegates most work |
-| planner | Better (architecture, impact analysis) | Needs deep reasoning |
-| task-manager | Better (implementation, code quality) | Needs to write correct code |
-| code-reviewer | Better (security, edge cases) | Needs sharp analysis |
-| explorer | Cheaper (just searches) | Simple grep/glob |
-| librarian | Cheaper (fetches docs) | Simple fetch operations |
-| learner | Cheaper (analysis after the fact) | Post-processing only |
-| fixer | Cheaper (bounded edits) | Well-defined scope |
-
-Example with mixed models:
-
-```json
-{
-  "agent": {
-    "orchestrator": {
-      "model": "sumopod/deepseek-v4-flash",
-      "fallback_models": ["gpt-4o-mini"]
-    },
-    "planner": {
-      "model": "gpt-4o",
-      "fallback_models": ["sumopod/deepseek-v4-flash"]
-    },
-    "task-manager": {
-      "model": "gpt-4o",
-      "fallback_models": ["sumopod/deepseek-v4-flash"]
-    }
-  }
-}
-```