erosolar-cli 1.7.373 → 1.7.379

package/dist/core/intelligentTestFlows.js

@@ -0,0 +1,678 @@
+/**
+ * Intelligent Test Flow Generator
+ *
+ * Creates highly complex, intelligent test flows for runtime verification:
+ * - Edge case detection and generation
+ * - State machine exploration
+ * - Fuzzing with smart mutations
+ * - Regression test generation
+ * - UI interaction simulation
+ *
+ * Principal Investigator: Bo Shang
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
+import { join, basename, relative } from 'node:path';
+import { homedir } from 'node:os';
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+const TEST_FLOWS_DIR = join(homedir(), '.erosolar', 'test-flows');
+const BUG_REPORTS_DIR = join(homedir(), '.erosolar', 'bug-reports');
+const UI_UPDATES_FILE = join(homedir(), '.erosolar', 'ui-updates.json');
+// Edge case categories
+const EDGE_CASE_CATEGORIES = {
+    boundary: ['empty', 'null', 'undefined', 'zero', 'negative', 'max-int', 'min-int', 'overflow'],
+    string: ['empty-string', 'whitespace', 'unicode', 'emoji', 'very-long', 'special-chars', 'html-injection', 'sql-injection'],
+    array: ['empty-array', 'single-item', 'large-array', 'nested', 'circular-ref', 'mixed-types'],
+    async: ['timeout', 'race-condition', 'concurrent', 'retry-exhausted', 'network-error'],
+    state: ['uninitialized', 'partially-initialized', 'corrupted', 'stale', 'locked'],
+    file: ['not-found', 'permission-denied', 'corrupted', 'locked', 'symlink', 'very-large'],
+};
+// ============================================================================
+// EDGE CASE GENERATOR
+// ============================================================================
+/**
+ * Generate edge cases for a given function/component
+ */
+export function generateEdgeCases(targetName, paramTypes) {
+    const edgeCases = [];
+    let idCounter = 0;
+    for (const [param, type] of Object.entries(paramTypes)) {
+        const cases = getEdgeCasesForType(type);
+        for (const edgeCase of cases) {
+            edgeCases.push({
+                id: `${targetName}_edge_${++idCounter}`,
+                category: edgeCase.category,
+                description: `${param}: ${edgeCase.description}`,
+                input: { [param]: edgeCase.value },
+                expectedBehavior: edgeCase.expectedBehavior,
+                severity: edgeCase.severity,
+                detected: false,
+            });
+        }
+    }
+    return edgeCases;
+}
+function getEdgeCasesForType(type) {
+    const cases = [];
+    switch (type.toLowerCase()) {
+        case 'string':
+            cases.push({ category: 'boundary', description: 'empty string', value: '', expectedBehavior: 'Handle gracefully', severity: 'medium' }, { category: 'boundary', description: 'null', value: null, expectedBehavior: 'Reject or default', severity: 'high' }, { category: 'string', description: 'whitespace only', value: '   ', expectedBehavior: 'Trim or reject', severity: 'low' }, { category: 'string', description: 'unicode', value: '你好世界🌍', expectedBehavior: 'Handle correctly', severity: 'medium' }, { category: 'string', description: 'very long', value: 'x'.repeat(10000), expectedBehavior: 'Truncate or reject', severity: 'high' }, { category: 'string', description: 'special chars', value: '<script>alert(1)</script>', expectedBehavior: 'Escape or reject', severity: 'critical' }, { category: 'string', description: 'path traversal', value: '../../../etc/passwd', expectedBehavior: 'Reject', severity: 'critical' });
+            break;
+        case 'number':
+            cases.push({ category: 'boundary', description: 'zero', value: 0, expectedBehavior: 'Handle zero case', severity: 'medium' }, { category: 'boundary', description: 'negative', value: -1, expectedBehavior: 'Validate range', severity: 'medium' }, { category: 'boundary', description: 'max safe int', value: Number.MAX_SAFE_INTEGER, expectedBehavior: 'Handle large numbers', severity: 'high' }, { category: 'boundary', description: 'infinity', value: Infinity, expectedBehavior: 'Reject or handle', severity: 'high' }, { category: 'boundary', description: 'NaN', value: NaN, expectedBehavior: 'Reject NaN', severity: 'high' }, { category: 'boundary', description: 'float precision', value: 0.1 + 0.2, expectedBehavior: 'Handle float precision', severity: 'low' });
+            break;
+        case 'array':
+            cases.push({ category: 'array', description: 'empty array', value: [], expectedBehavior: 'Handle empty', severity: 'medium' }, { category: 'array', description: 'single item', value: [1], expectedBehavior: 'Handle single', severity: 'low' }, { category: 'array', description: 'large array', value: Array(10000).fill(0), expectedBehavior: 'Handle efficiently', severity: 'high' }, { category: 'array', description: 'null in array', value: [1, null, 3], expectedBehavior: 'Filter or handle', severity: 'medium' }, { category: 'array', description: 'undefined in array', value: [1, undefined, 3], expectedBehavior: 'Filter or handle', severity: 'medium' });
+            break;
+        case 'object':
+            cases.push({ category: 'boundary', description: 'null object', value: null, expectedBehavior: 'Reject or default', severity: 'high' }, { category: 'boundary', description: 'empty object', value: {}, expectedBehavior: 'Handle empty', severity: 'medium' }, { category: 'state', description: 'missing required', value: { partial: true }, expectedBehavior: 'Validate schema', severity: 'high' }, { category: 'array', description: 'deeply nested', value: { a: { b: { c: { d: { e: {} } } } } }, expectedBehavior: 'Handle depth', severity: 'medium' });
+            break;
+        default:
+            cases.push({ category: 'boundary', description: 'null', value: null, expectedBehavior: 'Handle null', severity: 'high' }, { category: 'boundary', description: 'undefined', value: undefined, expectedBehavior: 'Handle undefined', severity: 'high' });
+    }
+    return cases;
+}
+// ============================================================================
+// TEST FLOW GENERATOR
+// ============================================================================
+/**
+ * Generate intelligent test flows for a component
+ */
+export function generateTestFlows(workingDir, targetPath) {
+    const flows = [];
+    const fullPath = join(workingDir, targetPath);
+    if (!existsSync(fullPath)) {
+        return flows;
+    }
+    const content = readFileSync(fullPath, 'utf-8');
+    const fileName = basename(targetPath, '.ts');
+    // Extract function signatures
+    const functionMatches = content.matchAll(/(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/g);
+    for (const match of functionMatches) {
+        const funcName = match[1];
+        const params = parseParams(match[2] ?? '');
+        // Generate basic flow
+        flows.push(createBasicTestFlow(fileName, funcName, params));
+        // Generate edge case flows
+        flows.push(...createEdgeCaseFlows(fileName, funcName, params));
+        // Generate stress test flow
+        if (params.length > 0) {
+            flows.push(createStressTestFlow(fileName, funcName, params));
+        }
+    }
+    // Extract class methods
+    const classMatches = content.matchAll(/(?:async\s+)?(\w+)\s*\(([^)]*)\)\s*(?::\s*[^{]+)?\s*\{/g);
+    for (const match of classMatches) {
+        const methodName = match[1];
+        if (methodName === 'constructor' || methodName.startsWith('_'))
+            continue;
+        const params = parseParams(match[2] ?? '');
+        flows.push(createBasicTestFlow(fileName, methodName, params));
+    }
+    return flows;
+}
+function parseParams(paramStr) {
+    if (!paramStr.trim())
+        return [];
+    const params = [];
+    const parts = paramStr.split(',');
+    for (const part of parts) {
+        const match = part.match(/(\w+)\s*[?]?\s*:\s*([^=,]+)/);
+        if (match) {
+            params.push({
+                name: match[1].trim(),
+                type: match[2].trim(),
+            });
+        }
+    }
+    return params;
+}
+function createBasicTestFlow(fileName, funcName, params) {
+    const steps = [];
+    // Setup step
+    steps.push({
+        order: 1,
+        action: 'setup',
+        input: {},
+        assertions: [],
+    });
+    // Execution step
+    const input = {};
+    for (const param of params) {
+        input[param.name] = getDefaultValue(param.type);
+    }
+    steps.push({
+        order: 2,
+        action: `call ${funcName}`,
+        input,
+        assertions: [
+            { type: 'resolves', target: 'result', message: 'Function should complete' },
+        ],
+    });
+    // Verification step
+    steps.push({
+        order: 3,
+        action: 'verify',
+        assertions: [
+            { type: 'truthy', target: 'result', message: 'Result should be defined' },
+        ],
+    });
+    return {
+        id: `${fileName}_${funcName}_basic`,
+        name: `${funcName} - Basic Test`,
+        description: `Verify basic functionality of ${funcName}`,
+        category: 'unit',
+        steps,
+        preconditions: ['Module is loaded'],
+        postconditions: ['No side effects'],
+        expectedOutcome: 'Function executes successfully',
+        complexity: 'simple',
+        priority: 50,
+        generatedAt: new Date().toISOString(),
+    };
+}
+function createEdgeCaseFlows(fileName, funcName, params) {
+    const flows = [];
+    for (const param of params) {
+        const edgeCases = getEdgeCasesForType(param.type);
+        for (const edge of edgeCases.slice(0, 3)) { // Limit to top 3 per param
+            const steps = [
+                {
+                    order: 1,
+                    action: `call ${funcName} with ${edge.description}`,
+                    input: { [param.name]: edge.value },
+                    assertions: [
+                        { type: edge.severity === 'critical' ? 'throws' : 'resolves', target: 'result' },
+                    ],
+                },
+            ];
+            flows.push({
+                id: `${fileName}_${funcName}_edge_${param.name}_${edge.category}`,
+                name: `${funcName} - Edge: ${edge.description}`,
+                description: `Test ${funcName} with ${edge.description} for ${param.name}`,
+                category: 'edge-case',
+                steps,
+                preconditions: [],
+                postconditions: [],
+                expectedOutcome: edge.expectedBehavior,
+                complexity: 'moderate',
+                priority: edge.severity === 'critical' ? 90 : edge.severity === 'high' ? 70 : 50,
+                generatedAt: new Date().toISOString(),
+            });
+        }
+    }
+    return flows;
+}
+function createStressTestFlow(fileName, funcName, params) {
+    const iterations = 1000;
+    const steps = [];
+    for (let i = 0; i < 5; i++) {
+        const input = {};
+        for (const param of params) {
+            input[param.name] = getRandomValue(param.type);
+        }
+        steps.push({
+            order: i + 1,
+            action: `stress iteration ${i + 1}`,
+            input,
+            timeout: 5000,
+            assertions: [
+                { type: 'resolves', target: 'result' },
+            ],
+        });
+    }
+    return {
+        id: `${fileName}_${funcName}_stress`,
+        name: `${funcName} - Stress Test`,
+        description: `Stress test ${funcName} with random inputs`,
+        category: 'stress',
+        steps,
+        preconditions: [],
+        postconditions: ['No memory leaks', 'Consistent performance'],
+        expectedOutcome: 'Function handles load without degradation',
+        complexity: 'extreme',
+        priority: 60,
+        generatedAt: new Date().toISOString(),
+    };
+}
+function getDefaultValue(type) {
+    switch (type.toLowerCase()) {
+        case 'string': return 'test';
+        case 'number': return 1;
+        case 'boolean': return true;
+        case 'array': return [];
+        case 'object': return {};
+        default: return null;
+    }
+}
+function getRandomValue(type) {
+    switch (type.toLowerCase()) {
+        case 'string': return Math.random().toString(36).substring(7);
+        case 'number': return Math.floor(Math.random() * 1000);
+        case 'boolean': return Math.random() > 0.5;
+        case 'array': return Array(Math.floor(Math.random() * 10)).fill(0).map(() => Math.random());
+        default: return null;
+    }
+}
+// ============================================================================
+// BUG DETECTION
+// ============================================================================
+/**
+ * Analyze code for potential bugs
+ */
+export function detectBugs(workingDir) {
+    const bugs = [];
+    const srcDir = join(workingDir, 'src');
+    if (!existsSync(srcDir))
+        return bugs;
+    const files = findFilesRecursive(srcDir, ['.ts']);
+    for (const file of files) {
+        const content = readFileSync(file, 'utf-8');
+        const relativePath = relative(workingDir, file);
+        // Detect potential bugs
+        bugs.push(...detectNullDereferencing(content, relativePath));
+        bugs.push(...detectAsyncIssues(content, relativePath));
+        bugs.push(...detectTypeCoercion(content, relativePath));
+        bugs.push(...detectResourceLeaks(content, relativePath));
+        bugs.push(...detectLogicErrors(content, relativePath));
+    }
+    // Sort by severity
+    const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    bugs.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
+    return bugs;
+}
+function detectNullDereferencing(content, file) {
+    const bugs = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Pattern: accessing property without null check
+        if (line.match(/\w+\.\w+/) && !line.includes('?.') && !line.includes('!.')) {
+            // Check if there's a null check before this line
+            const prevLines = lines.slice(Math.max(0, i - 3), i).join('\n');
+            if (!prevLines.includes('!== null') && !prevLines.includes('!== undefined') &&
+                !prevLines.includes('!= null') && !prevLines.includes('if (')) {
+                // Could be a potential null dereference
+                const match = line.match(/(\w+)\.(\w+)/);
+                if (match && !['console', 'Math', 'JSON', 'Object', 'Array', 'String', 'Number', 'Date', 'process'].includes(match[1])) {
+                    bugs.push({
+                        id: `null_deref_${file}_${i + 1}`,
+                        severity: 'medium',
+                        type: 'edge-case',
+                        title: 'Potential null dereference',
+                        description: `Accessing ${match[1]}.${match[2]} without null check`,
+                        reproSteps: ['Call function with null/undefined input'],
+                        expectedBehavior: 'Should handle null gracefully',
+                        actualBehavior: 'May throw TypeError',
+                        file,
+                        line: i + 1,
+                        suggestedFix: `Add optional chaining: ${match[1]}?.${match[2]}`,
+                        detectedAt: new Date().toISOString(),
+                    });
+                }
+            }
+        }
+    }
+    return bugs.slice(0, 5); // Limit to prevent flooding
+}
+function detectAsyncIssues(content, file) {
+    const bugs = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Missing await on async call
+        if (line.match(/[^a]\w+Async\s*\(/) && !line.includes('await') && !line.includes('return')) {
+            bugs.push({
+                id: `missing_await_${file}_${i + 1}`,
+                severity: 'high',
+                type: 'logic',
+                title: 'Missing await on async function',
+                description: 'Async function called without await',
+                reproSteps: ['Call the function and check result'],
+                expectedBehavior: 'Should await async result',
+                actualBehavior: 'Returns Promise instead of resolved value',
+                file,
+                line: i + 1,
+                suggestedFix: 'Add await keyword',
+                detectedAt: new Date().toISOString(),
+            });
+        }
+        // Unhandled promise rejection
+        if (line.includes('.then(') && !content.slice(0, content.indexOf(line) + line.length + 200).includes('.catch(')) {
+            bugs.push({
+                id: `unhandled_promise_${file}_${i + 1}`,
+                severity: 'medium',
+                type: 'edge-case',
+                title: 'Unhandled promise rejection',
+                description: 'Promise chain without .catch() handler',
+                reproSteps: ['Cause the promise to reject'],
+                expectedBehavior: 'Should handle rejection',
+                actualBehavior: 'Unhandled promise rejection',
+                file,
+                line: i + 1,
+                suggestedFix: 'Add .catch() handler or use try/catch with await',
+                detectedAt: new Date().toISOString(),
+            });
+        }
+    }
+    return bugs.slice(0, 3);
+}
+function detectTypeCoercion(content, file) {
+    const bugs = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Loose equality
+        if (line.match(/[^!=]==[^=]/) && !line.includes('===')) {
+            bugs.push({
+                id: `loose_eq_${file}_${i + 1}`,
+                severity: 'low',
+                type: 'logic',
+                title: 'Loose equality comparison',
+                description: 'Using == instead of ===',
+                reproSteps: ['Compare values of different types'],
+                expectedBehavior: 'Strict type comparison',
+                actualBehavior: 'Type coercion may cause unexpected matches',
+                file,
+                line: i + 1,
+                suggestedFix: 'Use === for strict equality',
+                detectedAt: new Date().toISOString(),
+            });
+        }
+    }
+    return bugs.slice(0, 3);
+}
+function detectResourceLeaks(content, file) {
+    const bugs = [];
+    // File handle leaks
+    if (content.includes('openSync') && !content.includes('closeSync')) {
+        bugs.push({
+            id: `file_leak_${file}`,
+            severity: 'high',
+            type: 'performance',
+            title: 'Potential file handle leak',
+            description: 'File opened but not explicitly closed',
+            reproSteps: ['Call function repeatedly'],
+            expectedBehavior: 'File handles should be closed',
+            actualBehavior: 'May leak file handles',
+            file,
+            suggestedFix: 'Use try/finally or fs promises with proper cleanup',
+            detectedAt: new Date().toISOString(),
+        });
+    }
+    // Timer leaks
+    if ((content.includes('setInterval') || content.includes('setTimeout')) &&
+        !content.includes('clearInterval') && !content.includes('clearTimeout')) {
+        bugs.push({
+            id: `timer_leak_${file}`,
+            severity: 'medium',
+            type: 'performance',
+            title: 'Potential timer leak',
+            description: 'Timer set but never cleared',
+            reproSteps: ['Create and destroy component repeatedly'],
+            expectedBehavior: 'Timers should be cleared on cleanup',
+            actualBehavior: 'May accumulate timers',
+            file,
+            suggestedFix: 'Store timer ID and clear on cleanup',
+            detectedAt: new Date().toISOString(),
+        });
+    }
+    return bugs;
+}
+function detectLogicErrors(content, file) {
+    const bugs = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Always true/false conditions
+        if (line.match(/if\s*\(\s*true\s*\)/) || line.match(/if\s*\(\s*false\s*\)/)) {
+            bugs.push({
+                id: `const_cond_${file}_${i + 1}`,
+                severity: 'medium',
+                type: 'logic',
+                title: 'Constant condition',
+                description: 'Condition is always true or false',
+                reproSteps: ['Review the code'],
+                expectedBehavior: 'Dynamic condition',
+                actualBehavior: 'Dead code or always executed',
+                file,
+                line: i + 1,
+                suggestedFix: 'Remove dead code or fix condition',
+                detectedAt: new Date().toISOString(),
+            });
+        }
+        // Assignment in condition
+        if (line.match(/if\s*\([^=]*[^!=<>]=[^=][^)]*\)/)) {
+            bugs.push({
+                id: `assign_cond_${file}_${i + 1}`,
+                severity: 'high',
+                type: 'logic',
+                title: 'Assignment in condition',
+                description: 'Using = instead of == or === in condition',
+                reproSteps: ['Review the code'],
+                expectedBehavior: 'Comparison',
+                actualBehavior: 'Assignment (always truthy for non-null)',
+                file,
+                line: i + 1,
+                suggestedFix: 'Use === for comparison',
+                detectedAt: new Date().toISOString(),
+            });
+        }
+    }
+    return bugs.slice(0, 3);
+}
+// ============================================================================
+// UI UPDATE DETECTION
+// ============================================================================
+/**
+ * Detect needed UI updates
+ */
+export function detectUIUpdates(workingDir) {
+    const updates = [];
+    const uiDir = join(workingDir, 'src/ui');
+    if (!existsSync(uiDir))
+        return updates;
+    const files = findFilesRecursive(uiDir, ['.ts']);
+    for (const file of files) {
+        const content = readFileSync(file, 'utf-8');
+        const relativePath = relative(workingDir, file);
+        // Detect accessibility issues
+        if (content.includes('console.log') && file.includes('display')) {
+            updates.push({
+                component: basename(file, '.ts'),
+                type: 'accessibility',
+                description: 'Console output may not be screen-reader friendly',
+                before: 'console.log(...)',
+                after: 'Use structured output with ARIA labels',
+                file: relativePath,
+            });
+        }
+        // Detect hardcoded colors
+        const colorMatches = content.match(/['"`]#[0-9a-fA-F]{6}['"`]/g);
+        if (colorMatches && colorMatches.length > 3) {
+            updates.push({
+                component: basename(file, '.ts'),
+                type: 'style',
+                description: 'Hardcoded colors - should use theme',
+                before: colorMatches.slice(0, 3).join(', '),
+                after: 'Use theme.colors.* instead',
+                file: relativePath,
+            });
+        }
+        // Detect missing error handling in UI
+        if (content.includes('try') && !content.includes('showError') && !content.includes('displayError')) {
+            updates.push({
+                component: basename(file, '.ts'),
+                type: 'behavior',
+                description: 'Error handling without user feedback',
+                before: 'catch (error) { /* no UI feedback */ }',
+                after: 'catch (error) { showError(error.message); }',
+                file: relativePath,
+            });
+        }
+        // Detect long-running operations without loading state
+        if (content.includes('await') && !content.includes('loading') && !content.includes('spinner')) {
+            updates.push({
+                component: basename(file, '.ts'),
+                type: 'performance',
+                description: 'Async operation without loading indicator',
+                before: 'await longOperation()',
+                after: 'showLoading(); await longOperation(); hideLoading();',
+                file: relativePath,
+            });
+        }
+    }
+    return updates;
+}
+// ============================================================================
+// PERSISTENCE
+// ============================================================================
+/**
+ * Save test flows to disk
+ */
+export function saveTestFlows(flows) {
+    if (!existsSync(TEST_FLOWS_DIR)) {
+        mkdirSync(TEST_FLOWS_DIR, { recursive: true });
+    }
+    for (const flow of flows) {
+        const filePath = join(TEST_FLOWS_DIR, `${flow.id}.json`);
+        writeFileSync(filePath, JSON.stringify(flow, null, 2));
+    }
+}
+/**
+ * Load test flows from disk
+ */
+export function loadTestFlows() {
+    if (!existsSync(TEST_FLOWS_DIR))
+        return [];
+    const flows = [];
+    const files = readdirSync(TEST_FLOWS_DIR).filter(f => f.endsWith('.json'));
+    for (const file of files) {
+        try {
+            const content = readFileSync(join(TEST_FLOWS_DIR, file), 'utf-8');
+            flows.push(JSON.parse(content));
+        }
+        catch {
+            // Skip invalid files
+        }
+    }
+    return flows;
+}
+/**
+ * Save bug reports
+ */
+export function saveBugReports(bugs) {
+    if (!existsSync(BUG_REPORTS_DIR)) {
+        mkdirSync(BUG_REPORTS_DIR, { recursive: true });
+    }
+    for (const bug of bugs) {
+        const filePath = join(BUG_REPORTS_DIR, `${bug.id}.json`);
+        writeFileSync(filePath, JSON.stringify(bug, null, 2));
+    }
+}
+/**
+ * Save UI updates
+ */
+export function saveUIUpdates(updates) {
+    const dir = join(homedir(), '.erosolar');
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(UI_UPDATES_FILE, JSON.stringify(updates, null, 2));
+}
+// ============================================================================
+// STATUS DISPLAY
+// ============================================================================
+/**
+ * Get comprehensive test/bug status
+ */
+export function getTestFlowStatus(workingDir) {
+    const flows = loadTestFlows();
+    const bugs = detectBugs(workingDir);
+    const uiUpdates = detectUIUpdates(workingDir);
+    const lines = [];
+    lines.push('═══════════════════════════════════════════════════════════');
+    lines.push('     🧪 Intelligent Test Flow System');
+    lines.push('═══════════════════════════════════════════════════════════');
+    lines.push('');
+    // Test flows summary
+    const flowsByCategory = {};
+    for (const flow of flows) {
+        flowsByCategory[flow.category] = (flowsByCategory[flow.category] || 0) + 1;
+    }
+    lines.push(`Total Test Flows: ${flows.length}`);
+    for (const [category, count] of Object.entries(flowsByCategory)) {
+        lines.push(`  ${category}: ${count}`);
+    }
+    lines.push('');
+    // Bugs summary
+    const bugsBySeverity = {};
+    for (const bug of bugs) {
+        bugsBySeverity[bug.severity] = (bugsBySeverity[bug.severity] || 0) + 1;
+    }
+    lines.push(`Potential Bugs Detected: ${bugs.length}`);
+    if (bugsBySeverity['critical'])
+        lines.push(`  🔴 Critical: ${bugsBySeverity['critical']}`);
+    if (bugsBySeverity['high'])
+        lines.push(`  🟠 High: ${bugsBySeverity['high']}`);
+    if (bugsBySeverity['medium'])
+        lines.push(`  🟡 Medium: ${bugsBySeverity['medium']}`);
+    if (bugsBySeverity['low'])
+        lines.push(`  ⚪ Low: ${bugsBySeverity['low']}`);
+    lines.push('');
+    // UI updates
+    lines.push(`UI Updates Needed: ${uiUpdates.length}`);
+    const uiByType = {};
+    for (const update of uiUpdates) {
+        uiByType[update.type] = (uiByType[update.type] || 0) + 1;
+    }
+    for (const [type, count] of Object.entries(uiByType)) {
+        lines.push(`  ${type}: ${count}`);
+    }
+    lines.push('');
+    // Top bugs
+    if (bugs.length > 0) {
+        lines.push('Top Issues:');
+        for (const bug of bugs.slice(0, 5)) {
+            const icon = bug.severity === 'critical' ? '🔴' :
+                bug.severity === 'high' ? '🟠' :
+                    bug.severity === 'medium' ? '🟡' : '⚪';
+            lines.push(`  ${icon} ${bug.title}`);
+            lines.push(`     ${bug.file}:${bug.line ?? '?'}`);
+        }
+        lines.push('');
+    }
+    lines.push('Commands:');
+    lines.push('  /test generate <file> - Generate test flows for file');
+    lines.push('  /test bugs           - Detect potential bugs');
+    lines.push('  /test ui             - Detect UI improvements');
+    lines.push('  /test run            - Run generated tests');
+    lines.push('');
+    lines.push('═══════════════════════════════════════════════════════════');
+    return lines.join('\n');
+}
+// ============================================================================
+// HELPERS
+// ============================================================================
+function findFilesRecursive(dir, extensions) {
+    const files = [];
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith('.') &&
+                entry.name !== 'node_modules' && entry.name !== 'dist') {
+                files.push(...findFilesRecursive(fullPath, extensions));
+            }
+            else if (entry.isFile() && extensions.some(ext => entry.name.endsWith(ext))) {
+                files.push(fullPath);
+            }
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return files;
+}
+//# sourceMappingURL=intelligentTestFlows.js.map