opencode-conductor-cdd-plugin 1.0.0-beta.18 → 1.0.0-beta.20

package/dist/utils/projectMaturity.js

@@ -0,0 +1,179 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+/**
+ * Manifest files that indicate a brownfield project
+ */
+const MANIFEST_FILES = [
+    'package.json',
+    'pom.xml',
+    'requirements.txt',
+    'go.mod',
+    'Cargo.toml',
+    'Gemfile',
+];
+/**
+ * Source directory names to check for code
+ */
+const SOURCE_DIRECTORIES = ['src', 'app', 'lib'];
+/**
+ * Code file extensions to detect
+ */
+const CODE_EXTENSIONS = ['.ts', '.js', '.py', '.go', '.rs', '.rb', '.java', '.kt', '.swift'];
+/**
+ * Version control system directories
+ */
+const VCS_DIRECTORIES = ['.git', '.svn', '.hg'];
+/**
+ * Detect project maturity (brownfield vs greenfield)
+ *
+ * A project is considered BROWNFIELD if ANY of:
+ * - Version control directory exists (.git, .svn, .hg)
+ * - Git repository is dirty (uncommitted changes)
+ * - Dependency manifests exist
+ * - Source directories contain code files
+ *
+ * A project is considered GREENFIELD only if NONE of the above are true.
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns 'brownfield' or 'greenfield'
+ */
+export function detectProjectMaturity(projectPath) {
+    // Check version control
+    const vcs = checkVersionControl(projectPath);
+    if (vcs) {
+        return 'brownfield';
+    }
+    // Check git status (dirty repository)
+    const isDirty = checkGitStatus(projectPath);
+    if (isDirty) {
+        return 'brownfield';
+    }
+    // Check for dependency manifests
+    const manifests = checkManifestFiles(projectPath);
+    if (manifests.length > 0) {
+        return 'brownfield';
+    }
+    // Check for source directories with code
+    const sourceDirs = checkSourceDirectories(projectPath);
+    if (sourceDirs.length > 0) {
+        return 'brownfield';
+    }
+    // No brownfield indicators found
+    return 'greenfield';
+}
+/**
+ * Check if git repository has uncommitted changes
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns true if repository is dirty, false otherwise
+ */
+export function checkGitStatus(projectPath) {
+    try {
+        const gitDir = path.join(projectPath, '.git');
+        if (!fs.existsSync(gitDir)) {
+            return false;
+        }
+        const output = execSync('git status --porcelain', {
+            cwd: projectPath,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'ignore'], // Suppress stderr
+        });
+        return output.trim().length > 0;
+    }
+    catch (error) {
+        // Git command failed or not a git repository
+        return false;
+    }
+}
+/**
+ * Check for dependency manifest files
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Array of found manifest file names
+ */
+export function checkManifestFiles(projectPath) {
+    const found = [];
+    for (const manifest of MANIFEST_FILES) {
+        const manifestPath = path.join(projectPath, manifest);
+        if (fs.existsSync(manifestPath)) {
+            found.push(manifest);
+        }
+    }
+    return found;
+}
+/**
+ * Check for source directories containing code files
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Array of found source directory names
+ */
+export function checkSourceDirectories(projectPath) {
+    const found = [];
+    for (const dirName of SOURCE_DIRECTORIES) {
+        const dirPath = path.join(projectPath, dirName);
+        if (!fs.existsSync(dirPath)) {
+            continue;
+        }
+        const stat = fs.statSync(dirPath);
+        if (!stat.isDirectory()) {
+            continue;
+        }
+        // Check if directory contains code files
+        if (containsCodeFiles(dirPath)) {
+            found.push(dirName);
+        }
+    }
+    return found;
+}
+/**
+ * Check if directory contains code files (recursive, depth-limited)
+ *
+ * @param dirPath - Absolute path to directory
+ * @param maxDepth - Maximum recursion depth (default: 3)
+ * @param currentDepth - Current recursion depth
+ * @returns true if code files found
+ */
+function containsCodeFiles(dirPath, maxDepth = 3, currentDepth = 0) {
+    if (currentDepth > maxDepth) {
+        return false;
+    }
+    try {
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const entryPath = path.join(dirPath, entry.name);
+            if (entry.isFile()) {
+                const ext = path.extname(entry.name);
+                if (CODE_EXTENSIONS.includes(ext)) {
+                    return true;
+                }
+            }
+            else if (entry.isDirectory()) {
+                // Recursively check subdirectories
+                if (containsCodeFiles(entryPath, maxDepth, currentDepth + 1)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    catch (error) {
+        // Permission error or other issue
+        return false;
+    }
+}
+/**
+ * Check for version control system directories
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Name of VCS directory found, or null if none found
+ */
+export function checkVersionControl(projectPath) {
+    for (const vcs of VCS_DIRECTORIES) {
+        const vcsPath = path.join(projectPath, vcs);
+        if (fs.existsSync(vcsPath)) {
+            return vcs;
+        }
+    }
+    return null;
+}

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

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

package/dist/utils/projectMaturity.test.js

@@ -0,0 +1,298 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as fs from 'fs';
+import { execSync } from 'child_process';
+import { detectProjectMaturity, checkGitStatus, checkManifestFiles, checkSourceDirectories, checkVersionControl, } from './projectMaturity.js';
+/**
+ * Project Maturity Detection Module Tests
+ *
+ * This module is responsible for determining whether a project is:
+ * - Brownfield (existing project with code/configuration)
+ * - Greenfield (new/empty project)
+ *
+ * Based on reference implementations from:
+ * - derekbar90/opencode-conductor
+ * - gemini-cli-extensions/conductor
+ */
+// Mock file system and child_process
+vi.mock('fs');
+vi.mock('child_process');
+describe('Project Maturity Detection', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('detectProjectMaturity', () => {
+        it('should detect brownfield project with .git directory', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.git');
+            });
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with dirty git repository', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.git');
+            });
+            vi.mocked(execSync).mockReturnValue('M file.txt\n');
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with package.json manifest', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('package.json');
+            });
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with pom.xml manifest', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('pom.xml');
+            });
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with requirements.txt manifest', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('requirements.txt');
+            });
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with go.mod manifest', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('go.mod');
+            });
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with src/ directory containing code', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.statSync).mockReturnValue({
+                isDirectory: () => true,
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'index.ts', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with app/ directory containing code', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().includes('/app');
+            });
+            vi.mocked(fs.statSync).mockReturnValue({
+                isDirectory: () => true,
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'main.py', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with lib/ directory containing code', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().includes('/lib');
+            });
+            vi.mocked(fs.statSync).mockReturnValue({
+                isDirectory: () => true,
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'utils.js', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with .svn directory', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.svn');
+            });
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with .hg directory', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.hg');
+            });
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect greenfield project when directory is empty', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('greenfield');
+        });
+        it('should detect greenfield project with only README.md', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('greenfield');
+        });
+        it('should detect greenfield when no brownfield indicators present', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('greenfield');
+        });
+        it('should prioritize brownfield if ANY indicator is present', () => {
+            // Only .git exists, nothing else
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.git');
+            });
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+    });
+    describe('checkGitStatus', () => {
+        it('should return true for dirty repository', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(execSync).mockReturnValue('M file.txt\n');
+            const result = checkGitStatus('/test/project');
+            expect(result).toBe(true);
+        });
+        it('should return false for clean repository', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(execSync).mockReturnValue('');
+            const result = checkGitStatus('/test/project');
+            expect(result).toBe(false);
+        });
+        it('should handle missing .git directory gracefully', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = checkGitStatus('/test/project');
+            expect(result).toBe(false);
+        });
+    });
+    describe('checkManifestFiles', () => {
+        it('should detect package.json', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('package.json');
+            });
+            const result = checkManifestFiles('/test/project');
+            expect(result).toContain('package.json');
+        });
+        it('should detect pom.xml', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('pom.xml');
+            });
+            const result = checkManifestFiles('/test/project');
+            expect(result).toContain('pom.xml');
+        });
+        it('should detect requirements.txt', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('requirements.txt');
+            });
+            const result = checkManifestFiles('/test/project');
+            expect(result).toContain('requirements.txt');
+        });
+        it('should detect go.mod', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('go.mod');
+            });
+            const result = checkManifestFiles('/test/project');
+            expect(result).toContain('go.mod');
+        });
+        it('should detect Cargo.toml', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('Cargo.toml');
+            });
+            const result = checkManifestFiles('/test/project');
+            expect(result).toContain('Cargo.toml');
+        });
+        it('should detect Gemfile', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('Gemfile');
+            });
+            const result = checkManifestFiles('/test/project');
+            expect(result).toContain('Gemfile');
+        });
+        it('should return empty array when no manifests found', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = checkManifestFiles('/test/project');
+            expect(result).toEqual([]);
+        });
+    });
+    describe('checkSourceDirectories', () => {
+        it('should detect src/ directory with .ts files', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.statSync).mockReturnValue({
+                isDirectory: () => true,
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'index.ts', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = checkSourceDirectories('/test/project');
+            expect(result).toContain('src');
+        });
+        it('should detect app/ directory with .py files', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().includes('/app');
+            });
+            vi.mocked(fs.statSync).mockReturnValue({
+                isDirectory: () => true,
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'main.py', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = checkSourceDirectories('/test/project');
+            expect(result).toContain('app');
+        });
+        it('should detect lib/ directory with .js files', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().includes('/lib');
+            });
+            vi.mocked(fs.statSync).mockReturnValue({
+                isDirectory: () => true,
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'utils.js', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = checkSourceDirectories('/test/project');
+            expect(result).toContain('lib');
+        });
+        it('should ignore empty source directories', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.statSync).mockReturnValue({
+                isDirectory: () => true,
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([]);
+            const result = checkSourceDirectories('/test/project');
+            expect(result).toEqual([]);
+        });
+        it('should ignore directories with only non-code files', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.statSync).mockReturnValue({
+                isDirectory: () => true,
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'README.md', isFile: () => true, isDirectory: () => false },
+                { name: 'notes.txt', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = checkSourceDirectories('/test/project');
+            expect(result).toEqual([]);
+        });
+    });
+    describe('checkVersionControl', () => {
+        it('should detect .git directory', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.git');
+            });
+            const result = checkVersionControl('/test/project');
+            expect(result).toBe('.git');
+        });
+        it('should detect .svn directory', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.svn');
+            });
+            const result = checkVersionControl('/test/project');
+            expect(result).toBe('.svn');
+        });
+        it('should detect .hg directory', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.hg');
+            });
+            const result = checkVersionControl('/test/project');
+            expect(result).toBe('.hg');
+        });
+        it('should return null when no VCS found', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = checkVersionControl('/test/project');
+            expect(result).toBeNull();
+        });
+    });
+});

package/dist/utils/questionGenerator.d.ts

@@ -0,0 +1,51 @@
+import { CodebaseAnalysis } from './codebaseAnalysis.js';
+/**
+ * Question Generation Engine
+ *
+ * Generates context-aware questions for the CDD setup process:
+ * - Classifies questions as Additive (multiple) or Exclusive (single choice)
+ * - Generates brownfield questions based on codebase analysis
+ * - Generates greenfield questions based on common patterns
+ * - Creates 5 answer options (A-C: contextual, D: custom, E: autogenerate)
+ *
+ * Based on reference implementations:
+ * - derekbar90/opencode-conductor
+ * - gemini-cli-extensions/conductor
+ */
+export type QuestionType = 'additive' | 'exclusive';
+export type Section = 'product' | 'guidelines' | 'tech-stack' | 'styleguides' | 'workflow';
+export interface Question {
+    id: string;
+    text: string;
+    type: QuestionType;
+    section: Section;
+    options: string[];
+}
+/**
+ * Classify question type based on question text
+ */
+export declare function classifyQuestionType(questionText: string): QuestionType;
+/**
+ * Add suffix to question text based on type
+ */
+export declare function addQuestionSuffix(questionText: string, type: QuestionType): string;
+/**
+ * Generate brownfield questions based on codebase analysis
+ */
+export declare function generateBrownfieldQuestions(section: Section, analysis: CodebaseAnalysis): Question[];
+/**
+ * Generate greenfield questions based on common patterns
+ */
+export declare function generateGreenfieldQuestions(section: Section): Question[];
+/**
+ * Generate answer options (always 5 options: A-C contextual, D custom, E autogenerate)
+ */
+export declare function generateAnswerOptions(contextualOptions: string[], section: Section): string[];
+/**
+ * Format question for display with lettered options
+ */
+export declare function formatQuestion(question: Question, questionNumber: number): string;
+/**
+ * Main function: Generate questions for a section
+ */
+export declare function generateQuestionsForSection(section: Section, projectMaturity: 'brownfield' | 'greenfield', codebaseAnalysis?: CodebaseAnalysis): Question[];