erosolar-cli 2.1.249 → 2.1.253

package/dist/core/intelligentTestFlows.js

@@ -1,669 +1,25 @@
 /**
- * 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
+ * Intelligent Test Flows - Minimal stub for backward compatibility
  */
-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
-// ============================================================================
-// 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;
+export function generateTestFlows(_sourceFile, _targetPath) {
+    return [];
 }
-// ============================================================================
-// 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;
+export function detectBugs(_sourceFile, _targetPath) {
+    return [];
 }
-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;
+export function detectUIUpdates(_sourceFile, _targetPath) {
+    return [];
 }
-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(),
-    };
+export function saveTestFlows(_flows, _outputDir) {
+    // No-op stub
 }
-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;
+export function saveBugReports(_bugs, _outputDir) {
+    // No-op stub
 }
-function createStressTestFlow(fileName, funcName, params) {
-    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');
+export function saveUIUpdates(_updates, _outputDir) {
+    // No-op stub
 }
-// ============================================================================
-// 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;
+export function getTestFlowStatus(_workingDir) {
+    return 'Test flow generation is deprecated';
 }
 //# sourceMappingURL=intelligentTestFlows.js.map