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

package/dist/utils/codebaseAnalysis.js

@@ -0,0 +1,429 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+/**
+ * Parse ignore files with precedence: .geminiignore > .ignore > .gitignore
+ */
+export function parseIgnoreFiles(projectPath) {
+    const ignoreFiles = ['.geminiignore', '.ignore', '.gitignore'];
+    for (const ignoreFile of ignoreFiles) {
+        const ignoreFilePath = path.join(projectPath, ignoreFile);
+        if (fs.existsSync(ignoreFilePath)) {
+            return parseIgnoreFile(ignoreFilePath);
+        }
+    }
+    return [];
+}
+/**
+ * Parse a single ignore file
+ */
+function parseIgnoreFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    const patterns = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip empty lines and comments
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        // Handle negation patterns
+        if (trimmed.startsWith('!')) {
+            patterns.push({
+                pattern: trimmed.substring(1),
+                negated: true,
+            });
+        }
+        else {
+            patterns.push({
+                pattern: trimmed,
+                negated: false,
+            });
+        }
+    }
+    return patterns;
+}
+/**
+ * Detect and parse dependency manifests
+ */
+export function detectManifests(projectPath) {
+    const manifests = [];
+    // package.json (Node.js)
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const content = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            manifests.push({
+                type: 'package.json',
+                path: packageJsonPath,
+                metadata: {
+                    name: content.name,
+                    version: content.version,
+                    description: content.description,
+                },
+                dependencies: {
+                    ...content.dependencies,
+                    ...content.devDependencies,
+                },
+            });
+        }
+        catch (error) {
+            // Malformed JSON - return partial data
+            manifests.push({
+                type: 'package.json',
+                path: packageJsonPath,
+                metadata: { error: 'Malformed JSON' },
+            });
+        }
+    }
+    // pom.xml (Maven)
+    const pomPath = path.join(projectPath, 'pom.xml');
+    if (fs.existsSync(pomPath)) {
+        const content = fs.readFileSync(pomPath, 'utf-8');
+        const groupId = content.match(/<groupId>(.*?)<\/groupId>/)?.[1];
+        const artifactId = content.match(/<artifactId>(.*?)<\/artifactId>/)?.[1];
+        const version = content.match(/<version>(.*?)<\/version>/)?.[1];
+        manifests.push({
+            type: 'pom.xml',
+            path: pomPath,
+            metadata: { groupId, artifactId, version },
+        });
+    }
+    // requirements.txt (Python)
+    const requirementsPath = path.join(projectPath, 'requirements.txt');
+    if (fs.existsSync(requirementsPath)) {
+        const content = fs.readFileSync(requirementsPath, 'utf-8');
+        const dependencies = {};
+        content.split('\n').forEach(line => {
+            const trimmed = line.trim();
+            if (trimmed && !trimmed.startsWith('#')) {
+                const match = trimmed.match(/^([^=<>]+)(==|>=|<=|>|<)(.+)$/);
+                if (match) {
+                    dependencies[match[1].trim()] = match[3].trim();
+                }
+            }
+        });
+        manifests.push({
+            type: 'requirements.txt',
+            path: requirementsPath,
+            metadata: {},
+            dependencies,
+        });
+    }
+    // go.mod (Go)
+    const goModPath = path.join(projectPath, 'go.mod');
+    if (fs.existsSync(goModPath)) {
+        const content = fs.readFileSync(goModPath, 'utf-8');
+        const moduleName = content.match(/^module\s+(.+)$/m)?.[1];
+        manifests.push({
+            type: 'go.mod',
+            path: goModPath,
+            metadata: { module: moduleName },
+        });
+    }
+    // Cargo.toml (Rust)
+    const cargoPath = path.join(projectPath, 'Cargo.toml');
+    if (fs.existsSync(cargoPath)) {
+        const content = fs.readFileSync(cargoPath, 'utf-8');
+        const name = content.match(/^\[package\][\s\S]*?name\s*=\s*"(.+?)"/m)?.[1];
+        const version = content.match(/^\[package\][\s\S]*?version\s*=\s*"(.+?)"/m)?.[1];
+        manifests.push({
+            type: 'Cargo.toml',
+            path: cargoPath,
+            metadata: { name, version },
+        });
+    }
+    // Gemfile (Ruby)
+    const gemfilePath = path.join(projectPath, 'Gemfile');
+    if (fs.existsSync(gemfilePath)) {
+        const content = fs.readFileSync(gemfilePath, 'utf-8');
+        const dependencies = {};
+        content.split('\n').forEach(line => {
+            const match = line.match(/gem\s+['"](.+?)['"](?:,\s*['"](.+?)['"])?/);
+            if (match) {
+                dependencies[match[1]] = match[2] || '*';
+            }
+        });
+        manifests.push({
+            type: 'Gemfile',
+            path: gemfilePath,
+            metadata: {},
+            dependencies,
+        });
+    }
+    return manifests;
+}
+/**
+ * Infer architecture patterns from project structure
+ */
+export function inferArchitecture(projectPath) {
+    const architectures = [];
+    // Check for monorepo indicators
+    if (fs.existsSync(path.join(projectPath, 'packages')) ||
+        fs.existsSync(path.join(projectPath, 'apps'))) {
+        architectures.push('monorepo');
+    }
+    // Check package.json workspaces
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const content = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            if (content.workspaces) {
+                architectures.push('monorepo');
+            }
+        }
+        catch (error) {
+            // Ignore malformed JSON
+        }
+    }
+    // Check for lerna.json
+    if (fs.existsSync(path.join(projectPath, 'lerna.json'))) {
+        architectures.push('monorepo');
+    }
+    // Check for microservices (multiple service directories with manifests)
+    try {
+        const entries = fs.readdirSync(projectPath, { withFileTypes: true });
+        const serviceDirs = entries.filter(e => e.isDirectory() &&
+            (e.name.includes('service') || e.name.includes('api')) &&
+            fs.existsSync(path.join(projectPath, e.name, 'package.json')));
+        if (serviceDirs.length >= 2) {
+            architectures.push('microservices');
+        }
+    }
+    catch (error) {
+        // Directory read error
+    }
+    // Check for MVC pattern
+    const hasMVC = fs.existsSync(path.join(projectPath, 'models')) &&
+        fs.existsSync(path.join(projectPath, 'views')) &&
+        fs.existsSync(path.join(projectPath, 'controllers'));
+    if (hasMVC) {
+        architectures.push('mvc');
+    }
+    // Check for Clean Architecture
+    const hasCleanArch = fs.existsSync(path.join(projectPath, 'domain')) &&
+        fs.existsSync(path.join(projectPath, 'application')) &&
+        fs.existsSync(path.join(projectPath, 'infrastructure'));
+    if (hasCleanArch) {
+        architectures.push('clean-architecture');
+    }
+    // Check for Hexagonal Architecture
+    const hasHexagonal = fs.existsSync(path.join(projectPath, 'adapters')) &&
+        fs.existsSync(path.join(projectPath, 'ports'));
+    if (hasHexagonal) {
+        architectures.push('hexagonal-architecture');
+    }
+    // Check for Layered Architecture
+    const srcPath = path.join(projectPath, 'src');
+    if (fs.existsSync(srcPath)) {
+        const hasLayered = fs.existsSync(path.join(srcPath, 'api')) &&
+            fs.existsSync(path.join(srcPath, 'services')) &&
+            fs.existsSync(path.join(srcPath, 'data'));
+        if (hasLayered) {
+            architectures.push('layered-architecture');
+        }
+    }
+    return architectures.length > 0 ? architectures : ['unknown'];
+}
+/**
+ * Detect programming languages by file extensions
+ */
+export function detectLanguages(projectPath) {
+    const languageExtensions = {
+        '.ts': 'TypeScript',
+        '.tsx': 'TypeScript',
+        '.js': 'JavaScript',
+        '.jsx': 'JavaScript',
+        '.py': 'Python',
+        '.go': 'Go',
+        '.rs': 'Rust',
+        '.rb': 'Ruby',
+        '.java': 'Java',
+    };
+    const counts = {};
+    function scanDirectory(dirPath, depth = 0) {
+        if (depth > 5)
+            return; // Limit recursion depth
+        try {
+            const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                // Skip common directories to avoid
+                if (entry.isDirectory() && ['node_modules', '.git', 'dist', 'build'].includes(entry.name)) {
+                    continue;
+                }
+                const fullPath = path.join(dirPath, entry.name);
+                if (entry.isDirectory()) {
+                    scanDirectory(fullPath, depth + 1);
+                }
+                else if (entry.isFile()) {
+                    const ext = path.extname(entry.name);
+                    const language = languageExtensions[ext];
+                    if (language) {
+                        counts[language] = (counts[language] || 0) + 1;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Permission error or other issue
+        }
+    }
+    scanDirectory(projectPath);
+    // Convert to percentages
+    const total = Object.values(counts).reduce((sum, count) => sum + count, 0);
+    if (total === 0)
+        return {};
+    const percentages = {};
+    for (const [lang, count] of Object.entries(counts)) {
+        percentages[lang] = Math.round((count / total) * 100);
+    }
+    return percentages;
+}
+/**
+ * Detect frameworks from manifests
+ */
+export function detectFrameworks(manifests) {
+    const frontend = new Set();
+    const backend = new Set();
+    const frameworkMap = {
+        'react': { type: 'frontend', name: 'React' },
+        'next': { type: 'frontend', name: 'Next.js' },
+        'vue': { type: 'frontend', name: 'Vue' },
+        'angular': { type: 'frontend', name: 'Angular' },
+        'svelte': { type: 'frontend', name: 'Svelte' },
+        'express': { type: 'backend', name: 'Express' },
+        'fastify': { type: 'backend', name: 'Fastify' },
+        'koa': { type: 'backend', name: 'Koa' },
+        'django': { type: 'backend', name: 'Django' },
+        'flask': { type: 'backend', name: 'Flask' },
+        'spring-boot': { type: 'backend', name: 'Spring Boot' },
+        'spring': { type: 'backend', name: 'Spring' },
+    };
+    for (const manifest of manifests) {
+        if (!manifest.dependencies)
+            continue;
+        for (const [depName] of Object.entries(manifest.dependencies)) {
+            const lowerDep = depName.toLowerCase();
+            for (const [key, value] of Object.entries(frameworkMap)) {
+                if (lowerDep.includes(key)) {
+                    if (value.type === 'frontend') {
+                        frontend.add(value.name);
+                    }
+                    else {
+                        backend.add(value.name);
+                    }
+                }
+            }
+        }
+    }
+    return {
+        frontend: Array.from(frontend),
+        backend: Array.from(backend),
+    };
+}
+/**
+ * Detect database drivers from manifests
+ */
+function detectDatabases(manifests) {
+    const databases = new Set();
+    const dbDrivers = {
+        'mongoose': 'MongoDB',
+        'mongodb': 'MongoDB',
+        'pg': 'PostgreSQL',
+        'postgres': 'PostgreSQL',
+        'mysql': 'MySQL',
+        'mysql2': 'MySQL',
+        'sqlite': 'SQLite',
+        'sqlite3': 'SQLite',
+        'redis': 'Redis',
+    };
+    for (const manifest of manifests) {
+        if (!manifest.dependencies)
+            continue;
+        for (const [depName] of Object.entries(manifest.dependencies)) {
+            const lowerDep = depName.toLowerCase();
+            for (const [key, value] of Object.entries(dbDrivers)) {
+                if (lowerDep.includes(key)) {
+                    databases.add(value);
+                }
+            }
+        }
+    }
+    return Array.from(databases);
+}
+/**
+ * Extract project goal from README or package.json
+ */
+function extractProjectGoal(projectPath, manifests) {
+    // Check README.md first
+    const readmePath = path.join(projectPath, 'README.md');
+    if (fs.existsSync(readmePath)) {
+        const content = fs.readFileSync(readmePath, 'utf-8');
+        // Get first paragraph after title
+        const lines = content.split('\n');
+        for (let i = 0; i < Math.min(lines.length, 10); i++) {
+            const line = lines[i].trim();
+            if (line && !line.startsWith('#') && line.length > 20) {
+                return line;
+            }
+        }
+    }
+    // Fallback to package.json description
+    const packageManifest = manifests.find(m => m.type === 'package.json');
+    if (packageManifest?.metadata?.description) {
+        return packageManifest.metadata.description;
+    }
+    return undefined;
+}
+/**
+ * Get list of files using git ls-files or fallback to manual scan
+ */
+function getFileList(projectPath) {
+    try {
+        // Try git ls-files first (faster and respects .gitignore)
+        const output = execSync('git ls-files --exclude-standard -co', {
+            cwd: projectPath,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+        return output.trim().split('\n').filter(Boolean);
+    }
+    catch (error) {
+        // Fallback to manual scan
+        return [];
+    }
+}
+/**
+ * Read file with size limit (for large files, read only first/last 20 lines)
+ */
+function readFileWithLimit(filePath, maxSize = 1024 * 1024) {
+    const stats = fs.statSync(filePath);
+    if (stats.size > maxSize) {
+        // File is too large, read only first and last 20 lines
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const first20 = lines.slice(0, 20).join('\n');
+        const last20 = lines.slice(-20).join('\n');
+        return `${first20}\n\n... (file truncated) ...\n\n${last20}`;
+    }
+    return fs.readFileSync(filePath, 'utf-8');
+}
+/**
+ * Main function: Analyze entire codebase
+ */
+export function analyzeCodebase(projectPath) {
+    const manifests = detectManifests(projectPath);
+    const languages = detectLanguages(projectPath);
+    const frameworks = detectFrameworks(manifests);
+    const databases = detectDatabases(manifests);
+    const architecture = inferArchitecture(projectPath);
+    const projectGoal = extractProjectGoal(projectPath, manifests);
+    return {
+        languages,
+        frameworks,
+        databases,
+        architecture,
+        manifests,
+        projectGoal,
+    };
+}

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

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