@tudeorangbiasa/sdd-multiagent-opencode 0.1.0

package/bin/sdd-opencode.js

@@ -0,0 +1,387 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.resolve(__dirname, "..");
+
+function parseArgs(argv) {
+  const args = {
+    command: null,
+    flags: {
+      sddOnly: false,
+      rulesOnly: false,
+      force: false,
+      dryRun: false,
+    },
+  };
+
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "init" || arg === "help" || arg === "test") {
+      args.command = arg;
+    } else if (arg === "--sdd-only") {
+      args.flags.sddOnly = true;
+    } else if (arg === "--rules-only") {
+      args.flags.rulesOnly = true;
+    } else if (arg === "--force") {
+      args.flags.force = true;
+    } else if (arg === "--dry-run") {
+      args.flags.dryRun = true;
+    }
+  }
+
+  if (!args.command) {
+    args.command = "help";
+  }
+
+  return args;
+}
+
+function usage() {
+  console.log(`SDD Multi-Agent OpenCode Installer
+
+Usage:
+  sdd-opencode init [flags]
+  sdd-opencode help
+
+Flags:
+  --sdd-only      Install only SDD workflow (skip base rules)
+  --rules-only   Install only base rules (skip SDD)
+  --force        Overwrite existing managed files
+  --dry-run      Show what would be installed, no writes
+
+Examples:
+  sdd-opencode init                  # Install everything
+  sdd-opencode init --sdd-only       # SDD only
+  sdd-opencode init --rules-only     # Rules only
+  sdd-opencode init --force          # Overwrite existing
+  sdd-opencode init --dry-run        # Preview only
+`);
+}
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function copyFileSafe(src, dest, ctx, options = {}) {
+  const { force, dryRun } = ctx;
+
+  if (fs.existsSync(dest)) {
+    if (!force) {
+      ctx.skipped.push(path.relative(ctx.targetRoot, dest));
+      return false;
+    }
+  }
+
+  if (dryRun) {
+    ctx.dryRunFiles.push(path.relative(ctx.targetRoot, dest));
+    return true;
+  }
+
+  const content = fs.readFileSync(src, "utf-8");
+  fs.writeFileSync(dest, content);
+  ctx.installed.push(path.relative(ctx.targetRoot, dest));
+  return true;
+}
+
+function copyDirFlat(srcDir, destDir, ctx) {
+  if (!fs.existsSync(srcDir)) {
+    return;
+  }
+
+  ensureDir(destDir);
+
+  const files = fs.readdirSync(srcDir);
+  for (const file of files) {
+    const srcPath = path.join(srcDir, file);
+    const destPath = path.join(destDir, file);
+
+    if (fs.statSync(srcPath).isDirectory()) {
+      copyDirFlat(srcPath, destPath, ctx);
+    } else {
+      copyFileSafe(srcPath, destPath, ctx);
+    }
+  }
+}
+
+function copyOpencodeDir(srcRelative, destRelative, ctx) {
+  const srcPath = path.join(packageRoot, srcRelative);
+  const destPath = path.join(ctx.targetRoot, destRelative);
+
+  if (!fs.existsSync(srcPath)) {
+    return 0;
+  }
+
+  let count = 0;
+  const items = fs.readdirSync(srcPath);
+
+  for (const item of items) {
+    const srcItem = path.join(srcPath, item);
+    const destItem = path.join(destPath, item);
+
+    if (fs.statSync(srcItem).isDirectory()) {
+      ensureDir(destItem);
+      const subCount = copyOpencodeDir(
+        `${srcRelative}/${item}`,
+        `${destRelative}/${item}`,
+        ctx
+      );
+      count += subCount;
+    } else {
+      if (copyFileSafe(srcItem, destItem, ctx)) {
+        count++;
+      }
+    }
+  }
+
+  return count;
+}
+
+function installRules(ctx) {
+  const vendorRules = path.join(packageRoot, "vendor/opencode-agent-rules");
+
+  if (!fs.existsSync(vendorRules)) {
+    console.warn("⚠️  vendor/opencode-agent-rules not found, skipping rules");
+    return 0;
+  }
+
+  let count = 0;
+
+  const targetOpencode = path.join(ctx.targetRoot, ".opencode");
+  ensureDir(path.join(targetOpencode, "rules"));
+  ensureDir(path.join(targetOpencode, "plugins"));
+
+  const agentsSrc = path.join(vendorRules, "AGENTS.md");
+  const agentsDest = path.join(ctx.targetRoot, "AGENTS.md");
+
+  if (fs.existsSync(agentsSrc)) {
+    copyFileSafe(agentsSrc, agentsDest, ctx);
+    count++;
+  }
+
+  const rulesSrc = path.join(vendorRules, ".opencode/rules");
+  const rulesDest = path.join(targetOpencode, "rules");
+  count += copyOpencodeDir(".opencode/rules", ".opencode/rules", ctx);
+
+  const pluginsSrc = path.join(vendorRules, ".opencode/plugins");
+  if (fs.existsSync(pluginsSrc)) {
+    count += copyOpencodeDir(".opencode/plugins", ".opencode/plugins", ctx);
+  }
+
+  return count;
+}
+
+function installSdd(ctx) {
+  let count = 0;
+
+  const targetOpencode = path.join(ctx.targetRoot, ".opencode");
+
+  ensureDir(path.join(targetOpencode, "agents"));
+  ensureDir(path.join(targetOpencode, "commands"));
+  ensureDir(path.join(targetOpencode, "skills"));
+
+  count += copyOpencodeDir(".opencode/agents", ".opencode/agents", ctx);
+  count += copyOpencodeDir(".opencode/commands", ".opencode/commands", ctx);
+  count += copyOpencodeDir(".opencode/skills", ".opencode/skills", ctx);
+
+  const sddDir = path.join(ctx.targetRoot, ".sdd");
+  ensureDir(sddDir);
+  ensureDir(path.join(sddDir, "templates"));
+
+  const configSrc = path.join(packageRoot, ".sdd/config.json");
+  const configDest = path.join(sddDir, "config.json");
+  if (copyFileSafe(configSrc, configDest, ctx)) {
+    count++;
+  }
+
+  const templatesSrc = path.join(packageRoot, ".sdd/templates");
+  if (fs.existsSync(templatesSrc)) {
+    const templateFiles = fs.readdirSync(templatesSrc);
+    for (const file of templateFiles) {
+      const src = path.join(templatesSrc, file);
+      const dest = path.join(sddDir, "templates", file);
+      if (copyFileSafe(src, dest, ctx)) {
+        count++;
+      }
+    }
+  }
+
+  const projectProfileDest = path.join(sddDir, "project-profile.json");
+  const profileTemplateSrc = path.join(
+    sddDir,
+    "templates",
+    "project-profile-template.json"
+  );
+
+  if (fs.existsSync(projectProfileDest) && !ctx.force) {
+    ctx.skipped.push(".sdd/project-profile.json (exists)");
+  } else if (fs.existsSync(profileTemplateSrc)) {
+    const profile = JSON.parse(fs.readFileSync(profileTemplateSrc, "utf-8"));
+    profile.initialized = new Date().toISOString();
+    profile.lastUpdated = new Date().toISOString();
+
+    if (ctx.dryRun) {
+      ctx.dryRunFiles.push(".sdd/project-profile.json");
+    } else {
+      fs.writeFileSync(
+        projectProfileDest,
+        JSON.stringify(profile, null, 2)
+      );
+      ctx.installed.push(".sdd/project-profile.json");
+    }
+    count++;
+  }
+
+  const specsDir = path.join(ctx.targetRoot, "specs");
+  ensureDir(path.join(specsDir, "active"));
+  ensureDir(path.join(specsDir, "backlog"));
+  ensureDir(path.join(specsDir, "completed"));
+  ensureDir(path.join(specsDir, "todo-roadmap"));
+
+  return count;
+}
+
+function patchOpencodeJson(ctx) {
+  const targetJsonPath = path.join(ctx.targetRoot, "opencode.json");
+
+  let targetConfig = {};
+
+  if (fs.existsSync(targetJsonPath)) {
+    try {
+      targetConfig = JSON.parse(fs.readFileSync(targetJsonPath, "utf-8"));
+    } catch (e) {
+      ctx.skipped.push("opencode.json (parse error, skipping patch)");
+      return;
+    }
+  }
+
+  if (!targetConfig.agent) {
+    targetConfig.agent = {};
+  }
+
+  const vendorRulesJson = path.join(
+    packageRoot,
+    "vendor/opencode-agent-rules/opencode.json"
+  );
+  if (fs.existsSync(vendorRulesJson)) {
+    const rulesConfig = JSON.parse(fs.readFileSync(vendorRulesJson, "utf-8"));
+    if (rulesConfig.agent?.compaction && !targetConfig.agent.compaction) {
+      targetConfig.agent.compaction = rulesConfig.agent.compaction;
+      ctx.installed.push("opencode.json (compaction patch)");
+    }
+  }
+
+  const pkgJsonPath = path.join(packageRoot, "opencode.json");
+  if (fs.existsSync(pkgJsonPath)) {
+    const pkgConfig = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+
+    if (pkgConfig.agents && !targetConfig.agents) {
+      targetConfig.agents = pkgConfig.agents;
+      ctx.installed.push("opencode.json (agents patch)");
+    }
+
+    if (pkgConfig.agent) {
+      for (const [key, value] of Object.entries(pkgConfig.agent)) {
+        if (!targetConfig.agent[key]) {
+          targetConfig.agent[key] = value;
+          ctx.installed.push(`opencode.json (agent: ${key})`);
+        }
+      }
+    }
+
+    if (pkgConfig.permission && !targetConfig.permission) {
+      targetConfig.permission = pkgConfig.permission;
+      ctx.installed.push("opencode.json (permission patch)");
+    }
+  }
+
+  if (ctx.dryRun) {
+    ctx.dryRunFiles.push("opencode.json (patch)");
+    return;
+  }
+
+  fs.writeFileSync(targetJsonPath, JSON.stringify(targetConfig, null, 2));
+}
+
+async function runInit(args) {
+  const targetRoot = process.cwd();
+
+  if (args.flags.sddOnly && args.flags.rulesOnly) {
+    console.error("❌ Cannot use --sdd-only and --rules-only together.");
+    process.exit(1);
+  }
+
+  const ctx = {
+    targetRoot,
+    force: args.flags.force,
+    dryRun: args.flags.dryRun,
+    installed: [],
+    skipped: [],
+    dryRunFiles: [],
+  };
+
+  console.log(`\n📦 SDD Multi-Agent OpenCode Installer\n`);
+  console.log(`Target: ${targetRoot}`);
+
+  if (ctx.dryRun) {
+    console.log(`Mode: DRY RUN (no files will be written)\n`);
+  }
+
+  let rulesCount = 0;
+  let sddCount = 0;
+
+  if (!args.flags.sddOnly) {
+    console.log(`Installing base rules...`);
+    rulesCount = installRules(ctx);
+  }
+
+  if (!args.flags.rulesOnly) {
+    console.log(`Installing SDD workflow...`);
+    sddCount = installSdd(ctx);
+  }
+
+  patchOpencodeJson(ctx);
+
+  console.log(`\n✅ Done!\n`);
+
+  if (ctx.dryRun) {
+    console.log(`Would install (${ctx.dryRunFiles.length} files):`);
+    for (const f of ctx.dryRunFiles) {
+      console.log(`  + ${f}`);
+    }
+  } else {
+    console.log(`Installed:`);
+    console.log(`  - rules: ${rulesCount} files`);
+    console.log(`  - sdd: ${sddCount} files`);
+
+    if (ctx.skipped.length > 0) {
+      console.log(`\nSkipped (exists, use --force):`);
+      for (const f of ctx.skipped) {
+        console.log(`  - ${f}`);
+      }
+    }
+
+    console.log(`\nNext steps:`);
+    console.log(`  1. Edit .sdd/project-profile.json with your stack`);
+    console.log(`  2. Run: /brief my-feature "Feature description"`);
+    console.log(`  3. Optional TDD: /tasks my-feature --tdd`);
+  }
+}
+
+const args = parseArgs(process.argv);
+
+if (args.command === "help") {
+  usage();
+} else if (args.command === "init") {
+  runInit(args);
+} else {
+  console.error(`Unknown command: ${args.command}`);
+  usage();
+  process.exit(1);
+}

package/opencode.json

@@ -0,0 +1,98 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "agent": {
+    "sdd-orchestrator": {
+      "description": "Parallel task coordination and DAG-based execution for SDD workflows. Use for /execute-parallel, --until-finish automation, and coordinating multiple subagents across complex projects.",
+      "mode": "subagent",
+      "model": "opencode/gpt-5.5",
+      "temperature": 0.3,
+      "permission": {
+        "edit": "allow",
+        "bash": "allow",
+        "task": {
+          "*": "allow"
+        }
+      },
+      "color": "accent"
+    },
+    "sdd-planner": {
+      "description": "Architecture design and technical planning for SDD workflows. Use when generating plans from specifications, designing system architecture, or breaking down features into tasks.",
+      "mode": "subagent",
+      "model": "opencode/gpt-5.5",
+      "temperature": 0.3,
+      "permission": {
+        "edit": "allow",
+        "bash": "allow",
+        "task": {
+          "*": "allow"
+        }
+      },
+      "color": "info"
+    },
+    "sdd-explorer": {
+      "description": "Deep codebase exploration for SDD workflows using codebase-memory-mcp. Use proactively when technical approach is unclear, before /research or /specify, or when investigating existing patterns.",
+      "mode": "subagent",
+      "model": "opencode/deepseek-v4-flash-free",
+      "temperature": 0.1,
+      "permission": {
+        "edit": "deny",
+        "bash": {
+          "*": "ask",
+          "git status*": "allow",
+          "git log*": "allow",
+          "ls*": "allow",
+          "find*": "allow"
+        },
+        "skill": "allow"
+      },
+      "color": "secondary"
+    },
+    "sdd-implementer": {
+      "description": "Systematic code implementation following SDD plans and todo-lists. Use for executing planned implementations, code generation, and building features according to specifications.",
+      "mode": "subagent",
+      "model": "opencode/deepseek-v4-flash-free",
+      "temperature": 0.3,
+      "permission": {
+        "edit": "allow",
+        "bash": "allow",
+        "task": {
+          "sdd-verifier": "allow"
+        }
+      },
+      "color": "success"
+    },
+    "sdd-verifier": {
+      "description": "Independent validation that implementations are actually complete. Uses Chrome DevTools for visual/UI verification and codebase-memory-mcp for structural checks. Spawns after implementation phases.",
+      "mode": "subagent",
+      "model": "opencode/qwen3.6-plus-free",
+      "temperature": 0.1,
+      "permission": {
+        "edit": "deny",
+        "bash": "allow",
+        "skill": "allow"
+      },
+      "color": "warning"
+    },
+    "sdd-reviewer": {
+      "description": "Code review specialist for security, performance, and spec compliance. Use before marking tasks complete, during pull request reviews, or for quality assurance audits.",
+      "mode": "subagent",
+      "model": "opencode/minimax-m2.5-free",
+      "temperature": 0.2,
+      "permission": {
+        "edit": "deny",
+        "bash": {
+          "*": "ask",
+          "git diff*": "allow",
+          "git log*": "allow",
+          "grep*": "allow"
+        }
+      },
+      "color": "error"
+    }
+  },
+  "permission": {
+    "skill": {
+      "sdd-*": "allow"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@tudeorangbiasa/sdd-multiagent-opencode",
+  "version": "0.1.0",
+  "description": "Spec-Driven Development multi-agent workflow for OpenCode",
+  "type": "module",
+  "bin": {
+    "sdd-multiagent-opencode": "bin/sdd-opencode.js",
+    "sdd-opencode": "bin/sdd-opencode.js"
+  },
+  "files": [
+    "bin",
+    ".opencode",
+    ".sdd",
+    "vendor",
+    "README.md",
+    "opencode.json"
+  ],
+  "scripts": {
+    "smoke": "node bin/sdd-opencode.js init --dry-run"
+  },
+  "keywords": [
+    "opencode",
+    "sdd",
+    "spec-driven-development",
+    "multi-agent"
+  ],
+  "license": "MIT"
+}

package/vendor/opencode-agent-rules/.opencode/plugins/context-guard.js

@@ -0,0 +1,7 @@
+export const ContextGuard = async () => {
+  return {
+    "experimental.session.compacting": async (_input, output) => {
+      output.context.push(`## Context Guard\n\nWhen compacting this session, preserve the project operating state rather than a chat transcript.\n\nRequired structure:\n\n### Current Goal\n- What the user is trying to accomplish now.\n\n### Active Workflow\n- Workflow type: SDD / maintenance / bootstrap / general engineering.\n- Current command or phase.\n- Task ID or project ID if present.\n\n### Source Of Truth\n- AGENTS.md, DESIGN.md, PRODUCT.md, .sdd/project-profile.json, specs, plans, tasks, or roadmap paths that matter.\n\n### Decisions Made\n- Durable decisions and their rationale.\n\n### Files Touched\n- Created, modified, or intentionally avoided files.\n\n### Verification State\n- changed: what exists.\n- verified: exact proof run.\n- unverified: what was not checked.\n- blocked: blockers and evidence.\n\n### Next Action\n- The smallest concrete next step.\n\nDiscard resolved discussion, duplicate context, raw logs after summarization, and old alternatives no longer under consideration.`)
+    },
+  }
+}

package/vendor/opencode-agent-rules/.opencode/rules/cli-first.md

@@ -0,0 +1,31 @@
+# CLI-First Scaffolding
+
+For new projects, always use the official framework CLI when one exists.
+
+## Rules
+
+- Do not manually create boilerplate files when an official CLI exists.
+- Do not hand-write manifests, generated config, IDE metadata, or framework scaffolds from memory.
+- Use non-interactive flags when possible.
+- If required choices are missing, ask before running the CLI.
+- After any scaffold or generator runs, inspect the created directory structure before continuing.
+- For existing projects, never rerun scaffold commands unless the user explicitly asks.
+
+## Examples
+
+Use official commands such as:
+
+```bash
+pnpm create next-app@latest
+pnpm create vite@latest
+pnpm dlx nuxi@latest init
+pnpm create astro@latest
+composer create-project laravel/laravel
+```
+
+Never fabricate complex generated files such as:
+
+- `.xcodeproj`
+- `project.pbxproj`
+- `.xcworkspace`
+- complex `.sln` metadata

package/vendor/opencode-agent-rules/.opencode/rules/context-budget.md

@@ -0,0 +1,39 @@
+# Context Budget
+
+Keep active context below 80%.
+
+## Thresholds
+
+| Threshold | Behavior |
+|-----------|----------|
+| 60% | Reduce context loading, checkpoint current state, pass minimal prompts to subagents |
+| 80% | Prepare for compaction; preserve only source-of-truth state and active next action |
+
+## Policy
+
+- Prefer source-of-truth files over conversation memory.
+- Use codebase search and snippets before reading large files.
+- Do not inline entire roadmaps, specs, logs, or task objects into subagent prompts.
+- For multi-agent work, pass only task ID, task title, linked spec path, command to execute, and constraints.
+- Write checkpoints after each meaningful batch.
+- Before long work, summarize current goal, files touched, decisions, verification state, blockers, and next action.
+
+## Compaction Must Preserve
+
+- Current goal.
+- Active workflow and command.
+- Task ID or project ID.
+- Source-of-truth files.
+- Key decisions made.
+- Files touched.
+- Open blockers.
+- Verification state: `changed`, `verified`, `unverified`, `blocked`.
+- Next action.
+
+## Compaction Should Discard
+
+- Resolved discussions.
+- Duplicate context.
+- Failed hypotheses after evidence has been recorded.
+- Raw logs once the important result has been summarized.
+- Old alternatives no longer under consideration.

package/vendor/opencode-agent-rules/.opencode/rules/core-behavior.md

@@ -0,0 +1,44 @@
+# Core Behavior
+
+Use operational guidance, not persona text.
+
+## Default Posture
+
+- Act before explaining when tools can ground the answer.
+- Read before editing and verify after meaningful changes.
+- Match effort to task complexity and risk.
+- Prefer the smallest safe change that solves the real problem.
+- Reuse existing patterns before inventing new abstractions.
+- Separate observation, inference, and assumption in reports.
+
+## Solver Loop
+
+For non-trivial work:
+
+1. Define the outcome in operational terms.
+2. Inspect the repo and current environment before choosing an approach.
+3. Find the spine: entry points, data flow, state boundaries, persistence, and user-visible behavior.
+4. Build the smallest vertical slice that proves the solution works.
+5. Verify at the surface where the user experiences the change.
+6. Expand scope only after the core slice is working.
+
+## Scope Control
+
+- Do exactly the slice the user asked for.
+- Do not turn planning into implementation or explanation into edits.
+- Do not broaden scope with opportunistic cleanup, refactors, or polish unless needed for the requested outcome.
+- If scope changes during the work, tell the user what changed and why before continuing further than the original slice.
+- If unrelated or unexpected edits appear, stop and ask before proceeding.
+
+## Stuck Loop Policy
+
+- After two failed verification attempts on the same hypothesis, stop repeating the same fix.
+- Document evidence from those attempts, then switch strategy: smaller patch, wider read, or one concrete forked question.
+- Do not loop on identical reasoning without changing inputs.
+
+## Communication
+
+- Lead with actions, findings, and results.
+- Keep progress updates short and high signal.
+- Prefer milestone updates over step-by-step narration.
+- When blocked, state the blocker, evidence, and smallest next step.

package/vendor/opencode-agent-rules/.opencode/rules/status-verification.md

@@ -0,0 +1,36 @@
+# Status And Verification
+
+Code is not complete until it has been proved at the surface the user cares about.
+
+## Allowed Status Labels
+
+- `changed`: you edited or produced something.
+- `verified`: you proved a claim with a relevant check.
+- `unverified`: work exists but required proof was not run.
+- `blocked`: required progress or proof failed and the task cannot honestly be called complete.
+- `assumption`: a choice or statement depends on inference rather than direct evidence.
+
+Do not use `done`, `fixed`, `working`, or `resolved` without naming proof immediately after.
+
+## Minimum Proof By Change Type
+
+| Change type | Minimum proof |
+|-------------|---------------|
+| Localized edit | Re-read or one targeted static check |
+| Backend, logic, or API change | Targeted test, command, script, or runtime request |
+| UI or interaction change | Browser or user-surface verification, plus static checks as needed |
+| Integration-sensitive change | Build or typecheck plus one focused behavior check |
+| New app or scaffold | Setup/install succeeds, startup or health check succeeds, production build succeeds, one primary happy-path flow works |
+
+Build, lint, and typecheck support completion claims, but they do not replace runtime or surface proof for interaction, styling, navigation, or integration promises.
+
+## Closeout Contract
+
+Every substantive completion summary should include:
+
+- **Summary**: outcome in one short paragraph.
+- **Files touched**: paths or areas changed.
+- **Verification evidence**: exact commands run, manual checks, user-visible surfaces exercised.
+- **Risks and unverified items**: regressions not tested, assumptions, follow-ups.
+
+If intended verification failed and you fall back to a weaker check, say so explicitly.