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

package/dist/utils/commandFactory.js

@@ -0,0 +1,69 @@
+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);
+async function loadPrompt(filename, replacements = {}) {
+    const pathsToTry = [
+        join(__dirname, "..", "prompts", filename),
+        join(__dirname, "..", "..", filename),
+    ];
+    let content = "";
+    for (const p of pathsToTry) {
+        try {
+            content = await readFile(p, "utf-8");
+            break;
+        }
+        catch (e) {
+            continue;
+        }
+    }
+    if (!content) {
+        console.error(`[CDD] Error loading prompt ${filename}: Not found in any tried paths`);
+        return {
+            prompt: `SYSTEM ERROR: Failed to load prompt ${filename}`,
+            description: "Error loading command",
+        };
+    }
+    try {
+        const parsed = JSON.parse(content);
+        const description = parsed.description || "CDD Command";
+        let promptText = parsed.prompt || "";
+        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 };
+    }
+    catch (error) {
+        console.error(`[CDD] Error parsing prompt ${filename}:`, error);
+        return {
+            prompt: `SYSTEM ERROR: Failed to parse prompt ${filename}`,
+            description: "Error parsing command",
+        };
+    }
+}
+export function createCDDCommand(config) {
+    return (ctx) => {
+        return tool({
+            description: config.description,
+            args: config.args,
+            async execute(args) {
+                const additionalContext = config.additionalContext
+                    ? await config.additionalContext(ctx, args)
+                    : {};
+                const replacements = { ...additionalContext };
+                const { prompt } = await loadPrompt(config.name, replacements);
+                return JSON.stringify({
+                    directives: prompt
+                });
+            },
+        });
+    };
+}

package/dist/utils/commitMessages.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Conventional commit types
+ */
+export type CommitType = "feat" | "fix" | "docs" | "style" | "refactor" | "test" | "chore";
+export interface TaskCommitMessageOptions {
+    type: CommitType;
+    scope?: string;
+    description: string;
+    trackId: string;
+    body?: string;
+}
+export interface PhaseCheckpointMessageOptions {
+    phaseName: string;
+    trackId: string;
+}
+export interface PlanUpdateMessageOptions {
+    updateType: "task" | "phase";
+    description: string;
+    trackId: string;
+}
+/**
+ * Generates a conventional commit message for a task
+ * Format: <type>(<scope>): <description>\n\n[body]\n\nTrack: <trackId>
+ */
+export declare function generateTaskCommitMessage(options: TaskCommitMessageOptions): string;
+/**
+ * Generates a commit message for a phase checkpoint
+ * Format: cdd(checkpoint): Checkpoint end of <phaseName>\n\nTrack: <trackId>
+ */
+export declare function generatePhaseCheckpointMessage(options: PhaseCheckpointMessageOptions): string;
+/**
+ * Generates a commit message for plan.md updates
+ * Format: cdd(plan): Mark <updateType> '<description>' as complete\n\nTrack: <trackId>
+ */
+export declare function generatePlanUpdateMessage(options: PlanUpdateMessageOptions): string;

package/dist/utils/commitMessages.js

@@ -0,0 +1,33 @@
+/**
+ * Generates a conventional commit message for a task
+ * Format: <type>(<scope>): <description>\n\n[body]\n\nTrack: <trackId>
+ */
+export function generateTaskCommitMessage(options) {
+    const { type, scope, description, trackId, body } = options;
+    // Build the subject line
+    const scopePart = scope ? `(${scope})` : "";
+    const subject = `${type}${scopePart}: ${description}`;
+    // Build the full message
+    const parts = [subject];
+    if (body) {
+        parts.push("", body); // Empty line before body
+    }
+    parts.push("", `Track: ${trackId}`);
+    return parts.join("\n");
+}
+/**
+ * Generates a commit message for a phase checkpoint
+ * Format: cdd(checkpoint): Checkpoint end of <phaseName>\n\nTrack: <trackId>
+ */
+export function generatePhaseCheckpointMessage(options) {
+    const { phaseName, trackId } = options;
+    return `cdd(checkpoint): Checkpoint end of ${phaseName}\n\nTrack: ${trackId}`;
+}
+/**
+ * Generates a commit message for plan.md updates
+ * Format: cdd(plan): Mark <updateType> '<description>' as complete\n\nTrack: <trackId>
+ */
+export function generatePlanUpdateMessage(options) {
+    const { updateType, description, trackId } = options;
+    return `cdd(plan): Mark ${updateType} '${description}' as complete\n\nTrack: ${trackId}`;
+}

package/dist/utils/commitMessages.test.d.ts

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

package/dist/utils/commitMessages.test.js

@@ -0,0 +1,79 @@
+import { describe, it, expect } from "vitest";
+import { generateTaskCommitMessage, generatePhaseCheckpointMessage, generatePlanUpdateMessage } from "./commitMessages.js";
+describe("commitMessages", () => {
+    describe("generateTaskCommitMessage", () => {
+        it("should generate a commit message for a feature task", () => {
+            const message = generateTaskCommitMessage({
+                type: "feat",
+                scope: "auth",
+                description: "Add JWT authentication",
+                trackId: "track_123"
+            });
+            expect(message).toBe("feat(auth): Add JWT authentication\n\nTrack: track_123");
+        });
+        it("should generate a commit message for a fix task", () => {
+            const message = generateTaskCommitMessage({
+                type: "fix",
+                scope: "api",
+                description: "Correct endpoint validation",
+                trackId: "bug_fix_456"
+            });
+            expect(message).toBe("fix(api): Correct endpoint validation\n\nTrack: bug_fix_456");
+        });
+        it("should handle commit message without scope", () => {
+            const message = generateTaskCommitMessage({
+                type: "test",
+                description: "Add unit tests",
+                trackId: "track_789"
+            });
+            expect(message).toBe("test: Add unit tests\n\nTrack: track_789");
+        });
+        it("should include body when provided", () => {
+            const message = generateTaskCommitMessage({
+                type: "feat",
+                scope: "ui",
+                description: "Create user dashboard",
+                trackId: "track_abc",
+                body: "Implemented responsive layout with mobile support"
+            });
+            expect(message).toContain("feat(ui): Create user dashboard");
+            expect(message).toContain("Implemented responsive layout with mobile support");
+            expect(message).toContain("Track: track_abc");
+        });
+    });
+    describe("generatePhaseCheckpointMessage", () => {
+        it("should generate a checkpoint message for a phase", () => {
+            const message = generatePhaseCheckpointMessage({
+                phaseName: "Phase 1: Research & Analysis",
+                trackId: "track_123"
+            });
+            expect(message).toBe("cdd(checkpoint): Checkpoint end of Phase 1: Research & Analysis\n\nTrack: track_123");
+        });
+        it("should handle phase names with special characters", () => {
+            const message = generatePhaseCheckpointMessage({
+                phaseName: "Phase 2: Implementation & Testing",
+                trackId: "track_xyz"
+            });
+            expect(message).toContain("Phase 2: Implementation & Testing");
+            expect(message).toContain("Track: track_xyz");
+        });
+    });
+    describe("generatePlanUpdateMessage", () => {
+        it("should generate a message for task completion", () => {
+            const message = generatePlanUpdateMessage({
+                updateType: "task",
+                description: "Create user model",
+                trackId: "track_123"
+            });
+            expect(message).toBe("cdd(plan): Mark task 'Create user model' as complete\n\nTrack: track_123");
+        });
+        it("should generate a message for phase completion", () => {
+            const message = generatePlanUpdateMessage({
+                updateType: "phase",
+                description: "Phase 1: Setup",
+                trackId: "track_456"
+            });
+            expect(message).toBe("cdd(plan): Mark phase 'Phase 1: Setup' as complete\n\nTrack: track_456");
+        });
+    });
+});

package/dist/utils/configDetection.d.ts

@@ -0,0 +1,7 @@
+export interface ConfigDetectionResult {
+    hasCDDInOpenCode: boolean;
+    hasCDDInOMO: boolean;
+    synergyActive: boolean;
+    cddModel?: string;
+}
+export declare function detectCDDConfig(): ConfigDetectionResult;

package/dist/utils/configDetection.js

@@ -0,0 +1,49 @@
+import { join } from "path";
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+export function detectCDDConfig() {
+    const opencodeConfigDir = join(homedir(), ".config", "opencode");
+    const opencodeJsonPath = join(opencodeConfigDir, "opencode.json");
+    const omoJsonPath = join(opencodeConfigDir, "oh-my-opencode.json");
+    let hasCDDInOpenCode = false;
+    let hasCDDInOMO = false;
+    let cddModel;
+    // Check oh-my-opencode.json first (higher priority)
+    if (existsSync(omoJsonPath)) {
+        try {
+            const config = JSON.parse(readFileSync(omoJsonPath, "utf-8"));
+            if (config.agents && config.agents.cdd) {
+                hasCDDInOMO = true;
+                // Extract model from oh-my-opencode.json
+                if (config.agents.cdd.model) {
+                    cddModel = config.agents.cdd.model;
+                }
+            }
+        }
+        catch (e) {
+            // Silently fail on parse errors
+        }
+    }
+    // Check opencode.json (fallback if model not found in OMO)
+    if (existsSync(opencodeJsonPath)) {
+        try {
+            const config = JSON.parse(readFileSync(opencodeJsonPath, "utf-8"));
+            if (config.agent && config.agent.cdd) {
+                hasCDDInOpenCode = true;
+                // Only use this model if we didn't find one in oh-my-opencode.json
+                if (!cddModel && config.agent.cdd.model) {
+                    cddModel = config.agent.cdd.model;
+                }
+            }
+        }
+        catch (e) {
+            // Silently fail on parse errors
+        }
+    }
+    return {
+        hasCDDInOpenCode,
+        hasCDDInOMO,
+        synergyActive: hasCDDInOMO,
+        cddModel,
+    };
+}

package/dist/utils/configDetection.test.d.ts

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

package/dist/utils/configDetection.test.js

@@ -0,0 +1,119 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { existsSync, readFileSync } from "fs";
+import { detectCDDConfig } from "./configDetection.js";
+vi.mock("fs", () => ({
+    existsSync: vi.fn(),
+    readFileSync: vi.fn(),
+}));
+vi.mock("os", () => ({
+    homedir: vi.fn(() => "/home/user"),
+}));
+describe("configDetection", () => {
+    const opencodeJsonPath = "/home/user/.config/opencode/opencode.json";
+    const omoJsonPath = "/home/user/.config/opencode/oh-my-opencode.json";
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should detect cdd in opencode.json", () => {
+        vi.mocked(existsSync).mockImplementation((path) => path === opencodeJsonPath);
+        vi.mocked(readFileSync).mockImplementation((path) => {
+            if (path === opencodeJsonPath) {
+                return JSON.stringify({ agent: { cdd: { model: "anthropic/claude-3-5-sonnet" } } });
+            }
+            return "";
+        });
+        const result = detectCDDConfig();
+        expect(result.hasCDDInOpenCode).toBe(true);
+        expect(result.hasCDDInOMO).toBe(false);
+        expect(result.synergyActive).toBe(false);
+        expect(result.cddModel).toBe("anthropic/claude-3-5-sonnet");
+    });
+    it("should detect cdd in oh-my-opencode.json and activate synergy", () => {
+        vi.mocked(existsSync).mockImplementation((path) => path === omoJsonPath);
+        vi.mocked(readFileSync).mockImplementation((path) => {
+            if (path === omoJsonPath) {
+                return JSON.stringify({ agents: { cdd: { model: "anthropic/claude-3-5-haiku" } } });
+            }
+            return "";
+        });
+        const result = detectCDDConfig();
+        expect(result.hasCDDInOpenCode).toBe(false);
+        expect(result.hasCDDInOMO).toBe(true);
+        expect(result.synergyActive).toBe(true);
+        expect(result.cddModel).toBe("anthropic/claude-3-5-haiku");
+    });
+    it("should handle both configs present", () => {
+        vi.mocked(existsSync).mockReturnValue(true);
+        vi.mocked(readFileSync).mockImplementation((path) => {
+            if (path === opencodeJsonPath) {
+                return JSON.stringify({ agent: { cdd: { model: "anthropic/claude-3-5-sonnet" } } });
+            }
+            if (path === omoJsonPath) {
+                return JSON.stringify({ agents: { cdd: { model: "anthropic/claude-3-5-haiku" } } });
+            }
+            return "";
+        });
+        const result = detectCDDConfig();
+        expect(result.hasCDDInOpenCode).toBe(true);
+        expect(result.hasCDDInOMO).toBe(true);
+        expect(result.synergyActive).toBe(true);
+        expect(result.cddModel).toBe("anthropic/claude-3-5-haiku");
+    });
+    it("should handle missing configs", () => {
+        vi.mocked(existsSync).mockReturnValue(false);
+        const result = detectCDDConfig();
+        expect(result.hasCDDInOpenCode).toBe(false);
+        expect(result.hasCDDInOMO).toBe(false);
+        expect(result.synergyActive).toBe(false);
+        expect(result.cddModel).toBeUndefined();
+    });
+    it("should handle malformed JSON", () => {
+        vi.mocked(existsSync).mockReturnValue(true);
+        vi.mocked(readFileSync).mockReturnValue("invalid json");
+        const result = detectCDDConfig();
+        expect(result.hasCDDInOpenCode).toBe(false);
+        expect(result.hasCDDInOMO).toBe(false);
+        expect(result.synergyActive).toBe(false);
+        expect(result.cddModel).toBeUndefined();
+    });
+    it("should prioritize oh-my-opencode.json model over opencode.json", () => {
+        vi.mocked(existsSync).mockReturnValue(true);
+        vi.mocked(readFileSync).mockImplementation((path) => {
+            if (path === opencodeJsonPath) {
+                return JSON.stringify({ agent: { cdd: { model: "model-from-opencode" } } });
+            }
+            if (path === omoJsonPath) {
+                return JSON.stringify({ agents: { cdd: { model: "model-from-omo" } } });
+            }
+            return "";
+        });
+        const result = detectCDDConfig();
+        expect(result.cddModel).toBe("model-from-omo");
+    });
+    it("should fallback to opencode.json model when oh-my-opencode.json has no model", () => {
+        vi.mocked(existsSync).mockReturnValue(true);
+        vi.mocked(readFileSync).mockImplementation((path) => {
+            if (path === opencodeJsonPath) {
+                return JSON.stringify({ agent: { cdd: { model: "model-from-opencode" } } });
+            }
+            if (path === omoJsonPath) {
+                return JSON.stringify({ agents: { cdd: {} } });
+            }
+            return "";
+        });
+        const result = detectCDDConfig();
+        expect(result.cddModel).toBe("model-from-opencode");
+    });
+    it("should handle cdd config without model field", () => {
+        vi.mocked(existsSync).mockImplementation((path) => path === omoJsonPath);
+        vi.mocked(readFileSync).mockImplementation((path) => {
+            if (path === omoJsonPath) {
+                return JSON.stringify({ agents: { cdd: {} } });
+            }
+            return "";
+        });
+        const result = detectCDDConfig();
+        expect(result.hasCDDInOMO).toBe(true);
+        expect(result.cddModel).toBeUndefined();
+    });
+});

package/dist/utils/contentGeneration.d.ts

@@ -0,0 +1,10 @@
+import type { ProjectContext } from "./contextAnalysis.js";
+export type { ProjectContext };
+export interface GenerationResult {
+    content: string;
+    confidence: number;
+}
+export declare function generateProductGuide(context: ProjectContext): GenerationResult;
+export declare function generateProductGuidelines(context: ProjectContext): GenerationResult;
+export declare function generateTechStack(context: ProjectContext): GenerationResult;
+export declare function generateWorkflow(context: ProjectContext): GenerationResult;

package/dist/utils/contentGeneration.js

@@ -0,0 +1,141 @@
+export function generateProductGuide(context) {
+    const parts = [];
+    let confidence = 0.0;
+    if (context.raw.docs.length > 0) {
+        const readme = context.raw.docs[0].content;
+        const lines = readme.split("\n").slice(0, 10);
+        const description = lines.find((line) => line.length > 20 && !line.startsWith("#") && !line.startsWith("-"));
+        if (description) {
+            parts.push(`Project Description: ${description.trim()}`);
+            confidence += 0.4;
+        }
+        if (readme.toLowerCase().includes("feature")) {
+            const featureSection = readme.split("\n").find((line) => line.toLowerCase().includes("feature") && line.startsWith("#"));
+            if (featureSection) {
+                parts.push("\nKey Features: Based on documentation");
+                confidence += 0.2;
+            }
+        }
+    }
+    if (context.insights.projectType) {
+        parts.push(`\nProject Type: ${context.insights.projectType}`);
+        confidence += 0.2;
+    }
+    if (context.insights.techStack.frameworks.length > 0) {
+        const mainFramework = context.insights.techStack.frameworks[0].name;
+        parts.push(`\nBuilt with: ${mainFramework}`);
+        confidence += 0.2;
+    }
+    if (parts.length === 0) {
+        parts.push("Unable to automatically determine product details from project context.");
+        confidence = 0.3;
+    }
+    return {
+        content: parts.join("\n"),
+        confidence: Math.min(confidence, 1.0),
+    };
+}
+export function generateProductGuidelines(context) {
+    const guidelines = [];
+    let confidence = 0.0;
+    if (context.insights.techStack.languages.length > 0) {
+        const lang = context.insights.techStack.languages[0].name;
+        guidelines.push(`- Use ${lang} best practices and conventions`);
+        confidence += 0.3;
+    }
+    if (context.insights.techStack.frameworks.length > 0) {
+        const framework = context.insights.techStack.frameworks[0].name;
+        guidelines.push(`- Follow ${framework} component patterns`);
+        confidence += 0.2;
+    }
+    if (context.insights.techStack.testing.length > 0) {
+        guidelines.push("- Write tests for all new features");
+        confidence += 0.2;
+    }
+    if (context.insights.workflow.commitConvention === "conventional") {
+        guidelines.push("- Use conventional commit messages");
+        confidence += 0.3;
+    }
+    if (guidelines.length === 0) {
+        guidelines.push("- Follow project coding standards");
+        guidelines.push("- Ensure code quality and maintainability");
+        confidence = 0.4;
+    }
+    return {
+        content: guidelines.join("\n"),
+        confidence: Math.min(confidence, 1.0),
+    };
+}
+export function generateTechStack(context) {
+    const sections = [];
+    let confidence = 0.0;
+    if (context.insights.techStack.languages.length > 0) {
+        const langs = context.insights.techStack.languages
+            .map((l) => `${l.name} (${l.percentage}%)`)
+            .join(", ");
+        sections.push(`Languages: ${langs}`);
+        confidence += 0.3;
+    }
+    if (context.insights.techStack.frameworks.length > 0) {
+        const frameworks = context.insights.techStack.frameworks
+            .map((f) => f.name)
+            .join(", ");
+        sections.push(`Frameworks: ${frameworks}`);
+        confidence += 0.3;
+    }
+    if (context.insights.techStack.testing.length > 0) {
+        const testing = context.insights.techStack.testing
+            .map((t) => t.framework)
+            .join(", ");
+        sections.push(`Testing: ${testing}`);
+        confidence += 0.2;
+    }
+    if (context.insights.techStack.databases.length > 0) {
+        const dbs = context.insights.techStack.databases
+            .map((d) => d.type)
+            .join(", ");
+        sections.push(`Databases: ${dbs}`);
+        confidence += 0.2;
+    }
+    if (sections.length === 0) {
+        sections.push("Unable to automatically detect tech stack from project files.");
+        confidence = 0.3;
+    }
+    return {
+        content: sections.join("\n"),
+        confidence: Math.min(confidence, 1.0),
+    };
+}
+export function generateWorkflow(context) {
+    const workflow = [];
+    let confidence = 0.0;
+    if (context.insights.workflow.commitConvention === "conventional") {
+        workflow.push("Commit Convention: Conventional Commits (feat:, fix:, etc.)");
+        confidence += 0.3;
+    }
+    else {
+        workflow.push("Commit Convention: Standard git commits");
+        confidence += 0.1;
+    }
+    if (context.insights.techStack.testing.length > 0) {
+        const testFramework = context.insights.techStack.testing[0].framework;
+        workflow.push(`Testing: ${testFramework} for unit and integration tests`);
+        confidence += 0.2;
+    }
+    if (context.raw.cicd.length > 0) {
+        workflow.push("CI/CD: Automated testing and deployment via GitHub Actions");
+        confidence += 0.2;
+    }
+    if (context.insights.workflow.testingStrategy && context.insights.workflow.testingStrategy !== "unknown") {
+        workflow.push(`Testing Strategy: ${context.insights.workflow.testingStrategy}`);
+        confidence += 0.3;
+    }
+    if (workflow.length === 0) {
+        workflow.push("Standard git workflow with feature branches");
+        confidence = 0.4;
+    }
+    return {
+        content: workflow.join("\n"),
+        confidence: Math.min(confidence, 1.0),
+    };
+}

package/dist/utils/contentGeneration.test.d.ts

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