claude-flow-novice 2.2.4 → 2.2.5

package/scripts/build/typescript-fixer.js

@@ -0,0 +1,621 @@
+#!/usr/bin/env node
+
+/**
+ * Unified TypeScript Fixer - Consolidates 6+ TypeScript fix scripts
+ * Phase 12: Script Consolidation - TypeScript Error Resolution
+ *
+ * Consolidates:
+ * - fix-typescript-errors.js
+ * - fix-ts-advanced.js
+ * - fix-ts-targeted.sh
+ * - fix-ts-final.sh
+ * - quick-fix-ts.js
+ * - batch-fix-ts.sh
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+class TypeScriptFixer {
+    constructor() {
+        this.version = '1.0.0';
+        this.fixedFiles = new Set();
+        this.errorStats = {};
+        this.fixStrategies = new Map();
+        this.setupFixStrategies();
+    }
+
+    setupFixStrategies() {
+        // Basic error fixes (from fix-typescript-errors.js)
+        this.fixStrategies.set('basic', {
+            name: 'Basic Error Fixes',
+            description: 'Standard TypeScript error patterns',
+            fixes: this.getBasicFixes()
+        });
+
+        // Advanced fixes (from fix-ts-advanced.js)
+        this.fixStrategies.set('advanced', {
+            name: 'Advanced Error Fixes',
+            description: 'Complex TypeScript error patterns',
+            fixes: this.getAdvancedFixes()
+        });
+
+        // Targeted fixes (from fix-ts-targeted.sh equivalent)
+        this.fixStrategies.set('targeted', {
+            name: 'Targeted Fixes',
+            description: 'File-specific targeted fixes',
+            fixes: this.getTargetedFixes()
+        });
+
+        // Quick fixes (from quick-fix-ts.js)
+        this.fixStrategies.set('quick', {
+            name: 'Quick Fixes',
+            description: 'Fast common pattern fixes',
+            fixes: this.getQuickFixes()
+        });
+
+        // Batch fixes (from batch-fix-ts.sh equivalent)
+        this.fixStrategies.set('batch', {
+            name: 'Batch Fixes',
+            description: 'Bulk operation fixes',
+            fixes: this.getBatchFixes()
+        });
+    }
+
+    getBasicFixes() {
+        return {
+            // TS1361: Import type issues
+            TS1361: {
+                pattern: /error TS1361: '([^']+)' cannot be used as a value/,
+                fix: async (file, match) => {
+                    const content = await fs.readFile(file, 'utf8');
+                    const updated = content.replace(
+                        /import type \{([^}]*)\} from '([^']+)'/g,
+                        (m, imports, path) => {
+                            if (imports.includes(match[1])) {
+                                return `import { ${imports} } from '${path}'`;
+                            }
+                            return m;
+                        }
+                    );
+                    if (updated !== content) {
+                        await fs.writeFile(file, updated);
+                        return true;
+                    }
+                    return false;
+                }
+            },
+
+            // TS2339: Property does not exist
+            TS2339: {
+                pattern: /error TS2339: Property '([^']+)' does not exist on type '([^']+)'/,
+                fix: async (file, match) => {
+                    const content = await fs.readFile(file, 'utf8');
+                    const property = match[1];
+                    const type = match[2];
+
+                    if (type === 'never') {
+                        const updated = content.replace(
+                            new RegExp(`(\\w+)\\.${property}`, 'g'),
+                            `($1 as any).${property}`
+                        );
+                        if (updated !== content) {
+                            await fs.writeFile(file, updated);
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+            },
+
+            // TS2304: Cannot find name
+            TS2304: {
+                pattern: /error TS2304: Cannot find name '([^']+)'/,
+                fix: async (file, match) => {
+                    const name = match[1];
+                    const content = await fs.readFile(file, 'utf8');
+
+                    const commonImports = {
+                        'process': "import process from 'node:process';",
+                        'Buffer': "import { Buffer } from 'node:buffer';",
+                        'URL': "import { URL } from 'node:url';",
+                        '__dirname': "import { dirname } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nconst __dirname = dirname(fileURLToPath(import.meta.url));",
+                        '__filename': "import { fileURLToPath } from 'node:url';\nconst __filename = fileURLToPath(import.meta.url);"
+                    };
+
+                    if (commonImports[name] && !content.includes(commonImports[name])) {
+                        const lines = content.split('\n');
+                        const importIndex = lines.findIndex(line => line.startsWith('import'));
+                        if (importIndex !== -1) {
+                            lines.splice(importIndex, 0, commonImports[name]);
+                            await fs.writeFile(file, lines.join('\n'));
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+            },
+
+            // TS2307: Cannot find module
+            TS2307: {
+                pattern: /error TS2307: Cannot find module '([^']+)'/,
+                fix: async (file, match) => {
+                    const modulePath = match[1];
+                    const content = await fs.readFile(file, 'utf8');
+
+                    if (!modulePath.endsWith('.js') && modulePath.startsWith('.')) {
+                        const updated = content.replace(
+                            new RegExp(`from '${modulePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}'`, 'g'),
+                            `from '${modulePath}.js'`
+                        );
+                        if (updated !== content) {
+                            await fs.writeFile(file, updated);
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+            }
+        };
+    }
+
+    getAdvancedFixes() {
+        return {
+            // Advanced property fixes
+            propertyFixes: async (files) => {
+                const fixes = [];
+                for (const file of files) {
+                    try {
+                        const content = await fs.readFile(file, 'utf8');
+                        let updated = content;
+
+                        // Fix Command interface issues
+                        updated = updated.replace(/\.arguments\(/g, '.args(');
+                        updated = updated.replace(/\.outputHelp\(\)/g, '.help()');
+                        updated = updated.replace(/config\.capabilities/g, '(config as any).capabilities');
+                        updated = updated.replace(/task\.parameters/g, '(task as any).parameters');
+
+                        if (updated !== content) {
+                            await fs.writeFile(file, updated);
+                            fixes.push(file);
+                        }
+                    } catch (err) {
+                        // Ignore file access errors
+                    }
+                }
+                return fixes;
+            },
+
+            // Advanced type assertion fixes
+            typeAssertions: async (files) => {
+                const fixes = [];
+                for (const file of files) {
+                    try {
+                        const content = await fs.readFile(file, 'utf8');
+                        let updated = content;
+
+                        // Fix array push operations
+                        updated = updated.replace(
+                            /(\w+)\.push\(/g,
+                            (match, varName) => {
+                                if (content.includes(`${varName} = []`) || content.includes(`${varName}: []`)) {
+                                    return `(${varName} as any[]).push(`;
+                                }
+                                return match;
+                            }
+                        );
+
+                        // Fix never type arrays
+                        updated = updated.replace(/: never\[\]/g, ': any[]');
+                        updated = updated.replace(/= \[\] as never\[\]/g, '= [] as any[]');
+
+                        if (updated !== content) {
+                            await fs.writeFile(file, updated);
+                            fixes.push(file);
+                        }
+                    } catch (err) {
+                        // Ignore file access errors
+                    }
+                }
+                return fixes;
+            }
+        };
+    }
+
+    getTargetedFixes() {
+        return {
+            // File-specific fixes
+            cliCommands: async () => {
+                const files = await this.findFiles('src/cli/commands/*.ts');
+                const fixes = [];
+
+                for (const file of files) {
+                    try {
+                        const content = await fs.readFile(file, 'utf8');
+                        let updated = content;
+
+                        // Fix common CLI command issues
+                        updated = updated.replace(/program\.name\(\)/g, '(program as any).name()');
+                        updated = updated.replace(/status\./g, '(status as any).');
+
+                        if (updated !== content) {
+                            await fs.writeFile(file, updated);
+                            fixes.push(file);
+                        }
+                    } catch (err) {
+                        // Ignore file access errors
+                    }
+                }
+                return fixes;
+            },
+
+            // Agent-specific fixes
+            agentFiles: async () => {
+                const files = await this.findFiles('src/cli/agents/*.ts');
+                const fixes = [];
+
+                for (const file of files) {
+                    try {
+                        const content = await fs.readFile(file, 'utf8');
+                        let updated = content;
+
+                        // Fix agent capability issues
+                        updated = updated.replace(/agent\.capabilities/g, '(agent as any).capabilities');
+                        updated = updated.replace(/swarm\.agents/g, '(swarm as any).agents');
+
+                        if (updated !== content) {
+                            await fs.writeFile(file, updated);
+                            fixes.push(file);
+                        }
+                    } catch (err) {
+                        // Ignore file access errors
+                    }
+                }
+                return fixes;
+            }
+        };
+    }
+
+    getQuickFixes() {
+        return {
+            // Quick pattern replacements
+            commonPatterns: async (files) => {
+                const fixes = [];
+                const patterns = [
+                    { from: /export type \{([^}]+)\} from/g, to: 'export { type $1 } from' },
+                    { from: /import type \{([^}]+)\} from '([^']+)'/g, to: 'import { type $1 } from \'$2\'' },
+                    { from: /as never\b/g, to: 'as any' },
+                    { from: /: never\b/g, to: ': any' }
+                ];
+
+                for (const file of files) {
+                    try {
+                        const content = await fs.readFile(file, 'utf8');
+                        let updated = content;
+
+                        for (const pattern of patterns) {
+                            updated = updated.replace(pattern.from, pattern.to);
+                        }
+
+                        if (updated !== content) {
+                            await fs.writeFile(file, updated);
+                            fixes.push(file);
+                        }
+                    } catch (err) {
+                        // Ignore file access errors
+                    }
+                }
+                return fixes;
+            }
+        };
+    }
+
+    getBatchFixes() {
+        return {
+            // Bulk operations
+            bulkImportFixes: async (files) => {
+                const fixes = [];
+                for (const file of files) {
+                    try {
+                        const content = await fs.readFile(file, 'utf8');
+                        let updated = content;
+
+                        // Add missing .js extensions in bulk
+                        updated = updated.replace(/from '(\.[^']+)'/g, (match, path) => {
+                            if (!path.endsWith('.js') && !path.endsWith('.json')) {
+                                return `from '${path}.js'`;
+                            }
+                            return match;
+                        });
+
+                        if (updated !== content) {
+                            await fs.writeFile(file, updated);
+                            fixes.push(file);
+                        }
+                    } catch (err) {
+                        // Ignore file access errors
+                    }
+                }
+                return fixes;
+            },
+
+            // Bulk type fixes
+            bulkTypeFixes: async (files) => {
+                const fixes = [];
+                for (const file of files) {
+                    try {
+                        const content = await fs.readFile(file, 'utf8');
+                        let updated = content;
+
+                        // Replace problematic types in bulk
+                        updated = updated.replace(/\bany\[\]/g, 'unknown[]');
+                        updated = updated.replace(/\bnever\[\]/g, 'any[]');
+
+                        if (updated !== content) {
+                            await fs.writeFile(file, updated);
+                            fixes.push(file);
+                        }
+                    } catch (err) {
+                        // Ignore file access errors
+                    }
+                }
+                return fixes;
+            }
+        };
+    }
+
+    async findFiles(pattern) {
+        try {
+            const { stdout } = await execAsync(`find . -path "${pattern}" -name "*.ts" 2>/dev/null || true`);
+            return stdout.trim().split('\n').filter(f => f && f.length > 0);
+        } catch (err) {
+            return [];
+        }
+    }
+
+    async getTypeScriptErrors() {
+        try {
+            const { stdout } = await execAsync('npm run build:types 2>&1 || npm run typecheck 2>&1 || true');
+            const errors = stdout.split('\n').filter(line => line.includes('error TS'));
+
+            // Group errors by type
+            const errorGroups = {};
+            for (const error of errors) {
+                const match = error.match(/error TS(\d+):/);
+                if (match) {
+                    const code = `TS${match[1]}`;
+                    if (!errorGroups[code]) {
+                        errorGroups[code] = [];
+                    }
+                    errorGroups[code].push(error);
+                }
+            }
+
+            return { errors, errorGroups, total: errors.length };
+        } catch (err) {
+            return { errors: [], errorGroups: {}, total: 0 };
+        }
+    }
+
+    async applyFixes(strategy = 'all', options = {}) {
+        console.log(`🔧 Applying TypeScript fixes - Strategy: ${strategy}`);
+        console.log(`📊 TypeScript Fixer v${this.version}`);
+
+        const { dryRun = false, verbose = false, maxFiles = 100 } = options;
+
+        // Get current errors
+        const errorInfo = await this.getTypeScriptErrors();
+        console.log(`\n📊 Found ${errorInfo.total} TypeScript errors`);
+
+        if (errorInfo.total === 0) {
+            console.log('✅ No TypeScript errors found!');
+            return { success: true, fixed: 0, errors: 0 };
+        }
+
+        // Show error breakdown
+        console.log('\n📋 Error Breakdown:');
+        Object.entries(errorInfo.errorGroups)
+            .sort((a, b) => b[1].length - a[1].length)
+            .slice(0, 10)
+            .forEach(([code, errors]) => {
+                console.log(`  ${code}: ${errors.length} errors`);
+            });
+
+        const files = await this.findFiles('src/**/*.ts');
+        const limitedFiles = files.slice(0, maxFiles);
+
+        if (dryRun) {
+            console.log(`\n🔍 Dry run mode - would process ${limitedFiles.length} files`);
+            return { success: true, fixed: 0, errors: errorInfo.total };
+        }
+
+        let totalFixed = 0;
+
+        // Apply strategy-specific fixes
+        if (strategy === 'all' || strategy === 'basic') {
+            console.log('\n🔧 Applying basic fixes...');
+            const basicFixes = this.fixStrategies.get('basic').fixes;
+
+            for (const [errorCode, fixConfig] of Object.entries(basicFixes)) {
+                if (errorInfo.errorGroups[errorCode]) {
+                    const errors = errorInfo.errorGroups[errorCode].slice(0, 50);
+                    for (const error of errors) {
+                        const fileMatch = error.match(/([^(]+)\(/);
+                        if (fileMatch) {
+                            const file = fileMatch[1];
+                            const match = error.match(fixConfig.pattern);
+                            if (match) {
+                                try {
+                                    const fixed = await fixConfig.fix(file, match);
+                                    if (fixed) {
+                                        totalFixed++;
+                                        this.fixedFiles.add(file);
+                                    }
+                                } catch (err) {
+                                    if (verbose) {
+                                        console.error(`Error fixing ${file}: ${err.message}`);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (strategy === 'all' || strategy === 'advanced') {
+            console.log('\n🔧 Applying advanced fixes...');
+            const advancedFixes = this.fixStrategies.get('advanced').fixes;
+
+            const propertyFixes = await advancedFixes.propertyFixes(limitedFiles);
+            const typeFixes = await advancedFixes.typeAssertions(limitedFiles);
+
+            totalFixed += propertyFixes.length + typeFixes.length;
+            propertyFixes.forEach(file => this.fixedFiles.add(file));
+            typeFixes.forEach(file => this.fixedFiles.add(file));
+        }
+
+        if (strategy === 'all' || strategy === 'targeted') {
+            console.log('\n🔧 Applying targeted fixes...');
+            const targetedFixes = this.fixStrategies.get('targeted').fixes;
+
+            const cliFixes = await targetedFixes.cliCommands();
+            const agentFixes = await targetedFixes.agentFiles();
+
+            totalFixed += cliFixes.length + agentFixes.length;
+            cliFixes.forEach(file => this.fixedFiles.add(file));
+            agentFixes.forEach(file => this.fixedFiles.add(file));
+        }
+
+        if (strategy === 'all' || strategy === 'quick') {
+            console.log('\n🔧 Applying quick fixes...');
+            const quickFixes = this.fixStrategies.get('quick').fixes;
+
+            const patternFixes = await quickFixes.commonPatterns(limitedFiles);
+            totalFixed += patternFixes.length;
+            patternFixes.forEach(file => this.fixedFiles.add(file));
+        }
+
+        if (strategy === 'all' || strategy === 'batch') {
+            console.log('\n🔧 Applying batch fixes...');
+            const batchFixes = this.fixStrategies.get('batch').fixes;
+
+            const importFixes = await batchFixes.bulkImportFixes(limitedFiles);
+            const typeFixes = await batchFixes.bulkTypeFixes(limitedFiles);
+
+            totalFixed += importFixes.length + typeFixes.length;
+            importFixes.forEach(file => this.fixedFiles.add(file));
+            typeFixes.forEach(file => this.fixedFiles.add(file));
+        }
+
+        // Check remaining errors
+        console.log('\n🔍 Checking remaining errors...');
+        const finalErrorInfo = await this.getTypeScriptErrors();
+
+        console.log('\n📊 Fix Results:');
+        console.log(`  Files processed: ${limitedFiles.length}`);
+        console.log(`  Files modified: ${this.fixedFiles.size}`);
+        console.log(`  Fixes applied: ${totalFixed}`);
+        console.log(`  Errors before: ${errorInfo.total}`);
+        console.log(`  Errors after: ${finalErrorInfo.total}`);
+        console.log(`  Errors fixed: ${errorInfo.total - finalErrorInfo.total}`);
+
+        const success = finalErrorInfo.total < errorInfo.total;
+
+        if (success) {
+            console.log('✅ TypeScript fixes applied successfully!');
+
+            // Coordination hook
+            try {
+                await execAsync('npx claude-flow@alpha hooks post-edit --file "typescript-fixer" --memory-key "swarm/phase12/ts-fixes"');
+            } catch (err) {
+                // Ignore hook errors
+            }
+        } else {
+            console.log('⚠️ Some errors may require manual intervention');
+        }
+
+        return {
+            success,
+            fixed: totalFixed,
+            errorsBefore: errorInfo.total,
+            errorsAfter: finalErrorInfo.total,
+            filesModified: this.fixedFiles.size
+        };
+    }
+
+    printUsage() {
+        console.log('TypeScript Fixer v' + this.version);
+        console.log('Unified TypeScript error fixing utility');
+        console.log('');
+        console.log('Usage: node typescript-fixer.js [strategy] [options]');
+        console.log('');
+        console.log('Strategies:');
+        for (const [key, strategy] of this.fixStrategies) {
+            console.log(`  ${key.padEnd(12)} ${strategy.description}`);
+        }
+        console.log('  all          Apply all fix strategies (default)');
+        console.log('');
+        console.log('Options:');
+        console.log('  --dry-run    Show what would be fixed without making changes');
+        console.log('  --verbose    Show detailed output');
+        console.log('  --max-files  Maximum number of files to process (default: 100)');
+        console.log('  --help       Show this help');
+        console.log('');
+        console.log('Examples:');
+        console.log('  node typescript-fixer.js');
+        console.log('  node typescript-fixer.js basic --dry-run');
+        console.log('  node typescript-fixer.js advanced --verbose');
+        console.log('  node typescript-fixer.js quick --max-files 50');
+    }
+}
+
+// Main execution
+async function main() {
+    const args = process.argv.slice(2);
+    const fixer = new TypeScriptFixer();
+
+    let strategy = 'all';
+    const options = {};
+
+    // Parse arguments
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+
+        if (arg === '--help' || arg === '-h') {
+            fixer.printUsage();
+            process.exit(0);
+        } else if (arg === '--dry-run') {
+            options.dryRun = true;
+        } else if (arg === '--verbose') {
+            options.verbose = true;
+        } else if (arg === '--max-files') {
+            options.maxFiles = parseInt(args[++i]) || 100;
+        } else if (fixer.fixStrategies.has(arg) || arg === 'all') {
+            strategy = arg;
+        } else {
+            console.error(`Unknown argument: ${arg}`);
+            fixer.printUsage();
+            process.exit(1);
+        }
+    }
+
+    try {
+        const result = await fixer.applyFixes(strategy, options);
+        process.exit(result.success ? 0 : 1);
+    } catch (error) {
+        console.error('❌ Error during TypeScript fixing:', error.message);
+        process.exit(1);
+    }
+}
+
+// Execute if run directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main();
+}
+
+export { TypeScriptFixer };