@hyperdrive.bot/bmad-workflow 1.0.9 → 1.0.10

package/dist/commands/decompose.js

@@ -147,6 +147,7 @@ export default class Decompose extends Command {
                 filePattern: flags['file-pattern'],
                 goal: args.goal,
                 maxParallel: flags['max-parallel'],
+                model: flags.model,
                 perFile: flags['per-file'],
                 planOnly: flags['plan-only'],
                 storyFormat: flags['story-format'],

package/dist/models/provider.js

@@ -18,7 +18,7 @@ export const PROVIDER_CONFIGS = {
         supportsFileReferences: false,
     },
     opencode: {
-        command: 'opencode',
+        command: process.env.HOME + '/.opencode/bin/opencode',
         flags: ['run', '--format', 'json'],
         modelFlag: '--model',
         supportsFileReferences: true,

package/dist/services/agents/opencode-agent-runner.js

@@ -155,11 +155,11 @@ export class OpenCodeAgentRunner {
             tempDir = await mkdtemp(join(tmpdir(), 'opencode-prompt-'));
             tempFile = join(tempDir, 'prompt.txt');
             await writeFile(tempFile, prompt, 'utf8');
-            // Build command with --file flag (Open Code specific)
-            // Format: opencode run --format json [--model provider/model] --file "${tempFile}"
+            // Build command - use stdin to pass the prompt (handles newlines better)
+            // Format: cat tempfile | opencode run --format json [--model provider/model] -
             const flags = this.config.flags.join(' ');
             const modelArg = options.model ? `${this.config.modelFlag} ${options.model}` : '';
-            const command = `${this.config.command} ${flags} ${modelArg} --file "${tempFile}"`.replace(/\s+/g, ' ').trim();
+            const command = `cat "${tempFile}" | ${this.config.command} ${flags} ${modelArg} -`.replace(/\s+/g, ' ').trim();
             // Log the command being executed
             this.logger.info({
                 command,
@@ -264,47 +264,65 @@ export class OpenCodeAgentRunner {
         if (!stdoutData || stdoutData.trim().length === 0) {
             return '';
         }
-        try {
-            const parsed = JSON.parse(stdoutData);
-            // Try common JSON response structures
-            // Open Code may output different structures depending on version
-            if (typeof parsed === 'string') {
-                return parsed;
-            }
-            if (parsed.content) {
-                return String(parsed.content);
-            }
-            if (parsed.message) {
-                return String(parsed.message);
-            }
-            if (parsed.response) {
-                return String(parsed.response);
-            }
-            if (parsed.output) {
-                return String(parsed.output);
-            }
-            if (parsed.text) {
-                return String(parsed.text);
-            }
-            // If we have a result array, try to extract content
-            if (Array.isArray(parsed)) {
-                const messages = parsed
-                    .filter((item) => item.type === 'message' || item.content || item.text)
-                    .map((item) => item.content || item.text || item.message || '')
-                    .filter(Boolean);
-                if (messages.length > 0) {
-                    return messages.join('\n');
+        // Open Code outputs NDJSON (newline-delimited JSON)
+        // Each line is a separate JSON object: step_start, text, step_finish
+        // We need to extract the "text" from entries with type="text"
+        const lines = stdoutData.trim().split('\n');
+        const textParts = [];
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                // Handle JSON string (like "Just a string")
+                if (typeof parsed === 'string') {
+                    textParts.push(parsed);
+                    continue;
                 }
+                // Handle JSON array
+                if (Array.isArray(parsed)) {
+                    for (const item of parsed) {
+                        if (item.content)
+                            textParts.push(item.content);
+                        else if (item.text)
+                            textParts.push(item.text);
+                        else if (item.message)
+                            textParts.push(item.message);
+                    }
+                    continue;
+                }
+                // Extract text from "text" type entries (Open Code NDJSON format)
+                if (parsed.type === 'text' && parsed.part?.text) {
+                    textParts.push(parsed.part.text);
+                }
+                else if (parsed.text) {
+                    textParts.push(parsed.text);
+                }
+                else if (parsed.content) {
+                    textParts.push(parsed.content);
+                }
+                else if (parsed.message) {
+                    textParts.push(parsed.message);
+                }
+                else if (parsed.response) {
+                    textParts.push(parsed.response);
+                }
+                else if (parsed.output) {
+                    textParts.push(parsed.output);
+                }
+            }
+            catch {
+                // If line isn't valid JSON, it might be plain text output
+                this.logger.debug({ lineLength: line.length }, 'Line is not JSON, treating as plain text');
+                textParts.push(line);
             }
-            // Fallback: stringify the parsed object
-            this.logger.debug({ parsedKeys: Object.keys(parsed) }, 'Unknown JSON structure, returning stringified');
-            return JSON.stringify(parsed, null, 2);
         }
-        catch {
-            // JSON parsing failed, return raw output
-            this.logger.debug({ stdoutLength: stdoutData.length }, 'JSON parsing failed, returning raw output');
-            return stdoutData;
+        if (textParts.length > 0) {
+            return textParts.join('\n');
         }
+        // Fallback: return raw output
+        this.logger.debug({ stdoutLength: stdoutData.length }, 'No text extracted, returning raw output');
+        return stdoutData;
     }
     /**
      * Build detailed error context for debugging process failures

package/dist/services/orchestration/task-decomposition-service.js

@@ -41,6 +41,7 @@ export class TaskDecompositionService {
         // Execute Claude agent to generate task graph
         const result = await this.agentRunner.runAgent(prompt, {
             agentType: (options.agent ?? 'architect'),
+            model: options.model,
             references: options.contextFiles,
             timeout: options.taskTimeout ?? 600_000, // 10 min default for planning
         });

package/dist/types/task-graph.d.ts

@@ -119,6 +119,8 @@ export interface DecomposeOptions {
     goal: string;
     /** Maximum number of tasks to run in parallel */
     maxParallel?: number;
+    /** Model to use for AI provider */
+    model?: string;
     /** Enable per-file task generation for file-heavy operations */
     perFile?: boolean;
     /** Plan only without executing */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hyperdrive.bot/bmad-workflow",
   "description": "AI-driven development workflow orchestration CLI for BMAD projects",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "author": {
     "name": "DevSquad",
     "email": "marcelo@devsquad.email",