erosolar-cli 2.1.204 → 2.1.206

package/dist/core/alphaZeroModular.js

@@ -1,755 +0,0 @@
-/**
- * AlphaZero Modular Optimization System
- *
- * Enables self-improvement through modular targeting of:
- * - Token count minimization
- * - Context window optimization
- * - Tool management (create/edit/delete)
- * - Guideline and guardrail management
- * - System prompt optimization
- *
- * Principal Investigator: Bo Shang
- */
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from 'node:fs';
-import { join, relative, basename } from 'node:path';
-import { homedir } from 'node:os';
-// ============================================================================
-// CONSTANTS
-// ============================================================================
-const MODULAR_STATE_FILE = join(homedir(), '.erosolar', 'modular-state.json');
-const MODULAR_ACTIONS_FILE = join(homedir(), '.erosolar', 'modular-actions.json');
-const TOOLS_DIR = 'src/tools';
-const CAPABILITIES_DIR = 'src/capabilities';
-const CORE_DIR = 'src/core';
-const CONTRACTS_DIR = 'src/contracts';
-// Token estimation (rough approximation: 1 token ≈ 4 chars for code)
-const CHARS_PER_TOKEN = 4;
-// Priority scores for different component types
-const TYPE_PRIORITY = {
-    'guardrail': 100,
-    'system-prompt': 95,
-    'tool': 90,
-    'capability': 85,
-    'guideline': 80,
-    'schema': 70,
-};
-// ============================================================================
-// TOKEN ANALYSIS
-// ============================================================================
-/**
- * Estimate token count for a string
- */
-export function estimateTokens(content) {
-    return Math.ceil(content.length / CHARS_PER_TOKEN);
-}
-/**
- * Analyze token usage across the codebase
- */
-export function analyzeTokenUsage(workingDir) {
-    const analysis = {
-        totalTokens: 0,
-        byCategory: {},
-        topConsumers: [],
-        optimizationOpportunities: [],
-    };
-    const categories = [
-        { name: 'tools', dir: join(workingDir, TOOLS_DIR) },
-        { name: 'capabilities', dir: join(workingDir, CAPABILITIES_DIR) },
-        { name: 'core', dir: join(workingDir, CORE_DIR) },
-        { name: 'contracts', dir: join(workingDir, CONTRACTS_DIR) },
-    ];
-    const allFiles = [];
-    for (const category of categories) {
-        if (!existsSync(category.dir))
-            continue;
-        let categoryTokens = 0;
-        const files = findFilesRecursive(category.dir, ['.ts', '.json']);
-        for (const file of files) {
-            try {
-                const content = readFileSync(file, 'utf-8');
-                const tokens = estimateTokens(content);
-                categoryTokens += tokens;
-                allFiles.push({
-                    name: basename(file),
-                    tokens,
-                    path: relative(workingDir, file),
-                    category: category.name,
-                });
-                // Check for optimization opportunities
-                const opportunities = findOptimizationOpportunities(file, content, tokens);
-                analysis.optimizationOpportunities.push(...opportunities);
-            }
-            catch {
-                // Skip unreadable files
-            }
-        }
-        analysis.byCategory[category.name] = categoryTokens;
-        analysis.totalTokens += categoryTokens;
-    }
-    // Sort by token count and get top consumers
-    allFiles.sort((a, b) => b.tokens - a.tokens);
-    analysis.topConsumers = allFiles.slice(0, 20);
-    // Sort opportunities by savings
-    analysis.optimizationOpportunities.sort((a, b) => b.savings - a.savings);
-    return analysis;
-}
-function findOptimizationOpportunities(filePath, content, tokens) {
-    const opportunities = [];
-    const fileName = basename(filePath);
-    // Check for verbose comments
-    const commentMatches = content.match(/\/\*\*[\s\S]*?\*\//g) || [];
-    const commentChars = commentMatches.reduce((sum, c) => sum + c.length, 0);
-    if (commentChars > content.length * 0.3) {
-        const savings = Math.floor(commentChars * 0.5 / CHARS_PER_TOKEN);
-        opportunities.push({
-            target: fileName,
-            currentTokens: tokens,
-            estimatedOptimized: tokens - savings,
-            savings,
-            savingsPercent: Math.round((savings / tokens) * 100),
-            strategy: 'Reduce verbose JSDoc comments - keep essential docs only',
-            autoFixable: false,
-        });
-    }
-    // Check for duplicate code patterns
-    const lines = content.split('\n');
-    const lineSet = new Set();
-    let duplicates = 0;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed.length > 20 && lineSet.has(trimmed)) {
-            duplicates++;
-        }
-        lineSet.add(trimmed);
-    }
-    if (duplicates > 10) {
-        const savings = Math.floor(duplicates * 15 / CHARS_PER_TOKEN);
-        opportunities.push({
-            target: fileName,
-            currentTokens: tokens,
-            estimatedOptimized: tokens - savings,
-            savings,
-            savingsPercent: Math.round((savings / tokens) * 100),
-            strategy: 'Extract duplicate code into shared utilities',
-            autoFixable: false,
-        });
-    }
-    // Check for long string literals
-    const stringMatches = content.match(/'[^']{100,}'|"[^"]{100,}"|`[^`]{200,}`/g) || [];
-    if (stringMatches.length > 0) {
-        const stringChars = stringMatches.reduce((sum, s) => sum + s.length, 0);
-        const savings = Math.floor(stringChars * 0.3 / CHARS_PER_TOKEN);
-        if (savings > 50) {
-            opportunities.push({
-                target: fileName,
-                currentTokens: tokens,
-                estimatedOptimized: tokens - savings,
-                savings,
-                savingsPercent: Math.round((savings / tokens) * 100),
-                strategy: 'Move long strings to external files or templates',
-                autoFixable: false,
-            });
-        }
-    }
-    // Check for unused imports (simple heuristic)
-    const importMatches = content.match(/import\s+\{([^}]+)\}/g) || [];
-    for (const imp of importMatches) {
-        const imports = imp.match(/\{([^}]+)\}/)?.[1]?.split(',') || [];
-        for (const item of imports) {
-            const name = item.trim().split(/\s+as\s+/)[0]?.trim();
-            if (name && !content.includes(`${name}(`) && !content.includes(`${name}.`) &&
-                !content.includes(`: ${name}`) && !content.includes(`<${name}`)) {
-                // Potentially unused
-                opportunities.push({
-                    target: fileName,
-                    currentTokens: tokens,
-                    estimatedOptimized: tokens - 5,
-                    savings: 5,
-                    savingsPercent: 0,
-                    strategy: `Remove potentially unused import: ${name}`,
-                    autoFixable: true,
-                });
-            }
-        }
-    }
-    return opportunities;
-}
-// ============================================================================
-// MODULAR TARGET DISCOVERY
-// ============================================================================
-/**
- * Discover all modular targets in the codebase
- */
-export function discoverModularTargets(workingDir) {
-    const targets = [];
-    // Discover tools
-    const toolsDir = join(workingDir, TOOLS_DIR);
-    if (existsSync(toolsDir)) {
-        const toolFiles = findFilesRecursive(toolsDir, ['.ts']);
-        for (const file of toolFiles) {
-            const target = analyzeModularTarget(file, 'tool', workingDir);
-            if (target)
-                targets.push(target);
-        }
-    }
-    // Discover capabilities
-    const capsDir = join(workingDir, CAPABILITIES_DIR);
-    if (existsSync(capsDir)) {
-        const capFiles = findFilesRecursive(capsDir, ['.ts']);
-        for (const file of capFiles) {
-            const target = analyzeModularTarget(file, 'capability', workingDir);
-            if (target)
-                targets.push(target);
-        }
-    }
-    // Discover schemas (guardrails, guidelines)
-    const contractsDir = join(workingDir, CONTRACTS_DIR);
-    if (existsSync(contractsDir)) {
-        const schemaFiles = findFilesRecursive(contractsDir, ['.json']);
-        for (const file of schemaFiles) {
-            const target = analyzeModularTarget(file, 'schema', workingDir);
-            if (target)
-                targets.push(target);
-        }
-    }
-    // Discover agent rules (guardrails)
-    const agentsDir = join(workingDir, 'agents');
-    if (existsSync(agentsDir)) {
-        const ruleFiles = findFilesRecursive(agentsDir, ['.json']);
-        for (const file of ruleFiles) {
-            const target = analyzeModularTarget(file, 'guardrail', workingDir);
-            if (target)
-                targets.push(target);
-        }
-    }
-    // Sort by priority
-    targets.sort((a, b) => b.priority - a.priority);
-    return targets;
-}
-function analyzeModularTarget(filePath, type, workingDir) {
-    try {
-        const content = readFileSync(filePath, 'utf-8');
-        const stats = require('fs').statSync(filePath);
-        const tokens = estimateTokens(content);
-        const relativePath = relative(workingDir, filePath);
-        const name = basename(filePath, '.ts').replace('.json', '');
-        const issues = findModularIssues(content, type, name);
-        return {
-            id: relativePath.replace(/[/\\]/g, '_'),
-            type,
-            name,
-            path: relativePath,
-            tokenCount: tokens,
-            priority: TYPE_PRIORITY[type] || 50,
-            lastModified: stats.mtime.toISOString(),
-            issues,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function findModularIssues(content, type, name) {
-    const issues = [];
-    const tokens = estimateTokens(content);
-    // Token bloat detection
-    if (type === 'tool' && tokens > 500) {
-        issues.push({
-            type: 'token-bloat',
-            severity: tokens > 1000 ? 'high' : 'medium',
-            description: `Tool has ${tokens} tokens, consider splitting`,
-            suggestedAction: 'Split into smaller focused tools',
-            potentialSavings: Math.floor(tokens * 0.3),
-        });
-    }
-    // Redundancy detection (similar patterns)
-    if (content.includes('// TODO') || content.includes('// FIXME')) {
-        issues.push({
-            type: 'outdated',
-            severity: 'low',
-            description: 'Contains TODO/FIXME markers',
-            suggestedAction: 'Address or remove TODO markers',
-        });
-    }
-    // Check for deprecated patterns
-    if (content.includes('@deprecated') || content.includes('DEPRECATED')) {
-        issues.push({
-            type: 'outdated',
-            severity: 'high',
-            description: 'Contains deprecated code',
-            suggestedAction: 'Remove or update deprecated code',
-            potentialSavings: 50,
-        });
-    }
-    // Check for overly complex schemas
-    if (type === 'schema' && tokens > 2000) {
-        issues.push({
-            type: 'token-bloat',
-            severity: 'high',
-            description: `Schema has ${tokens} tokens - very large`,
-            suggestedAction: 'Split schema into smaller modules',
-            potentialSavings: Math.floor(tokens * 0.4),
-        });
-    }
-    // Check for missing documentation
-    if (type === 'tool' && !content.includes('description:') && !content.includes('@description')) {
-        issues.push({
-            type: 'missing',
-            severity: 'medium',
-            description: 'Tool lacks description',
-            suggestedAction: 'Add clear description for tool',
-        });
-    }
-    return issues;
-}
-// ============================================================================
-// TOOL MANAGEMENT
-// ============================================================================
-/**
- * Create a new tool
- */
-export function createTool(workingDir, definition) {
-    const toolsDir = join(workingDir, TOOLS_DIR);
-    if (!existsSync(toolsDir)) {
-        return { success: false, error: 'Tools directory not found' };
-    }
-    const fileName = `${definition.name.replace(/Tool$/, '')}Tools.ts`;
-    const filePath = join(toolsDir, fileName);
-    if (existsSync(filePath)) {
-        return { success: false, error: `Tool file already exists: ${fileName}` };
-    }
-    const toolCode = generateToolCode(definition);
-    try {
-        writeFileSync(filePath, toolCode);
-        return { success: true, path: filePath };
-    }
-    catch (error) {
-        return { success: false, error: String(error) };
-    }
-}
-function generateToolCode(def) {
-    return `/**
- * ${def.name}
- * ${def.description}
- *
- * Auto-generated by AlphaZero Modular System
- */
-
-import type { ToolDefinition } from '../core/toolRuntime.js';
-
-export const ${def.name}: ToolDefinition = {
-  name: '${def.name}',
-  description: '${def.description}',
-  inputSchema: ${JSON.stringify(def.inputSchema, null, 2)},
-  handler: async (input, context) => {
-    // TODO: Implement tool logic
-    return {
-      success: true,
-      result: 'Tool executed successfully',
-    };
-  },
-};
-`;
-}
-/**
- * Edit an existing tool
- */
-export function editTool(workingDir, toolPath, changes) {
-    const fullPath = join(workingDir, toolPath);
-    if (!existsSync(fullPath)) {
-        return { success: false, error: 'Tool file not found' };
-    }
-    try {
-        let content = readFileSync(fullPath, 'utf-8');
-        if (changes.description) {
-            content = content.replace(/description:\s*['"`][^'"`]*['"`]/, `description: '${changes.description}'`);
-        }
-        if (changes.inputSchema) {
-            // More complex - need to find and replace the schema
-            const schemaStr = JSON.stringify(changes.inputSchema, null, 2);
-            content = content.replace(/inputSchema:\s*\{[\s\S]*?\n\s*\}/, `inputSchema: ${schemaStr}`);
-        }
-        writeFileSync(fullPath, content);
-        return { success: true };
-    }
-    catch (error) {
-        return { success: false, error: String(error) };
-    }
-}
-/**
- * Delete a tool
- */
-export function deleteTool(workingDir, toolPath) {
-    const fullPath = join(workingDir, toolPath);
-    if (!existsSync(fullPath)) {
-        return { success: false, error: 'Tool file not found' };
-    }
-    try {
-        const rollbackData = readFileSync(fullPath, 'utf-8');
-        unlinkSync(fullPath);
-        return { success: true, rollbackData };
-    }
-    catch (error) {
-        return { success: false, error: String(error) };
-    }
-}
-// ============================================================================
-// GUIDELINE MANAGEMENT
-// ============================================================================
-const GUIDELINES_FILE = join(homedir(), '.erosolar', 'guidelines.json');
-/**
- * Get all guidelines
- */
-export function getGuidelines() {
-    try {
-        if (existsSync(GUIDELINES_FILE)) {
-            return JSON.parse(readFileSync(GUIDELINES_FILE, 'utf-8'));
-        }
-    }
-    catch {
-        // Ignore
-    }
-    return getDefaultGuidelines();
-}
-/**
- * Add a new guideline
- */
-export function addGuideline(guideline) {
-    try {
-        const guidelines = getGuidelines();
-        if (guidelines.some(g => g.id === guideline.id)) {
-            return { success: false, error: 'Guideline with this ID already exists' };
-        }
-        guidelines.push(guideline);
-        saveGuidelines(guidelines);
-        return { success: true };
-    }
-    catch (error) {
-        return { success: false, error: String(error) };
-    }
-}
-/**
- * Update a guideline
- */
-export function updateGuideline(id, updates) {
-    try {
-        const guidelines = getGuidelines();
-        const index = guidelines.findIndex(g => g.id === id);
-        if (index === -1) {
-            return { success: false, error: 'Guideline not found' };
-        }
-        guidelines[index] = { ...guidelines[index], ...updates };
-        saveGuidelines(guidelines);
-        return { success: true };
-    }
-    catch (error) {
-        return { success: false, error: String(error) };
-    }
-}
-/**
- * Delete a guideline
- */
-export function deleteGuideline(id) {
-    try {
-        const guidelines = getGuidelines();
-        const filtered = guidelines.filter(g => g.id !== id);
-        if (filtered.length === guidelines.length) {
-            return { success: false, error: 'Guideline not found' };
-        }
-        saveGuidelines(filtered);
-        return { success: true };
-    }
-    catch (error) {
-        return { success: false, error: String(error) };
-    }
-}
-function saveGuidelines(guidelines) {
-    const dir = join(homedir(), '.erosolar');
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync(GUIDELINES_FILE, JSON.stringify(guidelines, null, 2));
-}
-function getDefaultGuidelines() {
-    return [
-        {
-            id: 'token-efficiency',
-            category: 'performance',
-            rule: 'Minimize token usage while maintaining clarity',
-            rationale: 'Reduces costs and improves response times',
-            severity: 'should',
-        },
-        {
-            id: 'modular-design',
-            category: 'quality',
-            rule: 'Keep tools and capabilities small and focused',
-            rationale: 'Improves maintainability and reusability',
-            severity: 'should',
-        },
-        {
-            id: 'safety-first',
-            category: 'safety',
-            rule: 'Always validate inputs and handle errors gracefully',
-            rationale: 'Prevents security issues and crashes',
-            severity: 'must',
-        },
-        {
-            id: 'documentation',
-            category: 'quality',
-            rule: 'Document public APIs and complex logic',
-            rationale: 'Helps with maintenance and onboarding',
-            severity: 'should',
-        },
-    ];
-}
-/**
- * Generate context optimization strategies
- */
-export function generateContextOptimizations(workingDir) {
-    const optimizations = [];
-    const analysis = analyzeTokenUsage(workingDir);
-    // Strategy 1: Lazy loading for large tools
-    const largeTools = analysis.topConsumers.filter(t => t.tokens > 500 && t.path.includes('tools'));
-    if (largeTools.length > 0) {
-        const savings = largeTools.reduce((sum, t) => sum + Math.floor(t.tokens * 0.7), 0);
-        optimizations.push({
-            strategy: 'lazy-loading',
-            description: `Lazy load ${largeTools.length} large tools`,
-            impact: 'high',
-            tokensSaved: savings,
-            implementation: 'Load tools on-demand instead of at startup',
-        });
-    }
-    // Strategy 2: Schema compression
-    const schemas = analysis.topConsumers.filter(t => t.path.includes('.json'));
-    if (schemas.length > 0) {
-        const savings = schemas.reduce((sum, s) => sum + Math.floor(s.tokens * 0.3), 0);
-        optimizations.push({
-            strategy: 'schema-compression',
-            description: 'Compress JSON schemas by removing optional fields',
-            impact: 'medium',
-            tokensSaved: savings,
-            implementation: 'Minimize schemas to required fields only',
-        });
-    }
-    // Strategy 3: Comment stripping for production
-    const totalCommentSavings = Math.floor(analysis.totalTokens * 0.1);
-    optimizations.push({
-        strategy: 'comment-stripping',
-        description: 'Strip non-essential comments in production',
-        impact: 'medium',
-        tokensSaved: totalCommentSavings,
-        implementation: 'Build step to remove verbose comments',
-    });
-    // Strategy 4: Code deduplication
-    optimizations.push({
-        strategy: 'deduplication',
-        description: 'Extract common patterns into shared utilities',
-        impact: 'medium',
-        tokensSaved: Math.floor(analysis.totalTokens * 0.05),
-        implementation: 'Create shared utils for repeated patterns',
-    });
-    // Strategy 5: Dynamic import chunking
-    optimizations.push({
-        strategy: 'dynamic-imports',
-        description: 'Split rarely-used features into dynamic imports',
-        impact: 'high',
-        tokensSaved: Math.floor(analysis.totalTokens * 0.15),
-        implementation: 'Use import() for optional features',
-    });
-    // Sort by impact
-    optimizations.sort((a, b) => {
-        const impactOrder = { high: 0, medium: 1, low: 2 };
-        return impactOrder[a.impact] - impactOrder[b.impact];
-    });
-    return optimizations;
-}
-// ============================================================================
-// MODULAR ACTIONS
-// ============================================================================
-let pendingActions = [];
-/**
- * Queue a modular action for execution
- */
-export function queueModularAction(action) {
-    pendingActions.push({
-        ...action,
-        approved: false,
-        executed: false,
-    });
-    savePendingActions();
-}
-/**
- * Get pending actions
- */
-export function getPendingActions() {
-    try {
-        if (existsSync(MODULAR_ACTIONS_FILE)) {
-            pendingActions = JSON.parse(readFileSync(MODULAR_ACTIONS_FILE, 'utf-8'));
-        }
-    }
-    catch {
-        // Ignore
-    }
-    return pendingActions.filter(a => !a.executed);
-}
-/**
- * Approve and execute a pending action
- */
-export function executeModularAction(actionIndex, workingDir) {
-    const actions = getPendingActions();
-    const action = actions[actionIndex];
-    if (!action) {
-        return { success: false, error: 'Action not found' };
-    }
-    action.approved = true;
-    try {
-        switch (action.type) {
-            case 'delete':
-                const deleteResult = deleteTool(workingDir, action.target.path);
-                if (!deleteResult.success)
-                    return deleteResult;
-                action.rollbackData = deleteResult.rollbackData;
-                break;
-            case 'optimize':
-                // Optimization would require more complex logic
-                break;
-            case 'merge':
-                // Merge logic
-                break;
-            default:
-                break;
-        }
-        action.executed = true;
-        savePendingActions();
-        return { success: true };
-    }
-    catch (error) {
-        return { success: false, error: String(error) };
-    }
-}
-/**
- * Rollback an executed action
- */
-export function rollbackModularAction(actionIndex, workingDir) {
-    const actions = pendingActions;
-    const action = actions[actionIndex];
-    if (!action || !action.executed) {
-        return { success: false, error: 'Action not found or not executed' };
-    }
-    if (!action.rollbackData) {
-        return { success: false, error: 'No rollback data available' };
-    }
-    try {
-        if (action.type === 'delete') {
-            writeFileSync(join(workingDir, action.target.path), action.rollbackData);
-        }
-        action.executed = false;
-        savePendingActions();
-        return { success: true };
-    }
-    catch (error) {
-        return { success: false, error: String(error) };
-    }
-}
-function savePendingActions() {
-    const dir = join(homedir(), '.erosolar');
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync(MODULAR_ACTIONS_FILE, JSON.stringify(pendingActions, null, 2));
-}
-/**
- * Get overall modular system status
- */
-export function getModularStatus(workingDir) {
-    const targets = discoverModularTargets(workingDir);
-    const analysis = analyzeTokenUsage(workingDir);
-    const guidelines = getGuidelines();
-    const actions = getPendingActions();
-    const issuesByType = {};
-    for (const target of targets) {
-        for (const issue of target.issues) {
-            issuesByType[issue.type] = (issuesByType[issue.type] || 0) + 1;
-        }
-    }
-    const optimizationPotential = analysis.optimizationOpportunities.reduce((sum, o) => sum + o.savings, 0);
-    return {
-        totalTargets: targets.length,
-        totalTokens: analysis.totalTokens,
-        issuesByType,
-        optimizationPotential,
-        pendingActions: actions.length,
-        guidelines: guidelines.length,
-    };
-}
-/**
- * Get formatted status display
- */
-export function getModularStatusDisplay(workingDir) {
-    const status = getModularStatus(workingDir);
-    const analysis = analyzeTokenUsage(workingDir);
-    const lines = [];
-    lines.push('═══════════════════════════════════════════════════════════');
-    lines.push('     🧩 AlphaZero Modular Optimization System');
-    lines.push('═══════════════════════════════════════════════════════════');
-    lines.push('');
-    lines.push(`Total Modular Targets: ${status.totalTargets}`);
-    lines.push(`Total Tokens: ${status.totalTokens.toLocaleString()}`);
-    lines.push(`Optimization Potential: ${status.optimizationPotential.toLocaleString()} tokens`);
-    lines.push('');
-    lines.push('Token Usage by Category:');
-    for (const [category, tokens] of Object.entries(analysis.byCategory)) {
-        const pct = ((tokens / status.totalTokens) * 100).toFixed(1);
-        lines.push(`  ${category}: ${tokens.toLocaleString()} (${pct}%)`);
-    }
-    lines.push('');
-    if (Object.keys(status.issuesByType).length > 0) {
-        lines.push('Issues Found:');
-        for (const [type, count] of Object.entries(status.issuesByType)) {
-            lines.push(`  ${type}: ${count}`);
-        }
-        lines.push('');
-    }
-    lines.push(`Pending Actions: ${status.pendingActions}`);
-    lines.push(`Active Guidelines: ${status.guidelines}`);
-    lines.push('');
-    lines.push('Top Token Consumers:');
-    for (const consumer of analysis.topConsumers.slice(0, 5)) {
-        lines.push(`  ${consumer.tokens.toLocaleString().padStart(6)} | ${consumer.path}`);
-    }
-    lines.push('');
-    lines.push('Commands:');
-    lines.push('  /modular status     - Show this status');
-    lines.push('  /modular analyze    - Analyze optimization opportunities');
-    lines.push('  /modular targets    - List all modular targets');
-    lines.push('  /modular guidelines - Manage guidelines');
-    lines.push('  /modular optimize   - Apply optimizations');
-    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=alphaZeroModular.js.map