@tudeorangbiasa/sdd-multiagent-opencode 0.1.3 → 0.1.4

package/.opencode/plugins/sdd-auto-reasoning.js

@@ -0,0 +1,141 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const pluginDir = path.dirname(fileURLToPath(import.meta.url));
+const LEVELS = new Set(["low", "medium", "high"]);
+const pendingOverrides = new Map();
+const recentCommands = new Map();
+
+function readJson(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function readProfile() {
+  const candidates = [
+    path.join(process.cwd(), ".sdd", "reasoning-profile.json"),
+    path.join(pluginDir, "..", "..", ".sdd", "reasoning-profile.json"),
+    path.join(pluginDir, "..", ".sdd", "reasoning-profile.json"),
+  ];
+
+  for (const candidate of candidates) {
+    const profile = readJson(candidate);
+    if (profile) return profile;
+  }
+
+  return {
+    default: "low",
+    applyProviderOptions: true,
+    resetToolOverrideAfterNextRequest: true,
+    agents: {},
+    commands: {},
+  };
+}
+
+function normalizeLevel(level, fallback = "low") {
+  return LEVELS.has(level) ? level : fallback;
+}
+
+function applyReasoningOptions(output, level) {
+  if (!output.options) output.options = {};
+
+  output.options.reasoningEffort = level;
+  output.options.reasoning_effort = level;
+  output.options.reasoning = {
+    ...(output.options.reasoning ?? {}),
+    effort: level,
+  };
+
+  output.options.providerOptions = {
+    ...(output.options.providerOptions ?? {}),
+    openai: {
+      ...(output.options.providerOptions?.openai ?? {}),
+      reasoningEffort: level,
+      reasoning: {
+        ...(output.options.providerOptions?.openai?.reasoning ?? {}),
+        effort: level,
+      },
+    },
+  };
+}
+
+function resolveLevel(profile, input) {
+  const override = pendingOverrides.get(input.sessionID);
+  if (override) return override;
+
+  const command = recentCommands.get(input.sessionID);
+  if (command && profile.commands?.[command]) {
+    return normalizeLevel(profile.commands[command], profile.default);
+  }
+
+  if (profile.agents?.[input.agent]) {
+    return normalizeLevel(profile.agents[input.agent], profile.default);
+  }
+
+  return normalizeLevel(profile.default, "low");
+}
+
+export default async () => {
+  let toolHooks = {};
+
+  try {
+    const { tool } = await import("@opencode-ai/plugin");
+    toolHooks = {
+      tool: {
+        change_reasoning: tool({
+        description: "Set reasoning effort for the next model request in this session.",
+        args: {
+          level: tool.schema.enum(["low", "medium", "high"]).describe("Reasoning level to use: low, medium, or high."),
+        },
+        async execute(args, context) {
+          const level = normalizeLevel(args.level, "low");
+          pendingOverrides.set(context.sessionID, level);
+          context.metadata({ title: `Reasoning: ${level}`, metadata: { level } });
+
+          return {
+            output: `Reasoning level set to ${level} for the next model request in this session.`,
+            metadata: { level },
+          };
+        },
+      }),
+      },
+    };
+  } catch {
+    toolHooks = {};
+  }
+
+  return {
+    ...toolHooks,
+
+    "command.execute.before": async (input) => {
+      recentCommands.set(input.sessionID, input.command);
+    },
+
+    "chat.params": async (input, output) => {
+      const profile = readProfile();
+      const level = resolveLevel(profile, input);
+
+      if (profile.applyProviderOptions !== false) {
+        applyReasoningOptions(output, level);
+      }
+
+      output.options.sddReasoningLevel = level;
+
+      if (profile.resetToolOverrideAfterNextRequest !== false) {
+        pendingOverrides.delete(input.sessionID);
+      }
+    },
+
+    "experimental.chat.system.transform": async (_input, output) => {
+      output.system.push(
+        "SDD auto reasoning is enabled. Use change_reasoning sparingly when the current task needs a different reasoning level. Use low for simple edits, medium for implementation/review, and high for architecture, planning, multi-agent orchestration, and hard debugging."
+      );
+    },
+  };
+};

package/.sdd/templates/reasoning-profile-template.json

@@ -0,0 +1,25 @@
+{
+  "default": "low",
+  "applyProviderOptions": true,
+  "resetToolOverrideAfterNextRequest": true,
+  "agents": {
+    "general": "medium",
+    "plan": "high",
+    "sdd-orchestrator": "high",
+    "sdd-planner": "high",
+    "sdd-explorer": "low",
+    "sdd-implementer": "medium",
+    "sdd-verifier": "medium",
+    "sdd-reviewer": "medium"
+  },
+  "commands": {
+    "brief": "medium",
+    "research": "medium",
+    "specify": "high",
+    "plan": "high",
+    "tasks": "high",
+    "implement": "medium",
+    "execute-parallel": "high",
+    "audit": "medium"
+  }
+}

package/README.md

@@ -84,6 +84,31 @@ Default profile avoids paid GPT models:
 
 `.opencode/plugins/sdd-model-router.js` reads this file at OpenCode startup and applies the model settings. Restart OpenCode after editing it.
 
+### Auto Reasoning
+
+The installer also creates `.sdd/reasoning-profile.json` and installs `.opencode/plugins/sdd-auto-reasoning.js`.
+
+The plugin reverse-engineers the behavior of `@howaboua/pi-auto-reasoning-tool` for OpenCode:
+- sets reasoning effort automatically per agent and command
+- exposes `change_reasoning` when `@opencode-ai/plugin` is available
+- resets tool overrides after the next model request by default
+
+Default routing:
+
+```json
+{
+  "default": "low",
+  "agents": {
+    "sdd-orchestrator": "high",
+    "sdd-planner": "high",
+    "sdd-implementer": "medium",
+    "sdd-reviewer": "medium"
+  }
+}
+```
+
+Restart OpenCode after editing `.sdd/reasoning-profile.json`.
+
 ### 1. Install (Manual)
 
 #### Option A: Using Commands (Recommended)

package/bin/sdd-opencode.js

@@ -260,6 +260,20 @@ function installSdd(ctx) {
     count++;
   }
 
+  const reasoningProfileDest = path.join(sddDir, "reasoning-profile.json");
+  const reasoningProfileTemplateSrc = path.join(
+    sddDir,
+    "templates",
+    "reasoning-profile-template.json"
+  );
+
+  if (fs.existsSync(reasoningProfileDest) && !ctx.force) {
+    ctx.skipped.push(".sdd/reasoning-profile.json (exists)");
+  } else if (fs.existsSync(reasoningProfileTemplateSrc)) {
+    copyFileSafe(reasoningProfileTemplateSrc, reasoningProfileDest, ctx);
+    count++;
+  }
+
   const specsDir = path.join(ctx.targetRoot, "specs");
   ensureDir(path.join(specsDir, "active"));
   ensureDir(path.join(specsDir, "backlog"));
@@ -303,6 +317,21 @@ function patchOpencodeJson(ctx) {
   if (fs.existsSync(pkgJsonPath)) {
     const pkgConfig = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
 
+    if (Array.isArray(pkgConfig.plugin)) {
+      if (!Array.isArray(targetConfig.plugin)) {
+        targetConfig.plugin = [];
+      }
+
+      for (const pluginEntry of pkgConfig.plugin) {
+        const key = JSON.stringify(pluginEntry);
+        const exists = targetConfig.plugin.some((existing) => JSON.stringify(existing) === key);
+        if (!exists) {
+          targetConfig.plugin.push(pluginEntry);
+          ctx.installed.push(`opencode.json (plugin: ${Array.isArray(pluginEntry) ? pluginEntry[0] : pluginEntry})`);
+        }
+      }
+    }
+
     if (pkgConfig.model) {
       targetConfig.model = pkgConfig.model;
       ctx.installed.push("opencode.json (model patch)");

package/opencode.json

@@ -2,6 +2,10 @@
   "$schema": "https://opencode.ai/config.json",
   "model": "opencode/minimax-m2.5-free",
   "small_model": "opencode/deepseek-v4-flash-free",
+  "plugin": [
+    "./plugins/sdd-model-router.js",
+    "./plugins/sdd-auto-reasoning.js"
+  ],
   "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.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tudeorangbiasa/sdd-multiagent-opencode",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Spec-Driven Development multi-agent workflow for OpenCode",
   "type": "module",
   "bin": {