opencode-conductor-plugin 1.23.0 → 1.24.0

package/dist/tools/commands.d.ts

@@ -1,7 +1,11 @@
-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;
+export declare const setupCommand: (ctx: import("@opencode-ai/plugin").PluginInput) => ToolDefinition;
+export declare const newTrackCommand: (ctx: import("@opencode-ai/plugin").PluginInput) => ToolDefinition;
+export declare const implementCommand: (ctx: import("@opencode-ai/plugin").PluginInput) => ToolDefinition;
+export declare const statusCommand: (ctx: import("@opencode-ai/plugin").PluginInput) => ToolDefinition;
+export declare const revertCommand: (ctx: import("@opencode-ai/plugin").PluginInput) => ToolDefinition;
+export declare function createSetupTool(ctx: any): ToolDefinition;
+export declare function createNewTrackTool(ctx: any): ToolDefinition;
+export declare function createImplementTool(ctx: any): ToolDefinition;
+export declare function createStatusTool(ctx: any): ToolDefinition;
+export declare function createRevertTool(ctx: any): ToolDefinition;

package/dist/tools/commands.js

@@ -1,99 +1,81 @@
 import { tool } from "@opencode-ai/plugin/tool";
+import { createConductorCommand } from "../utils/commandFactory.js";
 import { join, dirname } from "path";
-import { readFile } from "fs/promises";
 import { fileURLToPath } from "url";
+import { readFile } from "fs/promises";
 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"),
+export const setupCommand = createConductorCommand({
+    name: "setup.toml",
+    description: "Scaffolds the project and sets up the Conductor environment",
+    args: {},
+});
+export const newTrackCommand = createConductorCommand({
+    name: "newTrack.toml",
+    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.)"),
+    },
+    additionalContext: async (ctx, args) => {
+        return {
+            args: args.description || "",
         };
-        const finalReplacements = { ...defaults, ...replacements };
-        for (const [key, value] of Object.entries(finalReplacements)) {
-            promptText = promptText.replaceAll(`{{${key}}}`, value || "");
+    },
+});
+export const implementCommand = createConductorCommand({
+    name: "implement.toml",
+    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"),
+    },
+    additionalContext: async (ctx, args) => {
+        // 1. Choose strategy based on OMO activity
+        const strategyFile = ctx.isOMOActive ? "delegate.md" : "manual.md";
+        const strategyPath = join(__dirname, "../prompts/strategies", strategyFile);
+        let strategySection = "";
+        try {
+            strategySection = await readFile(strategyPath, "utf-8");
+        }
+        catch (e) {
+            console.warn(`[Conductor] Failed to load strategy ${strategyFile}:`, e);
+            strategySection = "Error: Could not load execution strategy.";
         }
-        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",
+            strategy_section: strategySection,
+            track_name: args.track_name || "",
         };
-    }
-}
+    },
+});
+export const statusCommand = createConductorCommand({
+    name: "status.toml",
+    description: "Displays the current progress of the project",
+    args: {},
+});
+export const revertCommand = createConductorCommand({
+    name: "revert.toml",
+    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>')"),
+    },
+    additionalContext: async (ctx, args) => {
+        return {
+            target: args.target || "",
+        };
+    },
+});
+// Export as functions for backward compatibility
 export function createSetupTool(ctx) {
-    return tool({
-        description: "Scaffolds the project and sets up the Conductor environment",
-        args: {},
-        async execute(args) {
-            const { prompt } = await loadPrompt("setup.toml");
-            return prompt;
-        },
-    });
+    return setupCommand(ctx);
 }
 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) {
-            const trackDescription = args.description || "";
-            const { prompt } = await loadPrompt("newTrack.toml", {
-                args: trackDescription,
-            });
-            return prompt;
-        },
-    });
+    return newTrackCommand(ctx);
 }
 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) {
-            const trackName = args.track_name || "";
-            const { prompt } = await loadPrompt("implement.toml", {
-                track_name: trackName,
-            });
-            return prompt;
-        },
-    });
+    return implementCommand(ctx);
 }
 export function createStatusTool(ctx) {
-    return tool({
-        description: "Displays the current progress of the project",
-        args: {},
-        async execute(args) {
-            const { prompt } = await loadPrompt("status.toml");
-            return prompt;
-        },
-    });
+    return statusCommand(ctx);
 }
 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) {
-            const target = args.target || "";
-            const { prompt } = await loadPrompt("revert.toml", {
-                target: target,
-            });
-            return prompt;
-        },
-    });
+    return revertCommand(ctx);
 }

package/dist/utils/commandFactory.d.ts

@@ -0,0 +1,10 @@
+import { type PluginInput } from "@opencode-ai/plugin";
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+interface ConductorCommandConfig {
+    name: string;
+    description: string;
+    args: Record<string, any>;
+    additionalContext?: (ctx: PluginInput, args: any) => Promise<Record<string, string>>;
+}
+export declare function createConductorCommand(config: ConductorCommandConfig): (ctx: PluginInput) => ToolDefinition;
+export {};

package/dist/utils/commandFactory.js

@@ -0,0 +1,53 @@
+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",
+        };
+    }
+}
+export function createConductorCommand(config) {
+    return (ctx) => {
+        return tool({
+            description: config.description,
+            args: config.args,
+            async execute(args) {
+                // Get additional context if provided (this can override/extend args)
+                const additionalContext = config.additionalContext
+                    ? await config.additionalContext(ctx, args)
+                    : {};
+                // Merge additionalContext into replacements
+                // additionalContext takes precedence and can provide custom mappings
+                const replacements = { ...additionalContext };
+                const { prompt } = await loadPrompt(config.name, replacements);
+                return prompt;
+            },
+        });
+    };
+}

package/package.json

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