opencode-conductor-plugin 1.21.1 → 1.22.1

package/dist/index.js

@@ -4,6 +4,7 @@ import { readFile } from "fs/promises";
 import { fileURLToPath } from "url";
 import { createDelegationTool } from "./tools/delegate.js";
 import { BackgroundManager, createBackgroundTask, createBackgroundOutput, createBackgroundCancel, } from "./tools/background.js";
+import { createSetupTool, createNewTrackTool, createImplementTool, createStatusTool, createRevertTool, } from "./tools/commands.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const safeRead = async (path) => {
@@ -72,6 +73,11 @@ const ConductorPlugin = async (ctx) => {
                 "conductor_bg_task": createBackgroundTask(backgroundManager),
                 "conductor_bg_output": createBackgroundOutput(backgroundManager),
                 "conductor_bg_cancel": createBackgroundCancel(backgroundManager),
+                "conductor_setup": createSetupTool(ctx),
+                "conductor_newTrack": createNewTrackTool(ctx),
+                "conductor_implement": createImplementTool(ctx),
+                "conductor_status": createStatusTool(ctx),
+                "conductor_revert": createRevertTool(ctx),
             },
             config: async (config) => {
                 if (!config)
@@ -80,27 +86,27 @@ const ConductorPlugin = async (ctx) => {
                 config.command = {
                     ...(config.command || {}),
                     "conductor_setup": {
-                        template: setup.prompt,
+                        template: "Use the conductor_setup tool to scaffold the project and set up the Conductor environment. After calling the tool, you MUST follow all instructions provided in the tool's response exactly as specified.",
                         description: setup.description,
                         agent: "conductor",
                     },
                     "conductor_newTrack": {
-                        template: newTrack.prompt,
+                        template: "Use the conductor_newTrack tool to plan a track and generate track-specific spec documents. If arguments were provided with this command, pass them as the 'description' parameter to the tool. After calling the tool, you MUST follow all instructions provided in the tool's response exactly as specified.",
                         description: newTrack.description,
                         agent: "conductor",
                     },
                     "conductor_implement": {
-                        template: implement.prompt,
+                        template: "Use the conductor_implement tool to execute the tasks defined in the specified track's plan. If a track name was provided as an argument with this command, pass it as the 'track_name' parameter to the tool. After calling the tool, you MUST follow all instructions provided in the tool's response exactly as specified.",
                         description: implement.description,
                         agent: "conductor_implementer",
                     },
                     "conductor_status": {
-                        template: status.prompt,
+                        template: "Use the conductor_status tool to display the current progress of the project. After calling the tool, you MUST follow all instructions provided in the tool's response exactly as specified.",
                         description: status.description,
                         agent: "conductor",
                     },
                     "conductor_revert": {
-                        template: revert.prompt,
+                        template: "Use the conductor_revert tool to revert previous work. If a target was provided as an argument with this command (e.g., 'track <track_id>', 'phase <phase_name>', 'task <task_name>'), pass it as the 'target' parameter to the tool. After calling the tool, you MUST follow all instructions provided in the tool's response exactly as specified.",
                         description: revert.description,
                         agent: "conductor",
                     },
@@ -127,6 +133,11 @@ const ConductorPlugin = async (ctx) => {
                             todoread: "allow",
                             todowrite: "allow",
                             webfetch: "allow",
+                            "conductor_setup": "allow",
+                            "conductor_newTrack": "allow",
+                            "conductor_implement": "allow",
+                            "conductor_status": "allow",
+                            "conductor_revert": "allow",
                             external_directory: "deny",
                             doom_loop: "ask",
                         },
@@ -155,6 +166,11 @@ const ConductorPlugin = async (ctx) => {
                             "conductor_bg_task": "allow",
                             "conductor_bg_output": "allow",
                             "conductor_bg_cancel": "allow",
+                            "conductor_setup": "allow",
+                            "conductor_newTrack": "allow",
+                            "conductor_implement": "allow",
+                            "conductor_status": "allow",
+                            "conductor_revert": "allow",
                             external_directory: "deny",
                             doom_loop: "ask",
                         },

package/dist/tools/commands.d.ts

@@ -0,0 +1,7 @@
+import { type PluginInput } from "@opencode-ai/plugin";
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+export declare function createSetupTool(ctx: PluginInput): ToolDefinition;
+export declare function createNewTrackTool(ctx: PluginInput): ToolDefinition;
+export declare function createImplementTool(ctx: PluginInput): ToolDefinition;
+export declare function createStatusTool(ctx: PluginInput): ToolDefinition;
+export declare function createRevertTool(ctx: PluginInput): ToolDefinition;

package/dist/tools/commands.js

@@ -0,0 +1,132 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { join, dirname } from "path";
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Helper to load and process prompt templates
+async function loadPrompt(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(__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",
+        };
+    }
+}
+// Helper to execute a command prompt in a sub-session
+async function executeCommand(ctx, toolContext, promptText, agent, description) {
+    // Create a sub-session linked to the current one
+    const createResult = await ctx.client.session.create({
+        body: {
+            parentID: toolContext.sessionID,
+            title: description,
+        },
+    });
+    if (createResult.error)
+        return `Error: ${createResult.error}`;
+    const sessionID = createResult.data.id;
+    // Send the prompt to the agent
+    await ctx.client.session.prompt({
+        path: { id: sessionID },
+        body: {
+            agent: agent,
+            parts: [{ type: "text", text: promptText }],
+        },
+    });
+    // Fetch and return the assistant's response
+    const messagesResult = await ctx.client.session.messages({
+        path: { id: sessionID },
+    });
+    const lastMessage = messagesResult.data
+        ?.filter((m) => m.info.role === "assistant")
+        .pop();
+    const responseText = lastMessage?.parts
+        ?.filter((p) => p.type === "text")
+        .map((p) => p.text)
+        .join("\n") || "No response.";
+    return `${responseText}\n\n<task_metadata>\nsession_id: ${sessionID}\n</task_metadata>`;
+}
+export function createSetupTool(ctx) {
+    return tool({
+        description: "Scaffolds the project and sets up the Conductor environment",
+        args: {},
+        async execute(args, toolContext) {
+            const { prompt, description } = await loadPrompt("setup.toml");
+            return await executeCommand(ctx, toolContext, prompt, "conductor", description);
+        },
+    });
+}
+export function createNewTrackTool(ctx) {
+    return tool({
+        description: "Plans a track, generates track-specific spec documents and updates the tracks file",
+        args: {
+            description: tool.schema.string().optional().describe("Brief description of the track (feature, bug fix, chore, etc.)"),
+        },
+        async execute(args, toolContext) {
+            const trackDescription = args.description || "";
+            const { prompt, description } = await loadPrompt("newTrack.toml", {
+                args: trackDescription,
+            });
+            return await executeCommand(ctx, toolContext, prompt, "conductor", description);
+        },
+    });
+}
+export function createImplementTool(ctx) {
+    return tool({
+        description: "Executes 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"),
+        },
+        async execute(args, toolContext) {
+            const trackName = args.track_name || "";
+            const { prompt, description } = await loadPrompt("implement.toml", {
+                track_name: trackName,
+            });
+            return await executeCommand(ctx, toolContext, prompt, "conductor_implementer", description);
+        },
+    });
+}
+export function createStatusTool(ctx) {
+    return tool({
+        description: "Displays the current progress of the project",
+        args: {},
+        async execute(args, toolContext) {
+            const { prompt, description } = await loadPrompt("status.toml");
+            return await executeCommand(ctx, toolContext, prompt, "conductor", description);
+        },
+    });
+}
+export function createRevertTool(ctx) {
+    return tool({
+        description: "Reverts previous work",
+        args: {
+            target: tool.schema.string().optional().describe("Target to revert (e.g., 'track <track_id>', 'phase <phase_name>', 'task <task_name>')"),
+        },
+        async execute(args, toolContext) {
+            const target = args.target || "";
+            const { prompt, description } = await loadPrompt("revert.toml", {
+                target: target,
+            });
+            return await executeCommand(ctx, toolContext, prompt, "conductor", description);
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-conductor-plugin",
-  "version": "1.21.1",
+  "version": "1.22.1",
   "description": "Conductor plugin for OpenCode",
   "type": "module",
   "repository": "derekbar90/opencode-conductor",