opencode-conductor-plugin 1.25.0 → 1.26.0

package/dist/commands/implement.d.ts

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

package/dist/commands/newTrack.d.ts

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

package/dist/commands/revert.d.ts

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

package/dist/commands/setup.d.ts

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

package/dist/commands/status.d.ts

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

package/dist/tools/commands.d.ts

@@ -1,9 +1,9 @@
 import { type ToolDefinition } from "@opencode-ai/plugin/tool";
-export declare const setupCommand: (ctx: any) => ToolDefinition;
-export declare const newTrackCommand: (ctx: any) => ToolDefinition;
-export declare const implementCommand: (ctx: any) => ToolDefinition;
-export declare const statusCommand: (ctx: any) => ToolDefinition;
-export declare const revertCommand: (ctx: any) => 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;

package/dist/tools/commands.js

@@ -7,13 +7,12 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export const setupCommand = createConductorCommand({
     name: "setup.toml",
-    description: "Scaffolds the project and sets up the Conductor environment",
-    requiresSetup: false,
+    description: "Directives lookup tool for scaffolding the project and setting 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",
+    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.)"),
     },
@@ -25,7 +24,7 @@ export const newTrackCommand = createConductorCommand({
 });
 export const implementCommand = createConductorCommand({
     name: "implement.toml",
-    description: "Executes the tasks defined in the specified track's plan",
+    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"),
     },
@@ -49,12 +48,12 @@ export const implementCommand = createConductorCommand({
 });
 export const statusCommand = createConductorCommand({
     name: "status.toml",
-    description: "Displays the current progress of the project",
+    description: "Directives lookup tool for displaying the current progress of the project",
     args: {},
 });
 export const revertCommand = createConductorCommand({
     name: "revert.toml",
-    description: "Reverts previous work",
+    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/dist/tools/commands.test.js

@@ -1,15 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { createSetupTool, createNewTrackTool, createImplementTool, createStatusTool, createRevertTool, } from "./commands.js";
 import { readFile } from "fs/promises";
-import { existsSync } from "fs";
 // Mock fs/promises
 vi.mock("fs/promises", () => ({
     readFile: vi.fn(),
 }));
-// Mock fs
-vi.mock("fs", () => ({
-    existsSync: vi.fn(),
-}));
 describe("Command Tools", () => {
     let mockCtx;
     let mockToolContext;
@@ -20,132 +15,131 @@ describe("Command Tools", () => {
             isOMOActive: false,
         };
         mockToolContext = {
-            sessionID: "test-session-id",
-            messageID: "test-message-id",
+            sessionID: "test-session",
+            messageID: "test-message",
         };
-        // Default mocks
+        // Default mocks - must use triple quotes for the regex in commandFactory
         vi.mocked(readFile).mockResolvedValue(`
 description = "Test command"
 prompt = """
 Test prompt content
 """
 `);
-        vi.mocked(existsSync).mockReturnValue(true); // Assume setup exists by default
     });
     describe("createSetupTool", () => {
         it("should create a tool with correct description", () => {
             const tool = createSetupTool(mockCtx);
-            expect(tool.description).toBe("Scaffolds the project and sets up the Conductor environment");
-        });
-        it("should return prompt text when executed", async () => {
-            vi.mocked(readFile).mockResolvedValue(`
-description = "Setup"
-prompt = "Setup Prompt"
-`);
-            const tool = createSetupTool(mockCtx);
-            const result = await tool.execute({}, mockToolContext);
-            expect(result).toBe("Setup Prompt");
+            expect(tool.description).toBe("Directives lookup tool for scaffolding the project and setting up the Conductor environment");
         });
-        it("should NOT require setup to exist", async () => {
-            vi.mocked(existsSync).mockReturnValue(false);
+        it("should return directives JSON string when executed", async () => {
             vi.mocked(readFile).mockResolvedValue(`
 description = "Setup"
-prompt = "Setup Prompt"
+prompt = """Setup Prompt"""
 `);
             const tool = createSetupTool(mockCtx);
             const result = await tool.execute({}, mockToolContext);
-            expect(result).toBe("Setup Prompt");
+            expect(JSON.parse(result)).toEqual({ directives: "Setup Prompt" });
         });
     });
     describe("createNewTrackTool", () => {
+        it("should create a tool with correct description", () => {
+            const tool = createNewTrackTool(mockCtx);
+            expect(tool.description).toBe("Directives lookup tool for planning a track, generating track-specific spec documents and updating the tracks file");
+        });
         it("should have optional description argument", () => {
             const tool = createNewTrackTool(mockCtx);
             expect(tool.args).toHaveProperty("description");
         });
-        it("should replace description in prompt", async () => {
+        it("should replace description in directives", async () => {
             vi.mocked(readFile).mockResolvedValue(`
 description = "New Track"
-prompt = "Track description: {{args}}"
+prompt = """Track description: {{args}}"""
 `);
             const tool = createNewTrackTool(mockCtx);
             const result = await tool.execute({ description: "Login feature" }, mockToolContext);
-            expect(result).toBe("Track description: Login feature");
-        });
-        it("should return error if not set up", async () => {
-            vi.mocked(existsSync).mockReturnValue(false);
-            const tool = createNewTrackTool(mockCtx);
-            const result = await tool.execute({}, mockToolContext);
-            expect(result).toContain("Conductor is not set up");
+            expect(JSON.parse(result)).toEqual({ directives: "Track description: Login feature" });
         });
     });
     describe("createImplementTool", () => {
+        it("should create a tool with correct description", () => {
+            const tool = createImplementTool(mockCtx);
+            expect(tool.description).toBe("Directives lookup tool for executing the tasks defined in the specified track's plan");
+        });
         it("should have optional track_name argument", () => {
             const tool = createImplementTool(mockCtx);
             expect(tool.args).toHaveProperty("track_name");
         });
-        it("should replace track_name in prompt", async () => {
+        it("should replace track_name in directives", async () => {
             vi.mocked(readFile).mockResolvedValue(`
 description = "Implement"
-prompt = "Track: {{track_name}}"
+prompt = """Track: {{track_name}}"""
 `);
             const tool = createImplementTool(mockCtx);
             const result = await tool.execute({ track_name: "auth-track" }, mockToolContext);
-            expect(result).toBe("Track: auth-track");
+            expect(JSON.parse(result)).toEqual({ directives: "Track: auth-track" });
         });
-        it("should include strategy section", async () => {
+        it("should include strategy section in directives", async () => {
             vi.mocked(readFile).mockImplementation(async (path) => {
                 if (typeof path === 'string' && path.endsWith("manual.md")) {
                     return "Manual Strategy";
                 }
                 return `
 description = "Implement"
-prompt = "Strategy: {{strategy_section}}"
+prompt = """Strategy: {{strategy_section}}"""
 `;
             });
             const tool = createImplementTool(mockCtx);
             const result = await tool.execute({}, mockToolContext);
-            expect(result).toBe("Strategy: Manual Strategy");
+            expect(JSON.parse(result)).toEqual({ directives: "Strategy: Manual Strategy" });
         });
     });
     describe("createStatusTool", () => {
-        it("should execute and return prompt", async () => {
+        it("should create a tool with correct description", () => {
+            const tool = createStatusTool(mockCtx);
+            expect(tool.description).toBe("Directives lookup tool for displaying the current progress of the project");
+        });
+        it("should execute and return directives", async () => {
             vi.mocked(readFile).mockResolvedValue(`
 description = "Status"
-prompt = "Status Prompt"
+prompt = """Status Prompt"""
 `);
             const tool = createStatusTool(mockCtx);
             const result = await tool.execute({}, mockToolContext);
-            expect(result).toBe("Status Prompt");
+            expect(JSON.parse(result)).toEqual({ directives: "Status Prompt" });
         });
     });
     describe("createRevertTool", () => {
-        it("should replace target in prompt", async () => {
+        it("should create a tool with correct description", () => {
+            const tool = createRevertTool(mockCtx);
+            expect(tool.description).toBe("Directives lookup tool for reverting previous work");
+        });
+        it("should replace target in directives", async () => {
             vi.mocked(readFile).mockResolvedValue(`
 description = "Revert"
-prompt = "Target: {{target}}"
+prompt = """Target: {{target}}"""
 `);
             const tool = createRevertTool(mockCtx);
             const result = await tool.execute({ target: "track 1" }, mockToolContext);
-            expect(result).toBe("Target: track 1");
+            expect(JSON.parse(result)).toEqual({ directives: "Target: track 1" });
         });
     });
     describe("Error Handling", () => {
-        it("should throw error if readFile fails", async () => {
+        it("should return error in directives if readFile fails", async () => {
             vi.mocked(readFile).mockRejectedValue(new Error("File not found"));
             const tool = createSetupTool(mockCtx);
-            await expect(tool.execute({}, mockToolContext)).rejects.toThrow("Failed to load prompt");
+            const result = await tool.execute({}, mockToolContext);
+            expect(JSON.parse(result).directives).toContain("SYSTEM ERROR: Failed to load prompt");
         });
     });
     describe("Prompt Replacement", () => {
-        it("should replace standard variables", async () => {
+        it("should replace standard variables in directives", async () => {
             vi.mocked(readFile).mockResolvedValue(`
 description = "Test"
-prompt = "Templates: {{templatesDir}}, OMO: {{isOMOActive}}"
+prompt = """Templates: {{templatesDir}}"""
 `);
             const tool = createNewTrackTool(mockCtx);
             const result = await tool.execute({}, mockToolContext);
-            expect(result).toContain("Templates:");
-            expect(result).toContain("OMO: false");
+            expect(JSON.parse(result).directives).toContain("Templates:");
         });
     });
 });

package/dist/utils/commandFactory.d.ts

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

package/dist/utils/commandFactory.js

@@ -1,47 +1,55 @@
 import { tool } from "@opencode-ai/plugin/tool";
-import { existsSync } from "fs";
-import { readFile } from "fs/promises";
 import { join, dirname } from "path";
+import { readFile } from "fs/promises";
 import { fileURLToPath } from "url";
-import { parse } from "smol-toml";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-export const createConductorCommand = (options) => (ctx) => tool({
-    description: options.description,
-    args: options.args || {},
-    async execute(args) {
-        // 1. Setup Check
-        if (options.requiresSetup !== false) {
-            const conductorDir = join(ctx.directory, "conductor");
-            if (!existsSync(join(conductorDir, "product.md"))) {
-                return "Conductor is not set up. Please run `conductor_setup`.";
-            }
-        }
-        // 2. Load Prompt from TOML
-        const promptPath = join(__dirname, "../prompts", options.name);
-        let promptText = "";
-        try {
-            const content = await readFile(promptPath, "utf-8");
-            const parsed = parse(content);
-            promptText = parsed.prompt;
-        }
-        catch (error) {
-            throw new Error(`Failed to load prompt from ${promptPath}: ${error}`);
-        }
-        // 3. Prepare Replacements
-        const replacements = {
-            isOMOActive: ctx.isOMOActive ? "true" : "false",
-            templatesDir: join(dirname(dirname(__dirname)), "dist/templates") // Fixing template path for setup
+// 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"),
         };
-        // 4. Inject Additional Context (e.g. from args)
-        if (options.additionalContext) {
-            const extra = await options.additionalContext(ctx, args);
-            Object.assign(replacements, extra);
-        }
-        // 5. Apply Replacements
-        for (const [key, value] of Object.entries(replacements)) {
+        const finalReplacements = { ...defaults, ...replacements };
+        for (const [key, value] of Object.entries(finalReplacements)) {
             promptText = promptText.replaceAll(`{{${key}}}`, value || "");
         }
-        return promptText;
-    },
-});
+        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, context) {
+                // 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 JSON.stringify({
+                    directives: prompt
+                });
+            },
+        });
+    };
+}

package/package.json

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