opencode-conductor-cdd-plugin 1.0.0-beta.13

package/dist/tools/background.js

@@ -0,0 +1,198 @@
+import { tool } from "@opencode-ai/plugin/tool";
+const BACKGROUND_TASK_DESCRIPTION = "Launch a specialized agent in the background to perform research or implementation tasks.";
+const BACKGROUND_OUTPUT_DESCRIPTION = "Retrieve the results or status of a background task.";
+export class BackgroundManager {
+    tasks;
+    client;
+    pollingInterval;
+    constructor(ctx) {
+        this.tasks = new Map();
+        this.client = ctx.client;
+    }
+    async launch(input) {
+        if (!input.agent || input.agent.trim() === "") {
+            throw new Error("Agent parameter is required");
+        }
+        const createResult = await this.client.session.create({
+            body: {
+                parentID: input.parentSessionID,
+                title: `Background: ${input.description}`,
+            },
+        });
+        if (createResult.error) {
+            throw new Error(`Failed to create background session: ${createResult.error}`);
+        }
+        const sessionID = createResult.data.id;
+        const task = {
+            id: `bg_${Math.random().toString(36).substring(2, 10)}`,
+            sessionID,
+            parentSessionID: input.parentSessionID,
+            parentMessageID: input.parentMessageID,
+            description: input.description,
+            prompt: input.prompt,
+            agent: input.agent,
+            status: "running",
+            startedAt: new Date(),
+            progress: {
+                toolCalls: 0,
+                lastUpdate: new Date(),
+            },
+        };
+        this.tasks.set(task.id, task);
+        this.startPolling();
+        this.client.session.promptAsync({
+            path: { id: sessionID },
+            body: {
+                agent: input.agent,
+                tools: {
+                    "cdd_bg_task": false,
+                    "cdd_delegate": false,
+                },
+                parts: [{ type: "text", text: input.prompt }],
+            },
+        }).catch((error) => {
+            console.error("[Orchestrator] Background task error:", error);
+            task.status = "failed";
+            task.error = String(error);
+        });
+        return task;
+    }
+    async cancel(id) {
+        const task = this.tasks.get(id);
+        if (!task)
+            return `Task not found: ${id}`;
+        if (task.status !== "running")
+            return `Task is not running (status: ${task.status})`;
+        task.status = "cancelled";
+        task.completedAt = new Date();
+        // Attempt to notify parent session
+        await this.client.session.prompt({
+            path: { id: task.parentSessionID },
+            body: {
+                parts: [{ type: "text", text: `[BACKGROUND TASK CANCELLED] Task "${task.description}" has been manually cancelled.` }],
+            },
+        }).catch(() => { });
+        return `Task ${id} cancelled successfully.`;
+    }
+    async pollRunningTasks() {
+        try {
+            const statusResult = await this.client.session.status();
+            const allStatuses = (statusResult.data ?? {});
+            for (const task of this.tasks.values()) {
+                if (task.status !== "running")
+                    continue;
+                const sessionStatus = allStatuses[task.sessionID];
+                if (sessionStatus?.type === "idle") {
+                    this.completeTask(task);
+                }
+            }
+            if (!this.hasRunningTasks()) {
+                this.stopPolling();
+            }
+        }
+        catch (e) {
+            console.error("[Orchestrator] Polling error:", e);
+        }
+    }
+    completeTask(task) {
+        task.status = "completed";
+        task.completedAt = new Date();
+        this.notifyParentSession(task);
+    }
+    async notifyParentSession(task) {
+        const message = `[BACKGROUND TASK COMPLETED] Task "${task.description}" finished. Use cdd_bg_output with task_id="${task.id}" to get results.`;
+        await this.client.session.prompt({
+            path: { id: task.parentSessionID },
+            body: {
+                parts: [{ type: "text", text: message }],
+            },
+        }).catch(() => { });
+    }
+    getTask(id) {
+        return this.tasks.get(id);
+    }
+    startPolling() {
+        if (this.pollingInterval)
+            return;
+        this.pollingInterval = setInterval(() => this.pollRunningTasks(), 3000);
+    }
+    stopPolling() {
+        if (this.pollingInterval) {
+            clearInterval(this.pollingInterval);
+            this.pollingInterval = undefined;
+        }
+    }
+    hasRunningTasks() {
+        return Array.from(this.tasks.values()).some(t => t.status === "running");
+    }
+}
+export function createBackgroundTask(manager) {
+    return tool({
+        description: BACKGROUND_TASK_DESCRIPTION,
+        args: {
+            description: tool.schema.string().describe("Short task description"),
+            prompt: tool.schema.string().describe("Full detailed prompt for the agent"),
+            agent: tool.schema.string().describe("Agent type to use"),
+        },
+        async execute(args, toolContext) {
+            const ctx = toolContext;
+            const task = await manager.launch({
+                description: args.description,
+                prompt: args.prompt,
+                agent: args.agent.trim(),
+                parentSessionID: ctx.sessionID,
+                parentMessageID: ctx.messageID,
+            });
+            return `Background task launched successfully. Task ID: ${task.id}`;
+        },
+    });
+}
+export function createBackgroundOutput(manager) {
+    return tool({
+        description: BACKGROUND_OUTPUT_DESCRIPTION,
+        args: {
+            task_id: tool.schema.string().describe("Task ID to get output from"),
+            block: tool.schema.boolean().optional().describe("Wait for completion"),
+            timeout: tool.schema.number().optional().describe("Max wait time in ms"),
+        },
+        async execute(args, toolContext) {
+            const task = manager.getTask(args.task_id);
+            if (!task)
+                return `Task not found: ${args.task_id}`;
+            if (args.block && task.status === "running") {
+                const startTime = Date.now();
+                const timeoutMs = Math.min(args.timeout ?? 60000, 600000);
+                while (Date.now() - startTime < timeoutMs) {
+                    await new Promise(r => setTimeout(r, 2000));
+                    if (manager.getTask(args.task_id)?.status === "completed")
+                        break;
+                }
+            }
+            if (task.status === "completed") {
+                const client = toolContext.client || manager.client;
+                const messagesResult = await client.session.messages({
+                    path: { id: task.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 `### Results for: ${task.description}\n\n${responseText}`;
+            }
+            return `Task status: ${task.status}. (Started at: ${task.startedAt.toISOString()})`;
+        },
+    });
+}
+export function createBackgroundCancel(manager) {
+    return tool({
+        description: "Cancel a running background task",
+        args: {
+            taskId: tool.schema.string().describe("Task ID to cancel"),
+        },
+        async execute(args) {
+            return await manager.cancel(args.taskId);
+        },
+    });
+}

package/dist/tools/commands.d.ts

@@ -0,0 +1,11 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+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

@@ -0,0 +1,80 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { createCDDCommand } from "../utils/commandFactory.js";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { readFile } from "fs/promises";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export const setupCommand = createCDDCommand({
+    name: "cdd/setup.json",
+    description: "Directives lookup tool for scaffolding the project and setting up the CDD environment",
+    args: {},
+});
+export const newTrackCommand = createCDDCommand({
+    name: "cdd/newTrack.json",
+    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.)"),
+    },
+    additionalContext: async (_ctx, args) => {
+        return {
+            args: args.description || "",
+        };
+    },
+});
+export const implementCommand = createCDDCommand({
+    name: "cdd/implement.json",
+    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"),
+    },
+    additionalContext: async (ctx, args) => {
+        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(`[CDD] Failed to load strategy ${strategyFile}:`, e);
+            strategySection = "Error: Could not load execution strategy.";
+        }
+        return {
+            strategy_section: strategySection,
+            track_name: args.track_name || "",
+        };
+    },
+});
+export const statusCommand = createCDDCommand({
+    name: "cdd/status.json",
+    description: "Directives lookup tool for displaying the current progress of the project",
+    args: {},
+});
+export const revertCommand = createCDDCommand({
+    name: "cdd/revert.json",
+    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>')"),
+    },
+    additionalContext: async (_ctx, args) => {
+        return {
+            target: args.target || "",
+        };
+    },
+});
+// Export as functions for backward compatibility
+export function createSetupTool(ctx) {
+    return setupCommand(ctx);
+}
+export function createNewTrackTool(ctx) {
+    return newTrackCommand(ctx);
+}
+export function createImplementTool(ctx) {
+    return implementCommand(ctx);
+}
+export function createStatusTool(ctx) {
+    return statusCommand(ctx);
+}
+export function createRevertTool(ctx) {
+    return revertCommand(ctx);
+}

package/dist/tools/commands.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/commands.test.js

@@ -0,0 +1,142 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createSetupTool, createNewTrackTool, createImplementTool, createStatusTool, createRevertTool, } from "./commands.js";
+import { readFile } from "fs/promises";
+// Mock fs/promises
+vi.mock("fs/promises", () => ({
+    readFile: vi.fn(),
+}));
+describe("Command Tools", () => {
+    let mockCtx;
+    let mockToolContext;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockCtx = {
+            directory: "/test/project",
+            isOMOActive: false,
+        };
+        mockToolContext = {
+            sessionID: "test-session",
+            messageID: "test-message",
+        };
+        vi.mocked(readFile).mockResolvedValue(JSON.stringify({
+            description: "Test command",
+            prompt: "Test prompt content"
+        }));
+    });
+    describe("createSetupTool", () => {
+        it("should create a tool with correct description", () => {
+            const tool = createSetupTool(mockCtx);
+            expect(tool.description).toBe("Directives lookup tool for scaffolding the project and setting up the CDD environment");
+        });
+        it("should return directives JSON string when executed", async () => {
+            vi.mocked(readFile).mockResolvedValue(JSON.stringify({
+                description: "Setup",
+                prompt: "Setup Prompt"
+            }));
+            const tool = createSetupTool(mockCtx);
+            const result = await tool.execute({}, mockToolContext);
+            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 directives", async () => {
+            vi.mocked(readFile).mockResolvedValue(JSON.stringify({
+                description: "New Track",
+                prompt: "Track description: {{args}}"
+            }));
+            const tool = createNewTrackTool(mockCtx);
+            const result = await tool.execute({ description: "Login feature" }, mockToolContext);
+            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 directives", async () => {
+            vi.mocked(readFile).mockResolvedValue(JSON.stringify({
+                description: "Implement",
+                prompt: "Track: {{track_name}}"
+            }));
+            const tool = createImplementTool(mockCtx);
+            const result = await tool.execute({ track_name: "auth-track" }, mockToolContext);
+            expect(JSON.parse(result)).toEqual({ directives: "Track: auth-track" });
+        });
+        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 JSON.stringify({
+                    description: "Implement",
+                    prompt: "Strategy: {{strategy_section}}"
+                });
+            });
+            const tool = createImplementTool(mockCtx);
+            const result = await tool.execute({}, mockToolContext);
+            expect(JSON.parse(result)).toEqual({ directives: "Strategy: Manual Strategy" });
+        });
+    });
+    describe("createStatusTool", () => {
+        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(JSON.stringify({
+                description: "Status",
+                prompt: "Status Prompt"
+            }));
+            const tool = createStatusTool(mockCtx);
+            const result = await tool.execute({}, mockToolContext);
+            expect(JSON.parse(result)).toEqual({ directives: "Status Prompt" });
+        });
+    });
+    describe("createRevertTool", () => {
+        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(JSON.stringify({
+                description: "Revert",
+                prompt: "Target: {{target}}"
+            }));
+            const tool = createRevertTool(mockCtx);
+            const result = await tool.execute({ target: "track 1" }, mockToolContext);
+            expect(JSON.parse(result)).toEqual({ directives: "Target: track 1" });
+        });
+    });
+    describe("Error Handling", () => {
+        it("should return error in directives if readFile fails", async () => {
+            vi.mocked(readFile).mockRejectedValue(new Error("File not found"));
+            const tool = createSetupTool(mockCtx);
+            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 in directives", async () => {
+            vi.mocked(readFile).mockResolvedValue(JSON.stringify({
+                description: "Test",
+                prompt: "Templates: {{templatesDir}}"
+            }));
+            const tool = createNewTrackTool(mockCtx);
+            const result = await tool.execute({}, mockToolContext);
+            expect(JSON.parse(result).directives).toContain("Templates:");
+        });
+    });
+});

package/dist/tools/delegate.d.ts

@@ -0,0 +1,3 @@
+import { type PluginInput } from "@opencode-ai/plugin";
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+export declare function createDelegationTool(ctx: PluginInput): ToolDefinition;

package/dist/tools/delegate.js

@@ -0,0 +1,45 @@
+import { tool } from "@opencode-ai/plugin/tool";
+export function createDelegationTool(ctx) {
+    return tool({
+        description: "Delegate a specific task to a specialized subagent",
+        args: {
+            task_description: tool.schema.string().describe("Summary of the work"),
+            subagent_type: tool.schema.string().describe("The name of the agent to call"),
+            prompt: tool.schema.string().describe("Detailed instructions for the subagent"),
+        },
+        async execute(args, toolContext) {
+            // 1. Create a sub-session linked to the current one
+            const createResult = await ctx.client.session.create({
+                body: {
+                    parentID: toolContext.sessionID,
+                    title: `${args.task_description} (Delegated to ${args.subagent_type})`,
+                },
+            });
+            if (createResult.error)
+                return `Error: ${createResult.error}`;
+            const sessionID = createResult.data.id;
+            // 2. Send the prompt to the subagent
+            await ctx.client.session.prompt({
+                path: { id: sessionID },
+                body: {
+                    agent: args.subagent_type,
+                    tools: {
+                        "cdd_delegate": false,
+                    },
+                    parts: [{ type: "text", text: args.prompt }],
+                },
+            });
+            // 3. 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>`;
+        },
+    });
+}

package/dist/utils/autogenerateFlow.d.ts

@@ -0,0 +1,65 @@
+import { ProjectContext } from './contextAnalysis.js';
+export type SectionType = 'product_guide' | 'product_guidelines' | 'tech_stack' | 'workflow';
+export type UserChoice = 'A' | 'B' | 'C';
+export type FallbackChoice = 'A' | 'B' | 'C';
+export type FlowStatus = 'generating' | 'presented' | 'accepted' | 'edited' | 'regenerating';
+export type FallbackAction = 'manual' | 'regenerate' | 'accept_partial';
+export interface AutogenerationState {
+    questionId: string;
+    attemptNumber: number;
+    status: FlowStatus;
+    content: string;
+    userChoice: UserChoice | null;
+    guidanceHistory: string[];
+    editHistory: string[];
+    timestamp: string;
+}
+export interface FlowResult {
+    success: boolean;
+    content?: string;
+    error?: string;
+    state?: AutogenerationState;
+    failureSummary?: string;
+    fallbackPrompt?: string;
+    fallbackAction?: FallbackAction;
+    fallbackState?: ContextSufficiencyResult;
+    ambiguityState?: AmbiguityResult;
+}
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+}
+export interface ContextSufficiencyResult {
+    sufficient: boolean;
+    reason: string;
+    missing: string[];
+}
+export interface AmbiguityResult {
+    ambiguous: boolean;
+    reason: string;
+    signals: string[];
+}
+export declare const MAX_REGENERATION_ATTEMPTS = 3;
+export declare const MIN_CONTEXT_SIGNALS = 2;
+export declare const MIN_CONFIDENCE_THRESHOLD = 0.4;
+export declare function createInitialState(questionId: string): AutogenerationState;
+export declare function generateContentForSection(sectionType: SectionType, context: ProjectContext): FlowResult;
+export declare function validateContent(content: string, sectionType: SectionType): ValidationResult;
+export declare function evaluateContextSufficiency(context: ProjectContext): ContextSufficiencyResult;
+export declare function formatAutogenerationFailure(sectionType: SectionType, error: string, sufficiency: ContextSufficiencyResult, ambiguity: AmbiguityResult): string;
+export declare function evaluateAmbiguity(context: ProjectContext): AmbiguityResult;
+export declare function formatFallbackPrompt(reason: string, missing: string[]): string;
+export declare function parseFallbackChoice(input: string): FallbackChoice | null;
+export declare function resolveFallbackAction(choice: FallbackChoice | null): FallbackAction;
+export declare function handleAccept(state: AutogenerationState, sectionType: SectionType): FlowResult;
+export declare function handleEdit(state: AutogenerationState, editedContent: string, sectionType: SectionType): FlowResult;
+export declare function handleRegenerate(state: AutogenerationState, guidance: string, sectionType: SectionType, context: ProjectContext): FlowResult;
+export declare function formatPresentationPrompt(content: string): string;
+export declare function formatEditPrompt(content: string): string;
+export declare function formatRegeneratePrompt(): string;
+export declare function formatMaxAttemptsPrompt(): string;
+export declare function parseUserChoice(input: string): UserChoice | null;
+export declare function isCancel(input: string): boolean;
+export declare function handleFallbackManual(sectionType: SectionType, reason: string): FlowResult;
+export declare function handleFallbackAcceptPartial(partialContent: string, sectionType: SectionType, reason: string): FlowResult;
+export declare function handleFallbackRegenerate(sectionType: SectionType, context: ProjectContext, additionalContext: string): FlowResult;