erosolar-cli 2.0.5 → 2.1.2

package/dist/tools/enhancedDevWorkflowTools.js

@@ -1,31 +1,25 @@
 /**
  * Enhanced Development Workflow Tools
- * Advanced development workflow combining code intelligence, testing, and quality improvements
+ * Real workflow runners that measure build/test/lint quality gates and scaffold CI.
  */
-export function createEnhancedDevWorkflowTools(_workingDir) {
+import { exec } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
+const DEFAULT_TIMEOUT_MS = 300_000; // 5 minutes per step
+export function createEnhancedDevWorkflowTools(workingDir) {
     return [
         {
             name: 'run_comprehensive_workflow',
-            description: 'Run comprehensive development workflow including build, test, lint, and quality checks.',
+            description: 'Run build, test, lint, and quality gates with timing + output summaries.',
             parameters: {
                 type: 'object',
                 properties: {
-                    includeBuild: {
-                        type: 'boolean',
-                        description: 'Include build step (default: true).',
-                    },
-                    includeTests: {
-                        type: 'boolean',
-                        description: 'Include test execution (default: true).',
-                    },
-                    includeLint: {
-                        type: 'boolean',
-                        description: 'Include linting (default: true).',
-                    },
-                    includeQuality: {
-                        type: 'boolean',
-                        description: 'Include quality checks (default: true).',
-                    },
+                    includeBuild: { type: 'boolean', description: 'Run build script if present (default: true).' },
+                    includeTests: { type: 'boolean', description: 'Run test script if present (default: true).' },
+                    includeLint: { type: 'boolean', description: 'Run lint script if present (default: true).' },
+                    includeQuality: { type: 'boolean', description: 'Run quality gate script if present (default: true).' },
                     timeout: {
                         type: 'number',
                         description: 'Timeout per step in milliseconds (default: 300000).',
@@ -34,72 +28,65 @@ export function createEnhancedDevWorkflowTools(_workingDir) {
                 additionalProperties: false,
             },
             handler: async (args) => {
-                const includeBuild = args['includeBuild'] ?? true;
-                const includeTests = args['includeTests'] ?? true;
-                const includeLint = args['includeLint'] ?? true;
-                const includeQuality = args['includeQuality'] ?? true;
-                const timeout = args['timeout'] ?? 300000;
-                return runComprehensiveWorkflow({
-                    includeBuild,
-                    includeTests,
-                    includeLint,
-                    includeQuality,
-                    timeout,
+                const timeout = args['timeout'] ?? DEFAULT_TIMEOUT_MS;
+                const steps = collectWorkflowSteps(workingDir, {
+                    includeBuild: args['includeBuild'] !== false,
+                    includeTests: args['includeTests'] !== false,
+                    includeLint: args['includeLint'] !== false,
+                    includeQuality: args['includeQuality'] !== false,
                 });
+                return runWorkflowSteps(steps, workingDir, timeout);
             },
         },
         {
             name: 'analyze_workflow_performance',
-            description: 'Analyze development workflow performance and identify bottlenecks.',
+            description: 'Measure workflow step durations to identify bottlenecks.',
             parameters: {
                 type: 'object',
                 properties: {
                     iterations: {
                         type: 'number',
-                        description: 'Number of iterations to analyze (default: 3).',
+                        description: 'Number of runs to average (max 3, default: 1).',
                     },
                 },
                 additionalProperties: false,
             },
             handler: async (args) => {
-                const iterations = args['iterations'] ?? 3;
-                return analyzeWorkflowPerformance(iterations);
+                const iterations = Math.min(3, Math.max(1, Number(args['iterations'] ?? 1)));
+                return analyzeWorkflowPerformance(workingDir, iterations);
             },
         },
         {
             name: 'optimize_development_workflow',
-            description: 'Optimize development workflow with caching, parallel execution, and performance improvements.',
+            description: 'Generate optimization recommendations; optionally write them to .intelligence.',
             parameters: {
                 type: 'object',
                 properties: {
                     strategy: {
                         type: 'string',
                         enum: ['caching', 'parallel', 'incremental', 'all'],
-                        description: 'Optimization strategy (default: all).',
+                        description: 'Optimization strategy focus (default: all).',
                     },
                     preview: {
                         type: 'boolean',
-                        description: 'Show preview without applying changes (default: true).',
+                        description: 'If false, writes recommendations to .intelligence/workflow-optimizations.md.',
                     },
                 },
                 additionalProperties: false,
             },
             handler: async (args) => {
                 const strategy = args['strategy'] ?? 'all';
-                const preview = args['preview'] ?? true;
-                return optimizeDevelopmentWorkflow(strategy, preview);
+                const preview = args['preview'] !== false;
+                return optimizeDevelopmentWorkflow(workingDir, strategy, preview);
             },
         },
         {
             name: 'generate_workflow_report',
-            description: 'Generate comprehensive development workflow report with metrics and recommendations.',
+            description: 'Summarize available scripts, lockfiles, CI config, and quick recommendations.',
             parameters: {
                 type: 'object',
                 properties: {
-                    includeMetrics: {
-                        type: 'boolean',
-                        description: 'Include performance metrics (default: true).',
-                    },
+                    includeMetrics: { type: 'boolean', description: 'Include script availability and lockfile info (default: true).' },
                     includeRecommendations: {
                         type: 'boolean',
                         description: 'Include optimization recommendations (default: true).',
@@ -108,14 +95,14 @@ export function createEnhancedDevWorkflowTools(_workingDir) {
                 additionalProperties: false,
             },
             handler: async (args) => {
-                const includeMetrics = args['includeMetrics'] ?? true;
-                const includeRecommendations = args['includeRecommendations'] ?? true;
-                return generateWorkflowReport(includeMetrics, includeRecommendations);
+                const includeMetrics = args['includeMetrics'] !== false;
+                const includeRecommendations = args['includeRecommendations'] !== false;
+                return generateWorkflowReport(workingDir, includeMetrics, includeRecommendations);
             },
         },
         {
             name: 'setup_ci_cd_workflow',
-            description: 'Setup CI/CD workflow configuration for automated testing and deployment.',
+            description: 'Scaffold CI/CD workflow (GitHub Actions/GitLab/Azure/CircleCI).',
             parameters: {
                 type: 'object',
                 properties: {
@@ -126,178 +113,319 @@ export function createEnhancedDevWorkflowTools(_workingDir) {
                     },
                     includeQualityGates: {
                         type: 'boolean',
-                        description: 'Include quality gates (default: true).',
+                        description: 'Include quality gate steps when scripts exist (default: true).',
                     },
                     includeDeployment: {
                         type: 'boolean',
-                        description: 'Include deployment steps (default: false).',
+                        description: 'Include deploy placeholder step (default: false).',
                     },
                     preview: {
                         type: 'boolean',
-                        description: 'Show preview without applying changes (default: true).',
+                        description: 'Show workflow yaml instead of writing it (default: true).',
                     },
                 },
                 additionalProperties: false,
             },
             handler: async (args) => {
                 const platform = args['platform'] ?? 'github';
-                const includeQualityGates = args['includeQualityGates'] ?? true;
-                const includeDeployment = args['includeDeployment'] ?? false;
-                const preview = args['preview'] ?? true;
-                return setupCiCdWorkflow(platform, includeQualityGates, includeDeployment, preview);
+                const includeQualityGates = args['includeQualityGates'] !== false;
+                const includeDeployment = args['includeDeployment'] === true;
+                const preview = args['preview'] !== false;
+                return setupCiCdWorkflow({
+                    workingDir,
+                    platform,
+                    includeQualityGates,
+                    includeDeployment,
+                    preview,
+                });
             },
         },
     ];
 }
-async function runComprehensiveWorkflow(options) {
-    const output = [];
-    output.push('# Comprehensive Development Workflow');
-    output.push('');
-    output.push('🔧 Running development workflow with:');
-    output.push(`- Build: ${options.includeBuild ? 'Yes' : 'No'}`);
-    output.push(`- Tests: ${options.includeTests ? 'Yes' : 'No'}`);
-    output.push(`- Lint: ${options.includeLint ? 'Yes' : 'No'}`);
-    output.push(`- Quality: ${options.includeQuality ? 'Yes' : 'No'}`);
-    output.push('');
+function readPackageJson(workingDir) {
+    const packageJsonPath = join(workingDir, 'package.json');
+    if (!existsSync(packageJsonPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    }
+    catch (error) {
+        return null;
+    }
+}
+function collectWorkflowSteps(workingDir, options) {
+    const pkg = readPackageJson(workingDir);
+    const scripts = pkg?.['scripts'] ?? {};
     const steps = [];
     if (options.includeBuild) {
-        steps.push('npm run build');
+        if (scripts['build']) {
+            steps.push({ name: 'build', command: 'npm run build' });
+        }
+        else {
+            steps.push({ name: 'build', skipReason: 'package.json lacks a build script' });
+        }
     }
     if (options.includeTests) {
-        steps.push('npm test');
+        if (scripts['test']) {
+            steps.push({ name: 'test', command: 'npm test' });
+        }
+        else {
+            steps.push({ name: 'test', skipReason: 'package.json lacks a test script' });
+        }
     }
     if (options.includeLint) {
-        steps.push('npm run lint');
+        if (scripts['lint']) {
+            steps.push({ name: 'lint', command: 'npm run lint' });
+        }
+        else {
+            steps.push({ name: 'lint', skipReason: 'package.json lacks a lint script' });
+        }
     }
     if (options.includeQuality) {
-        steps.push('npm run quality-gate');
+        const qualityScript = scripts['quality-gate'] || scripts['quality'] || scripts['quality-check'] || scripts['quality:check'];
+        if (qualityScript) {
+            steps.push({ name: 'quality', command: `npm run ${qualityScript.includes('quality') ? qualityScript : 'quality-gate'}` });
+        }
+        else {
+            steps.push({ name: 'quality', skipReason: 'No quality gate script (quality-gate|quality|quality-check)' });
+        }
     }
-    output.push('## Workflow Steps');
-    steps.forEach((step, index) => {
-        output.push(`${index + 1}. ${step}`);
+    return steps;
+}
+async function runWorkflowSteps(steps, workingDir, timeoutMs) {
+    const results = [];
+    for (const step of steps) {
+        if (!step.command) {
+            results.push({ name: step.name, status: 'skipped', error: step.skipReason });
+            continue;
+        }
+        const start = Date.now();
+        try {
+            const { stdout, stderr } = await execAsync(step.command, {
+                cwd: workingDir,
+                timeout: timeoutMs,
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            results.push({
+                name: step.name,
+                status: 'passed',
+                durationMs: Date.now() - start,
+                output: [stdout, stderr].filter(Boolean).join('\n').trim(),
+            });
+        }
+        catch (error) {
+            results.push({
+                name: step.name,
+                status: 'failed',
+                durationMs: Date.now() - start,
+                output: [error?.stdout, error?.stderr].filter(Boolean).join('\n').trim(),
+                error: error?.message || 'Unknown error',
+            });
+        }
+    }
+    return formatWorkflowResults(results);
+}
+function formatWorkflowResults(results) {
+    const output = [];
+    output.push('# Workflow Results');
+    const summary = { passed: 0, failed: 0, skipped: 0 };
+    results.forEach((result) => {
+        summary[result.status]++;
+        const duration = result.durationMs ? ` (${renderDuration(result.durationMs)})` : '';
+        output.push(`- ${result.name}: ${result.status}${duration}`);
+        if (result.error) {
+            output.push(`  Error: ${result.error}`);
+        }
     });
     output.push('');
-    output.push('💡 This workflow ensures code quality and prevents regressions.');
+    output.push(`Summary: passed ${summary.passed}, failed ${summary.failed}, skipped ${summary.skipped}`);
     return output.join('\n');
 }
-async function analyzeWorkflowPerformance(iterations) {
+async function analyzeWorkflowPerformance(workingDir, iterations) {
+    const runnableSteps = collectWorkflowSteps(workingDir, {
+        includeBuild: true,
+        includeTests: true,
+        includeLint: true,
+        includeQuality: false,
+    }).filter((step) => Boolean(step.command));
+    if (runnableSteps.length === 0) {
+        return 'No runnable workflow steps found (build/test/lint scripts missing).';
+    }
+    const durations = Object.fromEntries(runnableSteps.map((s) => [s.name, []]));
+    for (let i = 0; i < iterations; i++) {
+        for (const step of runnableSteps) {
+            const start = Date.now();
+            try {
+                await execAsync(step.command, {
+                    cwd: workingDir,
+                    timeout: DEFAULT_TIMEOUT_MS,
+                    maxBuffer: 10 * 1024 * 1024,
+                });
+                durations[step.name]?.push(Date.now() - start);
+            }
+            catch (error) {
+                durations[step.name]?.push(Date.now() - start);
+            }
+        }
+    }
     const output = [];
-    output.push('# Workflow Performance Analysis');
-    output.push('');
-    output.push(`📊 Analyzing ${iterations} iterations of development workflow`);
+    output.push('# Workflow Performance');
+    output.push(`Iterations: ${iterations}`);
     output.push('');
-    output.push('## Performance Metrics');
-    output.push('- Build execution time');
-    output.push('- Test execution time');
-    output.push('- Lint execution time');
-    output.push('- Memory usage patterns');
-    output.push('- CPU utilization');
-    output.push('- I/O bottlenecks');
+    Object.entries(durations).forEach(([name, times]) => {
+        const avg = times.reduce((a, b) => a + b, 0) / times.length;
+        const worst = Math.max(...times);
+        output.push(`${name}: avg ${renderDuration(avg)}, worst ${renderDuration(worst)} across ${times.length} run(s)`);
+    });
     output.push('');
-    output.push('## Optimization Opportunities');
-    output.push('- Parallel test execution');
-    output.push('- Build caching strategies');
-    output.push('- Incremental compilation');
-    output.push('- Dependency optimization');
+    output.push('Use `run_comprehensive_workflow` to see full output and failures.');
     return output.join('\n');
 }
-async function optimizeDevelopmentWorkflow(strategy, preview) {
-    const output = [];
-    output.push('# Development Workflow Optimization');
-    output.push('');
-    output.push(`🎯 Strategy: ${strategy}`);
-    output.push(`👁️ Preview mode: ${preview ? 'ON' : 'OFF'}`);
-    output.push('');
-    output.push('## Optimization Features');
+function optimizeDevelopmentWorkflow(workingDir, strategy, preview) {
+    const pkg = readPackageJson(workingDir);
+    const scripts = pkg?.['scripts'] ?? {};
+    const lockFile = detectLockfile(workingDir);
+    const suggestions = [];
     if (strategy === 'caching' || strategy === 'all') {
-        output.push('### Caching');
-        output.push('- Build cache configuration');
-        output.push('- Test cache optimization');
-        output.push('- Dependency caching');
-        output.push('- Cache invalidation strategies');
+        suggestions.push(lockFile ? `Use ${lockFile} with CI cache (cache node_modules + ${lockFile}).` : 'Add a lockfile (npm ci) for repeatable installs.');
+        suggestions.push('Enable Jest/TS incremental caches with persistent cache directories in CI.');
+        suggestions.push('Reuse build artifacts between lint/test when possible (e.g., tsc --incremental).');
     }
     if (strategy === 'parallel' || strategy === 'all') {
-        output.push('### Parallel Execution');
-        output.push('- Parallel test execution');
-        output.push('- Concurrent build steps');
-        output.push('- Worker pool optimization');
-        output.push('- Resource allocation');
+        suggestions.push('Run lint and tests in parallel jobs (matrix or background runs).');
+        suggestions.push('Prefer --maxWorkers for Jest/ts-jest to fully utilize CPUs.');
     }
     if (strategy === 'incremental' || strategy === 'all') {
-        output.push('### Incremental Processing');
-        output.push('- Incremental compilation');
-        output.push('- Changed file detection');
-        output.push('- Smart rebuild triggers');
-        output.push('- Partial test execution');
+        suggestions.push('Use incremental TypeScript builds (tsc --incremental) and cache .tsbuildinfo.');
+        if (scripts['build']?.includes('--watch') || scripts['dev']?.includes('--watch')) {
+            suggestions.push('Adopt watch-mode for local dev to avoid full rebuilds.');
+        }
     }
-    if (preview) {
+    const output = [];
+    output.push('# Workflow Optimization Recommendations');
+    suggestions.forEach((s, idx) => output.push(`${idx + 1}. ${s}`));
+    if (!preview) {
+        const outDir = join(workingDir, '.intelligence');
+        mkdirSync(outDir, { recursive: true });
+        const outFile = join(outDir, 'workflow-optimizations.md');
+        writeFileSync(outFile, output.join('\n'), 'utf-8');
         output.push('');
-        output.push('💡 Run with `preview: false` to apply optimization changes.');
+        output.push(`Recommendations saved to ${outFile}`);
     }
     return output.join('\n');
 }
-async function generateWorkflowReport(includeMetrics, includeRecommendations) {
+function generateWorkflowReport(workingDir, includeMetrics, includeRecommendations) {
+    const pkg = readPackageJson(workingDir);
+    const scripts = pkg?.['scripts'] ?? {};
+    const lockFile = detectLockfile(workingDir);
+    const hasCi = existsSync(join(workingDir, '.github', 'workflows')) || existsSync(join(workingDir, '.gitlab-ci.yml'));
     const output = [];
     output.push('# Development Workflow Report');
-    output.push('');
     if (includeMetrics) {
-        output.push('## Performance Metrics');
-        output.push('- Build time: [measurement]');
-        output.push('- Test time: [measurement]');
-        output.push('- Lint time: [measurement]');
-        output.push('- Quality check time: [measurement]');
-        output.push('- Total workflow time: [measurement]');
+        output.push('## Script availability');
+        output.push(`- build: ${scripts['build'] ? 'present' : 'missing'}`);
+        output.push(`- test: ${scripts['test'] ? 'present' : 'missing'}`);
+        output.push(`- lint: ${scripts['lint'] ? 'present' : 'missing'}`);
+        output.push(`- quality: ${scripts['quality-gate'] || scripts['quality'] || scripts['quality-check'] || scripts['quality:check'] ? 'present' : 'missing'}`);
+        output.push('');
+        output.push(`Lockfile: ${lockFile ?? 'none detected'}`);
+        output.push(`CI config present: ${hasCi ? 'yes' : 'no'}`);
         output.push('');
     }
     if (includeRecommendations) {
-        output.push('## Optimization Recommendations');
-        output.push('- Enable build caching');
-        output.push('- Configure parallel test execution');
-        output.push('- Implement incremental compilation');
-        output.push('- Optimize dependency installation');
-        output.push('- Setup CI/CD pipeline');
-        output.push('');
+        output.push('## Recommendations');
+        if (!scripts['build'])
+            output.push('- Add a build script to enforce consistent artifacts.');
+        if (!scripts['test'])
+            output.push('- Add a test script to unblock automation.');
+        if (!scripts['lint'])
+            output.push('- Add a lint script with ESLint/biome for static checks.');
+        if (!lockFile)
+            output.push('- Commit a lockfile and use npm ci/pnpm i --frozen-lockfile in CI.');
+        if (!hasCi)
+            output.push('- Add CI (see setup_ci_cd_workflow) for automated gates.');
     }
-    output.push('## Quality Metrics');
-    output.push('- Code coverage: [percentage]');
-    output.push('- Complexity score: [score]');
-    output.push('- Lint warnings: [count]');
-    output.push('- Type safety: [score]');
-    output.push('- Maintainability: [score]');
     return output.join('\n');
 }
-async function setupCiCdWorkflow(platform, includeQualityGates, includeDeployment, preview) {
-    const output = [];
-    output.push('# CI/CD Workflow Setup');
-    output.push('');
-    output.push(`🏗️ Platform: ${platform}`);
-    output.push(`📊 Quality Gates: ${includeQualityGates ? 'Yes' : 'No'}`);
-    output.push(`🚀 Deployment: ${includeDeployment ? 'Yes' : 'No'}`);
-    output.push(`👁️ Preview mode: ${preview ? 'ON' : 'OFF'}`);
-    output.push('');
-    output.push('## Workflow Configuration');
-    output.push('- Automated testing');
-    output.push('- Code quality checks');
-    output.push('- Security scanning');
-    output.push('- Build verification');
-    if (includeQualityGates) {
-        output.push('### Quality Gates');
-        output.push('- Test coverage requirements');
-        output.push('- Complexity thresholds');
-        output.push('- Lint rule enforcement');
-        output.push('- Security vulnerability checks');
+function detectLockfile(workingDir) {
+    if (existsSync(join(workingDir, 'package-lock.json')))
+        return 'package-lock.json';
+    if (existsSync(join(workingDir, 'pnpm-lock.yaml')))
+        return 'pnpm-lock.yaml';
+    if (existsSync(join(workingDir, 'yarn.lock')))
+        return 'yarn.lock';
+    return null;
+}
+function renderDuration(ms) {
+    return `${Math.round(ms)}ms`;
+}
+async function setupCiCdWorkflow(options) {
+    const pkg = readPackageJson(options.workingDir);
+    const scripts = pkg?.['scripts'] ?? {};
+    const lockFile = detectLockfile(options.workingDir);
+    // Currently generate GitHub Actions YAML; other platforms return guidance.
+    if (options.platform !== 'github') {
+        return `Only GitHub Actions scaffolding is implemented. For ${options.platform}, create equivalent jobs for install/build/test/lint.`;
     }
-    if (includeDeployment) {
-        output.push('### Deployment Steps');
-        output.push('- Environment configuration');
-        output.push('- Deployment strategies');
-        output.push('- Rollback procedures');
-        output.push('- Monitoring setup');
+    const yaml = buildGithubWorkflowYaml({
+        scripts,
+        lockFile,
+        includeQualityGates: options.includeQualityGates,
+        includeDeployment: options.includeDeployment,
+    });
+    if (options.preview) {
+        return ['# GitHub Actions workflow (preview)', yaml].join('\n');
     }
-    if (preview) {
-        output.push('');
-        output.push('💡 Run with `preview: false` to create CI/CD configuration files.');
+    const workflowDir = join(options.workingDir, '.github', 'workflows');
+    mkdirSync(workflowDir, { recursive: true });
+    const workflowPath = join(workflowDir, 'erosolar-ci.yml');
+    writeFileSync(workflowPath, yaml, 'utf-8');
+    return `Workflow written to ${workflowPath}`;
+}
+function buildGithubWorkflowYaml(options) {
+    const runInstall = options.lockFile === 'pnpm-lock.yaml'
+        ? 'pnpm install --frozen-lockfile'
+        : options.lockFile === 'yarn.lock'
+            ? 'yarn install --frozen-lockfile'
+            : 'npm ci';
+    const steps = [
+        'name: Erosolar CI',
+        'on:',
+        '  push:',
+        '    branches: [ main, master ]',
+        '  pull_request:',
+        '    branches: [ main, master ]',
+        'jobs:',
+        '  build-test:',
+        '    runs-on: ubuntu-latest',
+        '    steps:',
+        '      - uses: actions/checkout@v4',
+        '      - uses: actions/setup-node@v4',
+        '        with:',
+        '          node-version: 20',
+        '          cache: npm',
+        `      - name: Install dependencies`,
+        `        run: ${runInstall}`,
+    ];
+    if (options.scripts['build']) {
+        steps.push('      - name: Build', '        run: npm run build');
     }
-    return output.join('\n');
+    if (options.scripts['test']) {
+        steps.push('      - name: Test', '        run: npm test');
+    }
+    if (options.scripts['lint']) {
+        steps.push('      - name: Lint', '        run: npm run lint');
+    }
+    if (options.includeQualityGates) {
+        const qualityScript = options.scripts['quality-gate'] || options.scripts['quality'] || options.scripts['quality-check'] || options.scripts['quality:check'];
+        if (qualityScript) {
+            steps.push('      - name: Quality Gate', `        run: npm run ${qualityScript}`);
+        }
+    }
+    if (options.includeDeployment) {
+        steps.push('      - name: Deploy', '        run: echo "Add deployment steps here"');
+    }
+    return steps.join('\n');
 }
 //# sourceMappingURL=enhancedDevWorkflowTools.js.map