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

package/dist/utils/contentGeneration.test.js

@@ -0,0 +1,147 @@
+import { describe, it, expect } from "vitest";
+import { generateProductGuide, generateProductGuidelines, generateTechStack, generateWorkflow, } from "./contentGeneration.js";
+describe("Content Generation Module", () => {
+    const mockContext = {
+        raw: {
+            manifests: [
+                {
+                    type: "package.json",
+                    dependencies: ["react", "typescript", "vitest"],
+                    devDependencies: ["@types/node"],
+                    scripts: { test: "vitest", build: "tsc" },
+                },
+            ],
+            docs: [
+                {
+                    filename: "README.md",
+                    content: "# Test Project\n\nA React TypeScript application for testing workflows",
+                },
+            ],
+            git: {
+                commitCount: 50,
+                conventionalCommits: 45,
+                patterns: ["conventional"],
+                warnings: [],
+            },
+            structure: {
+                structure: ["src/", "tests/", "dist/"],
+                fileExtensions: [".ts", ".tsx", ".json"],
+                warnings: [],
+            },
+            ignores: {
+                patterns: ["node_modules/", "dist/", ".env"],
+            },
+            cicd: [
+                {
+                    type: "github-actions",
+                    commands: ["npm test", "npm run build"],
+                },
+            ],
+        },
+        insights: {
+            techStack: {
+                languages: [{ name: "TypeScript", confidence: 1.0, percentage: 100 }],
+                frameworks: [{ name: "react", version: "", confidence: 1.0 }],
+                databases: [],
+                infrastructure: [],
+                testing: [{ framework: "vitest", confidence: 1.0 }],
+            },
+            product: {
+                targetUsers: [],
+                coreProblems: [],
+                keyFeatures: [],
+                confidence: 0.0,
+            },
+            workflow: {
+                commitConvention: "conventional",
+                testingStrategy: "TDD",
+                branchStrategy: "trunk-based",
+                confidence: 0.8,
+            },
+            projectType: "application",
+            maturity: "active",
+        },
+        meta: {
+            analyzedAt: new Date().toISOString(),
+            analysisTimeMs: 100,
+            filesAnalyzed: 2,
+            categoriesCompleted: ["manifests", "docs", "git", "structure", "ignores", "cicd"],
+            warnings: [],
+        },
+    };
+    describe("generateProductGuide", () => {
+        it("should generate product guide from context", () => {
+            const result = generateProductGuide(mockContext);
+            expect(result.content).toBeTruthy();
+            expect(result.content.length).toBeGreaterThan(50);
+            expect(result.confidence).toBeGreaterThan(0.5);
+            expect(result.confidence).toBeLessThanOrEqual(1.0);
+        });
+        it("should extract target users from README", () => {
+            const result = generateProductGuide(mockContext);
+            expect(result.content).toContain("application");
+        });
+        it("should mention project type in guide", () => {
+            const result = generateProductGuide(mockContext);
+            expect(result.content.toLowerCase()).toMatch(/application|tool|library/);
+        });
+        it("should return low confidence when no context available", () => {
+            const emptyContext = {
+                ...mockContext,
+                raw: { ...mockContext.raw, docs: [] },
+                insights: { ...mockContext.insights, techStack: { ...mockContext.insights.techStack, frameworks: [] } },
+            };
+            const result = generateProductGuide(emptyContext);
+            expect(result.confidence).toBeLessThan(0.5);
+        });
+    });
+    describe("generateProductGuidelines", () => {
+        it("should generate guidelines from context", () => {
+            const result = generateProductGuidelines(mockContext);
+            expect(result.content).toBeTruthy();
+            expect(result.content.length).toBeGreaterThan(30);
+            expect(result.confidence).toBeGreaterThan(0);
+        });
+        it("should infer guidelines from tech stack", () => {
+            const result = generateProductGuidelines(mockContext);
+            expect(result.content.toLowerCase()).toMatch(/type|component|test/);
+        });
+    });
+    describe("generateTechStack", () => {
+        it("should generate tech stack description", () => {
+            const result = generateTechStack(mockContext);
+            expect(result.content).toBeTruthy();
+            expect(result.content).toContain("TypeScript");
+            expect(result.content.toLowerCase()).toContain("react");
+            expect(result.confidence).toBeGreaterThan(0.7);
+        });
+        it("should list all detected technologies", () => {
+            const result = generateTechStack(mockContext);
+            expect(result.content).toContain("vitest");
+        });
+        it("should format as structured list", () => {
+            const result = generateTechStack(mockContext);
+            expect(result.content).toMatch(/Language|Framework|Testing/);
+        });
+    });
+    describe("generateWorkflow", () => {
+        it("should generate workflow description", () => {
+            const result = generateWorkflow(mockContext);
+            expect(result.content).toBeTruthy();
+            expect(result.content.length).toBeGreaterThan(50);
+            expect(result.confidence).toBeGreaterThan(0.5);
+        });
+        it("should detect conventional commits", () => {
+            const result = generateWorkflow(mockContext);
+            expect(result.content.toLowerCase()).toContain("conventional");
+        });
+        it("should mention testing strategy", () => {
+            const result = generateWorkflow(mockContext);
+            expect(result.content.toLowerCase()).toMatch(/test|tdd/);
+        });
+        it("should include CI/CD information when available", () => {
+            const result = generateWorkflow(mockContext);
+            expect(result.content).toContain("CI");
+        });
+    });
+});

package/dist/utils/contextAnalysis.d.ts

@@ -0,0 +1,100 @@
+export interface ManifestData {
+    type: string;
+    dependencies: string[];
+    devDependencies?: string[];
+    scripts?: Record<string, string>;
+}
+export interface DocumentData {
+    filename: string;
+    content: string;
+}
+export interface GitHistoryData {
+    commitCount: number;
+    conventionalCommits: number;
+    patterns: string[];
+    warnings: string[];
+}
+export interface DirectoryStructure {
+    structure: string[];
+    fileExtensions: string[];
+    warnings: string[];
+}
+export interface IgnorePatterns {
+    patterns: string[];
+}
+export interface CICDConfig {
+    type: string;
+    commands: string[];
+}
+export interface ProjectContext {
+    raw: {
+        manifests: ManifestData[];
+        docs: DocumentData[];
+        git: GitHistoryData;
+        structure: DirectoryStructure;
+        ignores: IgnorePatterns;
+        cicd: CICDConfig[];
+    };
+    insights: {
+        techStack: {
+            languages: Array<{
+                name: string;
+                confidence: number;
+                percentage: number;
+            }>;
+            frameworks: Array<{
+                name: string;
+                version: string;
+                confidence: number;
+            }>;
+            databases: Array<{
+                type: string;
+                confidence: number;
+            }>;
+            infrastructure: Array<{
+                type: string;
+                confidence: number;
+            }>;
+            testing: Array<{
+                framework: string;
+                confidence: number;
+            }>;
+        };
+        product: {
+            targetUsers: string[];
+            coreProblems: string[];
+            keyFeatures: string[];
+            confidence: number;
+        };
+        workflow: {
+            commitConvention: string;
+            testingStrategy: string;
+            branchStrategy: string;
+            confidence: number;
+        };
+        projectType: "library" | "application" | "tool" | "framework" | "unknown";
+        maturity: "early" | "active" | "mature" | "legacy";
+    };
+    meta: {
+        analyzedAt: string;
+        analysisTimeMs: number;
+        filesAnalyzed: number;
+        categoriesCompleted: string[];
+        warnings: string[];
+    };
+}
+export declare function parseManifests(projectPath: string): Promise<{
+    manifests: ManifestData[];
+    warnings: string[];
+}>;
+export declare function analyzeDocs(projectPath: string): Promise<{
+    docs: DocumentData[];
+    warnings: string[];
+}>;
+export declare function analyzeGitHistory(projectPath: string): Promise<GitHistoryData>;
+export declare function analyzeCodeStructure(projectPath: string, currentDepth?: number, maxDepth?: number): Promise<DirectoryStructure>;
+export declare function parseIgnoreFiles(projectPath: string): Promise<IgnorePatterns>;
+export declare function parseCICDConfigs(projectPath: string): Promise<{
+    configs: CICDConfig[];
+}>;
+export declare function analyzeProjectContext(projectPath: string): Promise<ProjectContext>;

package/dist/utils/contextAnalysis.js

@@ -0,0 +1,308 @@
+import { readFile, readdir, stat } from "fs/promises";
+import { execSync } from "child_process";
+import { join } from "path";
+export async function parseManifests(projectPath) {
+    const manifests = [];
+    const warnings = [];
+    try {
+        const files = await readdir(projectPath);
+        if (files.includes("package.json")) {
+            try {
+                const content = await readFile(join(projectPath, "package.json"), "utf-8");
+                const pkg = JSON.parse(content);
+                manifests.push({
+                    type: "package.json",
+                    dependencies: Object.keys(pkg.dependencies || {}),
+                    devDependencies: Object.keys(pkg.devDependencies || {}),
+                    scripts: pkg.scripts || {},
+                });
+            }
+            catch (error) {
+                warnings.push(`Failed to read package.json: ${error.message}`);
+            }
+        }
+        if (files.includes("requirements.txt")) {
+            try {
+                const content = await readFile(join(projectPath, "requirements.txt"), "utf-8");
+                const dependencies = content
+                    .split("\n")
+                    .filter((line) => line.trim() && !line.startsWith("#"))
+                    .map((line) => line.split(/[=<>]/)[0].trim());
+                manifests.push({
+                    type: "requirements.txt",
+                    dependencies,
+                });
+            }
+            catch (error) {
+                warnings.push(`Failed to read requirements.txt: ${error.message}`);
+            }
+        }
+        if (files.includes("Cargo.toml")) {
+            try {
+                const content = await readFile(join(projectPath, "Cargo.toml"), "utf-8");
+                const depSection = content.match(/\[dependencies\]([\s\S]*?)(\[|$)/)?.[1] || "";
+                const dependencies = depSection
+                    .split("\n")
+                    .filter((line) => line.trim() && !line.startsWith("#"))
+                    .map((line) => line.split("=")[0].trim())
+                    .filter((dep) => dep.length > 0);
+                manifests.push({
+                    type: "Cargo.toml",
+                    dependencies,
+                });
+            }
+            catch (error) {
+                warnings.push(`Failed to read Cargo.toml: ${error.message}`);
+            }
+        }
+        if (manifests.length === 0) {
+            warnings.push("No manifest files found");
+        }
+    }
+    catch (error) {
+        warnings.push(`Failed to read project directory: ${error.message}`);
+    }
+    return { manifests, warnings };
+}
+export async function analyzeDocs(projectPath) {
+    const docs = [];
+    const warnings = [];
+    try {
+        const files = await readdir(projectPath);
+        if (files.includes("README.md")) {
+            try {
+                const content = await readFile(join(projectPath, "README.md"), "utf-8");
+                const fileSize = Buffer.byteLength(content, "utf-8");
+                if (fileSize > 10 * 1024) {
+                    warnings.push("Large file detected, using sampling");
+                    const lines = content.split("\n");
+                    const totalLines = lines.length;
+                    if (totalLines > 200) {
+                        const sampled = [
+                            ...lines.slice(0, 100),
+                            `\n... (${totalLines - 200} lines omitted) ...\n`,
+                            ...lines.slice(-100),
+                        ].join("\n");
+                        docs.push({
+                            filename: "README.md",
+                            content: sampled,
+                        });
+                    }
+                    else {
+                        docs.push({
+                            filename: "README.md",
+                            content,
+                        });
+                    }
+                }
+                else {
+                    docs.push({
+                        filename: "README.md",
+                        content,
+                    });
+                }
+            }
+            catch (error) {
+                warnings.push(`Failed to read README.md: ${error.message}`);
+            }
+        }
+        if (docs.length === 0) {
+            warnings.push("No README found");
+        }
+    }
+    catch (error) {
+        warnings.push(`Failed to read docs: ${error.message}`);
+    }
+    return { docs, warnings };
+}
+export async function analyzeGitHistory(projectPath) {
+    const warnings = [];
+    try {
+        const output = execSync('git log --oneline --no-merges -n 100', {
+            cwd: projectPath,
+            encoding: "utf-8",
+        });
+        const commits = output.trim().split("\n").filter((line) => line.length > 0);
+        const conventionalPattern = /^[a-f0-9]+ (feat|fix|chore|docs|style|refactor|test|perf|ci|build)(\([^)]+\))?:/;
+        const conventionalCommits = commits.filter((commit) => conventionalPattern.test(commit)).length;
+        const patterns = [];
+        if (conventionalCommits > commits.length * 0.7) {
+            patterns.push("conventional");
+        }
+        return {
+            commitCount: commits.length,
+            conventionalCommits,
+            patterns,
+            warnings,
+        };
+    }
+    catch (error) {
+        warnings.push(`Not a git repository: ${error.message}`);
+        return {
+            commitCount: 0,
+            conventionalCommits: 0,
+            patterns: [],
+            warnings,
+        };
+    }
+}
+export async function analyzeCodeStructure(projectPath, currentDepth = 0, maxDepth = 5) {
+    const structure = [];
+    const fileExtensions = new Set();
+    const warnings = [];
+    if (currentDepth >= maxDepth) {
+        return { structure, fileExtensions: Array.from(fileExtensions), warnings };
+    }
+    try {
+        const files = await readdir(projectPath);
+        for (const file of files) {
+            if (file.startsWith(".") || file === "node_modules")
+                continue;
+            const fullPath = join(projectPath, file);
+            try {
+                const stats = await stat(fullPath);
+                if (stats.isDirectory()) {
+                    structure.push(`${file}/`);
+                }
+                else {
+                    const ext = file.substring(file.lastIndexOf("."));
+                    if (ext) {
+                        fileExtensions.add(ext);
+                    }
+                }
+            }
+            catch (error) {
+                warnings.push(`Failed to stat ${file}: ${error.message}`);
+            }
+        }
+    }
+    catch (error) {
+        warnings.push(`Failed to read directory: ${error.message}`);
+    }
+    return { structure, fileExtensions: Array.from(fileExtensions), warnings };
+}
+export async function parseIgnoreFiles(projectPath) {
+    const patterns = [];
+    try {
+        const files = await readdir(projectPath);
+        if (files.includes(".gitignore")) {
+            try {
+                const content = await readFile(join(projectPath, ".gitignore"), "utf-8");
+                const lines = content
+                    .split("\n")
+                    .filter((line) => line.trim() && !line.startsWith("#"));
+                patterns.push(...lines);
+            }
+            catch (error) {
+                { }
+            }
+        }
+    }
+    catch (error) {
+        { }
+    }
+    return { patterns };
+}
+export async function parseCICDConfigs(projectPath) {
+    const configs = [];
+    try {
+        const files = await readdir(projectPath);
+        if (files.includes(".github")) {
+            try {
+                const workflowsPath = join(projectPath, ".github", "workflows");
+                const workflowFiles = await readdir(workflowsPath);
+                for (const file of workflowFiles) {
+                    if (file.endsWith(".yml") || file.endsWith(".yaml")) {
+                        const content = await readFile(join(workflowsPath, file), "utf-8");
+                        const commands = [];
+                        const runMatches = content.matchAll(/run:\s*(.+)/g);
+                        for (const match of runMatches) {
+                            commands.push(match[1].trim());
+                        }
+                        configs.push({
+                            type: "github-actions",
+                            commands,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                { }
+            }
+        }
+    }
+    catch (error) {
+        { }
+    }
+    return { configs };
+}
+export async function analyzeProjectContext(projectPath) {
+    const startTime = Date.now();
+    const warnings = [];
+    const categoriesCompleted = [];
+    const { manifests, warnings: manifestWarnings } = await parseManifests(projectPath);
+    warnings.push(...manifestWarnings);
+    categoriesCompleted.push("manifests");
+    const { docs, warnings: docWarnings } = await analyzeDocs(projectPath);
+    warnings.push(...docWarnings);
+    categoriesCompleted.push("docs");
+    const git = await analyzeGitHistory(projectPath);
+    warnings.push(...git.warnings);
+    categoriesCompleted.push("git");
+    const structure = await analyzeCodeStructure(projectPath);
+    warnings.push(...structure.warnings);
+    categoriesCompleted.push("structure");
+    const ignores = await parseIgnoreFiles(projectPath);
+    categoriesCompleted.push("ignores");
+    const { configs: cicd } = await parseCICDConfigs(projectPath);
+    categoriesCompleted.push("cicd");
+    const frameworks = [];
+    for (const manifest of manifests) {
+        if (manifest.type === "package.json") {
+            if (manifest.dependencies.includes("react")) {
+                frameworks.push({ name: "react", version: "", confidence: 1.0 });
+            }
+        }
+    }
+    const analysisTime = Date.now() - startTime;
+    return {
+        raw: {
+            manifests,
+            docs,
+            git,
+            structure,
+            ignores,
+            cicd,
+        },
+        insights: {
+            techStack: {
+                languages: [],
+                frameworks,
+                databases: [],
+                infrastructure: [],
+                testing: [],
+            },
+            product: {
+                targetUsers: [],
+                coreProblems: [],
+                keyFeatures: [],
+                confidence: 0.0,
+            },
+            workflow: {
+                commitConvention: git.patterns.includes("conventional") ? "conventional" : "none",
+                testingStrategy: "unknown",
+                branchStrategy: "unknown",
+                confidence: 0.5,
+            },
+            projectType: "unknown",
+            maturity: "active",
+        },
+        meta: {
+            analyzedAt: new Date().toISOString(),
+            analysisTimeMs: analysisTime,
+            filesAnalyzed: manifests.length + docs.length,
+            categoriesCompleted,
+            warnings,
+        },
+    };
+}

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

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