opencode-conductor-plugin 1.27.0 → 1.28.0

package/dist/index.js

@@ -1,94 +1,206 @@
-import { setupCommand } from "./commands/setup.js";
-import { newTrackCommand } from "./commands/newTrack.js";
-import { implementCommand } from "./commands/implement.js";
-import { statusCommand } from "./commands/status.js";
-import { revertCommand } from "./commands/revert.js";
 import { join, dirname } from "path";
-import { homedir } from "os";
-import { existsSync, readFileSync } from "fs";
+import { existsSync } from "fs";
 import { readFile } from "fs/promises";
 import { fileURLToPath } from "url";
+import { createDelegationTool } from "./tools/delegate.js";
+import { BackgroundManager, createBackgroundTask, createBackgroundOutput, createBackgroundCancel, } from "./tools/background.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const ConductorPlugin = async (ctx) => {
-    // Detect oh-my-opencode for synergy features
-    const configPath = join(homedir(), ".config", "opencode", "opencode.json");
-    let isOMOActive = false;
+const safeRead = async (path) => {
     try {
-        if (existsSync(configPath)) {
-            const config = JSON.parse(readFileSync(configPath, "utf-8"));
-            isOMOActive = config.plugin?.some((p) => p.includes("oh-my-opencode"));
-        }
-    }
-    catch (e) {
-        // Fallback to filesystem check if config read fails
-        const omoPath = join(homedir(), ".config", "opencode", "node_modules", "oh-my-opencode");
-        isOMOActive = existsSync(omoPath);
+        if (existsSync(path))
+            return await readFile(path, "utf-8");
     }
-    console.log(`[Conductor] Plugin tools loaded. (OMO Synergy: ${isOMOActive ? "Enabled" : "Disabled"})`);
-    const extendedCtx = { ...ctx, isOMOActive };
-    return {
-        commands: {
-            setup: setupCommand(extendedCtx),
-            newTrack: newTrackCommand(extendedCtx),
-            implement: implementCommand(extendedCtx),
-            status: statusCommand(extendedCtx),
-            revert: revertCommand(extendedCtx),
-        },
-        "tool.execute.before": async (input, output) => {
-            // INTERCEPT: Sisyphus Delegation Hook
-            // Purpose: Automatically inject the full Conductor context (Plan, Spec, Workflow, Protocol)
-            // whenever the Conductor delegates a task to Sisyphus. This ensures Sisyphus has "Engineering Authority"
-            // without needing the LLM to manually copy-paste huge context blocks.
-            if (input.tool === "delegate_to_agent") {
-                const agentName = (output.args.agent_name || output.args.agent || "").toLowerCase();
-                if (agentName.includes("sisyphus")) {
-                    console.log("[Conductor] Intercepting Sisyphus delegation. Injecting Context Packet...");
+    catch (e) { }
+    return null;
+};
+const ConductorPlugin = async (ctx) => {
+    try {
+        console.log("[Conductor] Initializing plugin...");
+        const backgroundManager = new BackgroundManager(ctx);
+        // 1. Helper to load and process prompt templates (Manual TOML Parsing)
+        const loadPrompt = async (filename, replacements = {}) => {
+            const promptPath = join(__dirname, "prompts", filename);
+            try {
+                const content = await readFile(promptPath, "utf-8");
+                const descMatch = content.match(/description\s*=\s*\"([^\"]+)\"/);
+                const description = descMatch ? descMatch[1] : "Conductor Command";
+                const promptMatch = content.match(/prompt\s*=\s*\"\"\"([\s\S]*?)\"\"\"/);
+                let promptText = promptMatch ? promptMatch[1] : "";
+                if (!promptText)
+                    throw new Error(`Could not parse prompt text from ${filename}`);
+                const defaults = {
+                    templatesDir: join(dirname(__dirname), "templates"),
+                };
+                const finalReplacements = { ...defaults, ...replacements };
+                for (const [key, value] of Object.entries(finalReplacements)) {
+                    promptText = promptText.replaceAll(`{{${key}}}`, value || "");
+                }
+                return { prompt: promptText, description: description };
+            }
+            catch (error) {
+                console.error(`[Conductor] Error loading prompt ${filename}:`, error);
+                return {
+                    prompt: `SYSTEM ERROR: Failed to load prompt ${filename}`,
+                    description: "Error loading command",
+                };
+            }
+        };
+        // 2. Load all Command Prompts (Parallel)
+        const [setup, newTrack, implement, status, revert] = await Promise.all([
+            loadPrompt("setup.toml"),
+            loadPrompt("newTrack.toml", { args: "$ARGUMENTS" }),
+            loadPrompt("implement.toml", {
+                track_name: "$ARGUMENTS",
+            }),
+            loadPrompt("status.toml"),
+            loadPrompt("revert.toml", { target: "$ARGUMENTS" }),
+        ]);
+        // 3. Extract Agent Prompts
+        const [conductorMd, implementerMd] = await Promise.all([
+            readFile(join(__dirname, "prompts", "agent", "conductor.md"), "utf-8"),
+            readFile(join(__dirname, "prompts", "agent", "implementer.md"), "utf-8"),
+        ]);
+        const conductorPrompt = conductorMd.split("---").pop()?.trim() || "";
+        const implementerPrompt = implementerMd.split("---").pop()?.trim() || "";
+        console.log("[Conductor] All components ready. Injecting config...");
+        return {
+            tool: {
+                ...(ctx.client.tool || {}),
+                "conductor_delegate": createDelegationTool(ctx),
+                "conductor_bg_task": createBackgroundTask(backgroundManager),
+                "conductor_bg_output": createBackgroundOutput(backgroundManager),
+                "conductor_bg_cancel": createBackgroundCancel(backgroundManager),
+            },
+            config: async (config) => {
+                if (!config)
+                    return;
+                console.log("[Conductor] config handler: Merging commands and agents...");
+                config.command = {
+                    ...(config.command || {}),
+                    "conductor_setup": {
+                        template: setup.prompt,
+                        description: setup.description,
+                        agent: "conductor",
+                    },
+                    "conductor_newTrack": {
+                        template: newTrack.prompt,
+                        description: newTrack.description,
+                        agent: "conductor",
+                    },
+                    "conductor_implement": {
+                        template: implement.prompt,
+                        description: implement.description,
+                        agent: "conductor_implementer",
+                    },
+                    "conductor_status": {
+                        template: status.prompt,
+                        description: status.description,
+                        agent: "conductor",
+                    },
+                    "conductor_revert": {
+                        template: revert.prompt,
+                        description: revert.description,
+                        agent: "conductor",
+                    },
+                };
+                config.agent = {
+                    ...(config.agent || {}),
+                    conductor: {
+                        description: "Conductor Protocol Steward.",
+                        mode: "primary",
+                        prompt: conductorPrompt,
+                        permission: {
+                            '*': 'allow',
+                            read: {
+                                "*": "allow",
+                                "*.env": "deny",
+                                "*.env.*": "deny",
+                                "*.env.example": "allow",
+                            },
+                            edit: "allow",
+                            bash: "allow",
+                            grep: "allow",
+                            glob: "allow",
+                            list: "allow",
+                            lsp: "allow",
+                            todoread: "allow",
+                            todowrite: "allow",
+                            webfetch: "allow",
+                            external_directory: "deny",
+                            doom_loop: "ask",
+                        },
+                    },
+                    conductor_implementer: {
+                        description: "Conductor Protocol Implementer.",
+                        mode: "primary",
+                        prompt: implementerPrompt,
+                        permission: {
+                            '*': 'allow',
+                            read: {
+                                "*": "allow",
+                                "*.env": "deny",
+                                "*.env.*": "deny",
+                                "*.env.example": "allow",
+                            },
+                            edit: "allow",
+                            bash: "allow",
+                            grep: "allow",
+                            glob: "allow",
+                            list: "allow",
+                            lsp: "allow",
+                            todoread: "allow",
+                            todowrite: "allow",
+                            webfetch: "allow",
+                            "conductor_delegate": "allow",
+                            "conductor_bg_task": "allow",
+                            "conductor_bg_output": "allow",
+                            "conductor_bg_cancel": "allow",
+                            external_directory: "deny",
+                            doom_loop: "ask",
+                        },
+                    },
+                };
+            },
+            "tool.execute.before": async (input, output) => {
+                const delegationTools = [
+                    "delegate_to_agent",
+                    "task",
+                    "background_task",
+                    "conductor_delegate",
+                    "conductor_bg_task",
+                ];
+                if (delegationTools.includes(input.tool)) {
                     const conductorDir = join(ctx.directory, "conductor");
-                    const promptsDir = join(__dirname, "prompts");
-                    // Helper to safely read file content
-                    const safeRead = async (path) => {
-                        try {
-                            if (existsSync(path))
-                                return await readFile(path, "utf-8");
-                        }
-                        catch (e) { /* ignore */ }
-                        return null;
-                    };
-                    // 1. Read Project Context Files
-                    // We need to find the active track to get the correct spec/plan.
-                    // Since we don't know the track ID easily here, we look for the 'plan.md' that might be in the args
-                    // OR we just rely on the Conductor having already done the setup. 
-                    // WAIT: We can't easily guess the track ID here. 
-                    // BETTER APPROACH: We rely on the generic 'conductor/workflow.md' and 'prompts/implement.toml'.
-                    // For 'spec.md' and 'plan.md', the Conductor usually puts the path in the message. 
-                    // However, to be robust, we will read the GLOBAL workflow and the IMPLEMENT prompt.
-                    // We will explicitly inject the IMPLEMENT PROMPT as requested.
-                    const implementToml = await safeRead(join(promptsDir, "definitions", "implement.toml"));
                     const workflowMd = await safeRead(join(conductorDir, "workflow.md"));
-                    // Construct the injection block
-                    let injection = "\n\n--- [SYSTEM INJECTION: CONDUCTOR CONTEXT PACKET] ---\n";
-                    injection += "You are receiving this task from the Conductor Architect.\n";
-                    if (implementToml) {
-                        injection += "\n### 1. ARCHITECTURAL PROTOCOL (Reference Only)\n";
-                        injection += "Use this protocol to understand the project's rigorous standards. DO NOT restart the project management lifecycle (e.g. track selection).\n";
-                        injection += "```toml\n" + implementToml + "\n```\n";
-                    }
                     if (workflowMd) {
-                        injection += "\n### 2. DEVELOPMENT WORKFLOW\n";
-                        injection += "Follow these TDD and Commit rules precisely.\n";
-                        injection += "```markdown\n" + workflowMd + "\n```\n";
+                        let injection = "\n\n--- [SYSTEM INJECTION: CONDUCTOR CONTEXT PACKET] ---\n";
+                        injection += "You are receiving this task from the Conductor.\n";
+                        injection += "You MUST adhere to the following project workflow rules:\n";
+                        injection += "\n### DEVELOPMENT WORKFLOW\n" + workflowMd + "\n";
+                        if (implement?.prompt) {
+                            injection += "\n### IMPLEMENTATION PROTOCOL\n" + implement.prompt + "\n";
+                        }
+                        injection += "\n### DELEGATED AUTHORITY\n- **EXECUTE:** Implement the requested task.\n- **REFINE:** You have authority to update `plan.md` and `spec.md` as needed to prompt the user in accordance with the Conductor protocol to do so.\n";
+                        injection += "--- [END INJECTION] ---\n";
+                        // Inject into the primary instruction field depending on the tool's schema
+                        if (output.args && typeof output.args.objective === "string") {
+                            output.args.objective += injection;
+                        }
+                        else if (output.args && typeof output.args.prompt === "string") {
+                            output.args.prompt += injection;
+                        }
+                        else if (output.args && typeof output.args.instruction === "string") {
+                            output.args.instruction += injection;
+                        }
                     }
-                    injection += "\n### 3. DELEGATED AUTHORITY\n";
-                    injection += "- **EXECUTE:** Implement the requested task using the Workflow.\n";
-                    injection += "- **REFINE:** You have authority to update `plan.md` if it is flawed.\n";
-                    injection += "- **ESCALATE:** If you modify the Plan or Spec, report 'PLAN_UPDATED' immediately.\n";
-                    injection += "--- [END INJECTION] ---\n";
-                    // Append to the objective
-                    output.args.objective += injection;
                 }
-            }
-        }
-    };
+            },
+        };
+    }
+    catch (err) {
+        console.error("[Conductor] FATAL: Plugin initialization failed:", err);
+        throw err;
+    }
 };
 export default ConductorPlugin;

package/dist/tools/commands.js

@@ -6,12 +6,12 @@ import { readFile } from "fs/promises";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export const setupCommand = createConductorCommand({
-    name: "legacy/conductor/commands/conductor/setup.toml",
+    name: "setup.toml",
     description: "Directives lookup tool for scaffolding the project and setting up the Conductor environment",
     args: {},
 });
 export const newTrackCommand = createConductorCommand({
-    name: "legacy/conductor/commands/conductor/newTrack.toml",
+    name: "newTrack.toml",
     description: "Directives lookup tool for planning a track, generating track-specific spec documents and updating the tracks file",
     args: {
         description: tool.schema.string().optional().describe("Brief description of the track (feature, bug fix, chore, etc.)"),
@@ -23,7 +23,7 @@ export const newTrackCommand = createConductorCommand({
     },
 });
 export const implementCommand = createConductorCommand({
-    name: "legacy/conductor/commands/conductor/implement.toml",
+    name: "implement.toml",
     description: "Directives lookup tool for executing the tasks defined in the specified track's plan",
     args: {
         track_name: tool.schema.string().optional().describe("Name or description of the track to implement"),
@@ -47,12 +47,12 @@ export const implementCommand = createConductorCommand({
     },
 });
 export const statusCommand = createConductorCommand({
-    name: "legacy/conductor/commands/conductor/status.toml",
+    name: "status.toml",
     description: "Directives lookup tool for displaying the current progress of the project",
     args: {},
 });
 export const revertCommand = createConductorCommand({
-    name: "legacy/conductor/commands/conductor/revert.toml",
+    name: "revert.toml",
     description: "Directives lookup tool for reverting previous work",
     args: {
         target: tool.schema.string().optional().describe("Target to revert (e.g., 'track <track_id>', 'phase <phase_name>', 'task <task_name>')"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-conductor-plugin",
-  "version": "1.27.0",
+  "version": "1.28.0",
   "description": "Conductor plugin for OpenCode",
   "type": "module",
   "repository": "derekbar90/opencode-conductor",
@@ -31,9 +31,10 @@
     "test": "vitest run",
     "postinstall": "node scripts/postinstall.cjs",
     "build": "tsc && npm run copy-prompts && npm run copy-templates",
-    "copy-prompts": "mkdir -p dist/prompts && cp src/prompts/*.md dist/prompts/ && mkdir -p dist/prompts/agent && cp src/prompts/agent/*.md dist/prompts/agent/ && mkdir -p dist/prompts/strategies && cp src/prompts/strategies/*.md dist/prompts/strategies/ && mkdir -p dist/prompts/legacy/conductor/commands/conductor && cp legacy/conductor/commands/conductor/*.toml dist/prompts/legacy/conductor/commands/conductor/",
+    "copy-prompts": "mkdir -p dist/prompts && cp src/prompts/*.md dist/prompts/ && cp legacy/conductor/commands/conductor/*.toml dist/prompts/ && mkdir -p dist/prompts/agent && cp src/prompts/agent/*.md dist/prompts/agent/ && mkdir -p dist/prompts/strategies && cp src/prompts/strategies/*.md dist/prompts/strategies/",
     "copy-templates": "mkdir -p dist/templates && cp -r src/templates/* dist/templates/",
-    "prepublishOnly": "npm run build"
+    "update-submodule": "git submodule update --init --recursive --remote",
+    "prepublishOnly": "npm run update-submodule && npm run build"
   },
   "dependencies": {
     "@opencode-ai/plugin": "^1.0.209",

package/dist/commands/newTrack.d.ts

@@ -1 +0,0 @@
-export declare const newTrackCommand: (ctx: import("@opencode-ai/plugin").PluginInput) => import("@opencode-ai/plugin/tool").ToolDefinition;

package/dist/commands/newTrack.js

@@ -1,12 +0,0 @@
-import { tool } from "@opencode-ai/plugin/tool";
-import { createConductorCommand } from "../utils/commandFactory.js";
-export const newTrackCommand = createConductorCommand({
-    name: "legacy/conductor/commands/conductor/newTrack.toml",
-    description: "Creates a new Development Track (feature/bug/chore) with proper scaffolding.",
-    args: {
-        description: tool.schema.string().optional().describe("Brief description of the track."),
-    },
-    additionalContext: async (_, args) => ({
-        args: args.description || ""
-    })
-});

package/dist/commands/revert.d.ts

@@ -1 +0,0 @@
-export declare const revertCommand: (ctx: import("@opencode-ai/plugin").PluginInput) => import("@opencode-ai/plugin/tool").ToolDefinition;

package/dist/commands/revert.js

@@ -1,14 +0,0 @@
-import { createConductorCommand } from "../utils/commandFactory.js";
-import { tool } from "@opencode-ai/plugin/tool";
-export const revertCommand = createConductorCommand({
-    name: "legacy/conductor/commands/conductor/revert.toml",
-    description: "Reverts the last commit in the current track and updates the plan.",
-    args: {
-        target: tool.schema.string().optional().describe("ID or description of what to revert."),
-    },
-    additionalContext: async (ctx, args) => {
-        return {
-            target: args.target || "",
-        };
-    },
-});

package/dist/commands/setup.d.ts

@@ -1 +0,0 @@
-export declare const setupCommand: (ctx: import("@opencode-ai/plugin").PluginInput) => import("@opencode-ai/plugin/tool").ToolDefinition;

package/dist/commands/setup.js

@@ -1,10 +0,0 @@
-import { tool } from "@opencode-ai/plugin/tool";
-import { createConductorCommand } from "../utils/commandFactory.js";
-export const setupCommand = createConductorCommand({
-    name: "legacy/conductor/commands/conductor/setup.toml",
-    description: "Initializes the Conductor in the current project, creating necessary directories and the workflow file.",
-    args: {
-        user_input: tool.schema.string().optional().describe("The user's response to a previous question, if applicable."),
-    },
-    requiresSetup: false // Setup command is what creates the setup
-});

package/dist/commands/status.d.ts

@@ -1 +0,0 @@
-export declare const statusCommand: (ctx: import("@opencode-ai/plugin").PluginInput) => import("@opencode-ai/plugin/tool").ToolDefinition;

package/dist/commands/status.js

@@ -1,6 +0,0 @@
-import { createConductorCommand } from "../utils/commandFactory.js";
-export const statusCommand = createConductorCommand({
-    name: "legacy/conductor/commands/conductor/status.toml",
-    description: "Displays the current Conductor status, active tracks, and project health.",
-    args: {}
-});