erosolar-cli 1.7.439 → 1.7.441

package/dist/core/alphaZeroModular.js

@@ -0,0 +1,755 @@
+/**
+ * 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