erosolar-cli 2.1.294 → 2.1.296

package/dist/core/realAGI.js

@@ -1,947 +0,0 @@
-/**
- * Real AGI Core - Pure Tool-Based Autonomous Intelligence
- *
- * NO INTENTS - Only tools
- * NO SIMULATIONS - Everything executes for real
- * NO CATEGORIES - Just understanding and execution
- *
- * This mirrors how Claude Code works:
- * 1. Understand the prompt
- * 2. Think about what tools to use
- * 3. Execute tools in sequence
- * 4. Display results in Claude Code style
- *
- * Handles ANY prompt: software, research, legal, finance, defense, or anything else
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { execSync } from 'child_process';
-import { getToolEmbeddings } from './toolEmbeddings.js';
-export class RealAGI {
-    workingDir;
-    memory;
-    memoryPath;
-    tools;
-    embeddings;
-    displayCallback = null;
-    constructor(workingDir) {
-        this.workingDir = workingDir || process.cwd();
-        this.memoryPath = path.join(this.workingDir, '.erosolar', 'real-agi-memory.json');
-        this.memory = this.loadMemory();
-        this.tools = this.createRealTools();
-        this.embeddings = getToolEmbeddings(this.workingDir);
-        this.detectProject();
-    }
-    /** Set callback for streaming output through the shell UI */
-    setDisplayCallback(callback) {
-        this.displayCallback = callback;
-    }
-    /** Stream a message through the UI if callback is set */
-    streamToUI(message, type = 'step') {
-        if (this.displayCallback) {
-            this.displayCallback(message, type);
-        }
-    }
-    // ==========================================================================
-    // MEMORY
-    // ==========================================================================
-    loadMemory() {
-        try {
-            if (fs.existsSync(this.memoryPath)) {
-                return JSON.parse(fs.readFileSync(this.memoryPath, 'utf-8'));
-            }
-        }
-        catch { }
-        return {
-            successfulApproaches: [],
-            projectInfo: { type: 'unknown', buildCmd: null, testCmd: null, lintCmd: null },
-        };
-    }
-    saveMemory() {
-        try {
-            const dir = path.dirname(this.memoryPath);
-            if (!fs.existsSync(dir))
-                fs.mkdirSync(dir, { recursive: true });
-            fs.writeFileSync(this.memoryPath, JSON.stringify(this.memory, null, 2));
-        }
-        catch { }
-    }
-    detectProject() {
-        const pkgPath = path.join(this.workingDir, 'package.json');
-        if (fs.existsSync(pkgPath)) {
-            try {
-                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-                this.memory.projectInfo.type = 'node';
-                this.memory.projectInfo.testCmd = pkg.scripts?.test ? 'npm test' : null;
-                this.memory.projectInfo.lintCmd = pkg.scripts?.lint ? 'npm run lint' : null;
-                this.memory.projectInfo.buildCmd = pkg.scripts?.build ? 'npm run build' : null;
-            }
-            catch { }
-        }
-        if (fs.existsSync(path.join(this.workingDir, 'pyproject.toml'))) {
-            this.memory.projectInfo.type = 'python';
-            this.memory.projectInfo.testCmd = 'pytest';
-        }
-        if (fs.existsSync(path.join(this.workingDir, 'Cargo.toml'))) {
-            this.memory.projectInfo.type = 'rust';
-            this.memory.projectInfo.testCmd = 'cargo test';
-            this.memory.projectInfo.buildCmd = 'cargo build';
-        }
-        this.saveMemory();
-    }
-    // ==========================================================================
-    // REAL TOOLS - These actually execute
-    // ==========================================================================
-    createRealTools() {
-        const tools = new Map();
-        // Bash - executes shell commands
-        tools.set('Bash', {
-            name: 'Bash',
-            execute: async (args) => {
-                const start = Date.now();
-                const command = args.command;
-                try {
-                    const output = execSync(command, {
-                        cwd: this.workingDir,
-                        encoding: 'utf-8',
-                        timeout: 120000,
-                        maxBuffer: 10 * 1024 * 1024,
-                    });
-                    return { success: true, output: output.slice(0, 5000), duration: Date.now() - start };
-                }
-                catch (e) {
-                    const error = e;
-                    return {
-                        success: false,
-                        output: error.stdout || '',
-                        error: error.stderr || error.message || 'Command failed',
-                        duration: Date.now() - start,
-                    };
-                }
-            },
-        });
-        // Read - reads files
-        tools.set('Read', {
-            name: 'Read',
-            execute: async (args) => {
-                const start = Date.now();
-                const filePath = args.file_path;
-                const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.workingDir, filePath);
-                try {
-                    const content = fs.readFileSync(fullPath, 'utf-8');
-                    return { success: true, output: content.slice(0, 10000), duration: Date.now() - start };
-                }
-                catch (e) {
-                    return { success: false, output: '', error: e.message, duration: Date.now() - start };
-                }
-            },
-        });
-        // Write - writes files
-        tools.set('Write', {
-            name: 'Write',
-            execute: async (args) => {
-                const start = Date.now();
-                const filePath = args.file_path;
-                const content = args.content;
-                const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.workingDir, filePath);
-                try {
-                    const dir = path.dirname(fullPath);
-                    if (!fs.existsSync(dir))
-                        fs.mkdirSync(dir, { recursive: true });
-                    fs.writeFileSync(fullPath, content);
-                    return { success: true, output: `Written ${content.length} bytes to ${filePath}`, duration: Date.now() - start, artifacts: [fullPath] };
-                }
-                catch (e) {
-                    return { success: false, output: '', error: e.message, duration: Date.now() - start };
-                }
-            },
-        });
-        // Glob - finds files
-        tools.set('Glob', {
-            name: 'Glob',
-            execute: async (args) => {
-                const start = Date.now();
-                const pattern = args.pattern;
-                try {
-                    // Use find command for glob-like behavior
-                    const cmd = `find . -type f -name "${pattern.replace('**/', '')}" 2>/dev/null | head -50`;
-                    const output = execSync(cmd, { cwd: this.workingDir, encoding: 'utf-8' });
-                    return { success: true, output, duration: Date.now() - start };
-                }
-                catch (e) {
-                    return { success: false, output: '', error: e.message, duration: Date.now() - start };
-                }
-            },
-        });
-        // Grep - searches content
-        tools.set('Grep', {
-            name: 'Grep',
-            execute: async (args) => {
-                const start = Date.now();
-                const pattern = args.pattern;
-                const searchPath = args.path || '.';
-                try {
-                    const cmd = `grep -rn "${pattern}" ${searchPath} 2>/dev/null | head -100`;
-                    const output = execSync(cmd, { cwd: this.workingDir, encoding: 'utf-8' });
-                    return { success: true, output, duration: Date.now() - start };
-                }
-                catch {
-                    return { success: true, output: 'No matches found', duration: Date.now() - start };
-                }
-            },
-        });
-        // Edit - edits files (simplified - reads, modifies, writes)
-        tools.set('Edit', {
-            name: 'Edit',
-            execute: async (args) => {
-                const start = Date.now();
-                const filePath = args.file_path;
-                const oldStr = args.old_string;
-                const newStr = args.new_string;
-                const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.workingDir, filePath);
-                try {
-                    let content = fs.readFileSync(fullPath, 'utf-8');
-                    if (!content.includes(oldStr)) {
-                        return { success: false, output: '', error: 'Old string not found in file', duration: Date.now() - start };
-                    }
-                    content = content.replace(oldStr, newStr);
-                    fs.writeFileSync(fullPath, content);
-                    return { success: true, output: `Edited ${filePath}`, duration: Date.now() - start, artifacts: [fullPath] };
-                }
-                catch (e) {
-                    return { success: false, output: '', error: e.message, duration: Date.now() - start };
-                }
-            },
-        });
-        // WebSearch - searches the web (simulated with curl to a search API or just returns search suggestion)
-        tools.set('WebSearch', {
-            name: 'WebSearch',
-            execute: async (args) => {
-                const start = Date.now();
-                const query = args.query;
-                // In real implementation, this would call a search API
-                // For now, we acknowledge the search request
-                return {
-                    success: true,
-                    output: `Search query prepared: "${query}"\nTo execute, use web browser or search API integration.`,
-                    duration: Date.now() - start,
-                };
-            },
-        });
-        // Think - explicit thinking step (outputs thinking process)
-        tools.set('Think', {
-            name: 'Think',
-            execute: async (args) => {
-                const start = Date.now();
-                const thought = args.thought;
-                return { success: true, output: thought, duration: Date.now() - start };
-            },
-        });
-        return tools;
-    }
-    // ==========================================================================
-    // EMBEDDINGS-BASED TOOL SEARCH
-    // ==========================================================================
-    /**
-     * Search for relevant tools using embeddings (dot product similarity)
-     */
-    async searchTools(prompt, topK = 5) {
-        return this.embeddings.search(prompt, topK);
-    }
-    /**
-     * Get recommended tools for a prompt using embeddings
-     */
-    async getRecommendedTools(prompt) {
-        return this.embeddings.recommendTools(prompt);
-    }
-    /**
-     * Format tool search results
-     */
-    async formatToolSearch(prompt) {
-        const matches = await this.embeddings.search(prompt, 5);
-        return this.embeddings.formatSearchResults(matches);
-    }
-    // ==========================================================================
-    // UNDERSTANDING - No intents, just figure out what tools to use
-    // ==========================================================================
-    /**
-     * Understand any prompt and figure out what tools to run
-     * This is the core AGI function - no intents, just tool planning
-     */
-    understand(prompt) {
-        const lower = prompt.toLowerCase();
-        const thinking = [];
-        const steps = [];
-        let stepId = 0;
-        const addStep = (tool, args, description, deps = []) => {
-            const id = `step-${stepId++}`;
-            steps.push({ id, tool, args, description, dependsOn: deps, status: 'pending' });
-            return id;
-        };
-        // Think about what we're doing
-        thinking.push(`Understanding prompt: "${prompt}"`);
-        // ========================================================================
-        // SOFTWARE ENGINEERING PATTERNS
-        // ========================================================================
-        if (/fix|bug|error|broken|crash|fail/i.test(lower)) {
-            thinking.push('This looks like bug fixing - I should run diagnostics first');
-            const lintId = addStep('Bash', { command: this.memory.projectInfo.lintCmd || 'npm run lint 2>&1 || true' }, 'Run linter to find issues');
-            const typeId = addStep('Bash', { command: 'npx tsc --noEmit 2>&1 || true' }, 'Check for type errors');
-            const testId = addStep('Bash', { command: this.memory.projectInfo.testCmd || 'npm test 2>&1 || true' }, 'Run tests to find failures');
-            const todoId = addStep('Grep', { pattern: 'TODO|FIXME|BUG|HACK', path: 'src' }, 'Search for known issues');
-            thinking.push('After diagnostics, I can analyze and fix the issues');
-            addStep('Think', { thought: 'Analyzing diagnostic results to prioritize fixes...' }, 'Analyze findings', [lintId, typeId, testId, todoId]);
-        }
-        // Feature addition
-        else if (/add|create|implement|build|new|feature/i.test(lower)) {
-            thinking.push('This is about adding something new - I should understand the codebase first');
-            const exploreId = addStep('Bash', { command: 'find src -name "*.ts" -o -name "*.js" | head -20' }, 'Explore codebase structure');
-            const pkgId = addStep('Read', { file_path: 'package.json' }, 'Read project configuration');
-            thinking.push('Then I can plan and implement the feature');
-            addStep('Think', { thought: 'Planning implementation based on codebase analysis...' }, 'Plan implementation', [exploreId, pkgId]);
-        }
-        // Testing
-        else if (/test|spec|coverage/i.test(lower)) {
-            thinking.push('This is about testing');
-            addStep('Bash', { command: this.memory.projectInfo.testCmd || 'npm test 2>&1' }, 'Run test suite');
-        }
-        // Security
-        else if (/security|vulnerab|audit|pentest|hack|exploit|cyber|attack/i.test(lower)) {
-            thinking.push('This is a security-related task');
-            const auditId = addStep('Bash', { command: 'npm audit 2>&1 || true' }, 'Audit dependencies for vulnerabilities');
-            const secretsId = addStep('Grep', { pattern: 'password|secret|api.key|token', path: '.' }, 'Search for hardcoded secrets');
-            const evalId = addStep('Grep', { pattern: 'eval\\(|exec\\(|innerHTML', path: 'src' }, 'Search for dangerous patterns');
-            addStep('Think', { thought: 'Analyzing security findings...' }, 'Analyze security results', [auditId, secretsId, evalId]);
-        }
-        // DevOps (but not infrastructure analysis)
-        else if (/devops|ci\/cd|pipeline|docker|kubernetes|deploy|k8s|helm|terraform/i.test(lower) && !/infrastructure.*(analysis|assessment|destruction|attack)/i.test(lower)) {
-            thinking.push('This is a DevOps task');
-            addStep('Bash', { command: 'ls -la .github/workflows/ 2>/dev/null || echo "No GitHub workflows"' }, 'Check CI/CD configuration');
-            addStep('Bash', { command: 'cat Dockerfile 2>/dev/null || echo "No Dockerfile"' }, 'Check Docker configuration');
-            addStep('Bash', { command: 'cat docker-compose.yml 2>/dev/null || echo "No docker-compose"' }, 'Check Docker Compose');
-        }
-        // ========================================================================
-        // RESEARCH & SCIENCE PATTERNS
-        // ========================================================================
-        else if (/cure|cancer|research|experiment|clinical|biomedical|genom/i.test(lower)) {
-            thinking.push('This is a research/science task - I will set up analysis tools');
-            addStep('Think', { thought: 'Research task identified. Building computational pipeline...' }, 'Define research scope');
-            addStep('WebSearch', { query: `${prompt} research papers methods` }, 'Search for relevant research');
-            addStep('Bash', { command: 'python3 --version 2>/dev/null || echo "Python not found"' }, 'Check Python environment');
-            addStep('Write', { file_path: 'research_pipeline.py', content: `# Research Pipeline for: ${prompt}\n# Generated by AGI\n\nimport pandas as pd\nimport numpy as np\n\n# TODO: Implement analysis\nprint("Research pipeline initialized")` }, 'Create research pipeline scaffold');
-        }
-        // Data Science
-        else if (/data|ml|machine.learning|model|neural|statistic/i.test(lower)) {
-            thinking.push('This is a data science task');
-            addStep('Bash', { command: 'python3 -c "import pandas; import numpy; import sklearn; print(\'ML libs OK\')" 2>&1 || pip install pandas numpy scikit-learn' }, 'Check/install ML libraries');
-            addStep('Write', { file_path: 'analysis.py', content: `# Data Analysis for: ${prompt}\nimport pandas as pd\nimport numpy as np\nfrom sklearn.model_selection import train_test_split\n\n# TODO: Load data and build model` }, 'Create analysis scaffold');
-        }
-        // ========================================================================
-        // LEGAL PATTERNS
-        // ========================================================================
-        else if (/sue|lawsuit|litigation|legal|court|attorney|lawyer|contract|complaint/i.test(lower)) {
-            thinking.push('This is a legal task - I will set up document generation');
-            // Extract defendant if present
-            const defendantMatch = lower.match(/sue\s+(\w+)/i) || lower.match(/against\s+(\w+)/i);
-            const defendant = defendantMatch ? defendantMatch[1] : 'defendant';
-            addStep('Think', { thought: `Legal action against ${defendant}. Preparing document automation...` }, 'Identify legal framework');
-            addStep('WebSearch', { query: `federal court complaint requirements ${defendant}` }, 'Research legal requirements');
-            addStep('Write', {
-                file_path: 'legal/complaint_draft.md',
-                content: `# COMPLAINT\n\n## IN THE UNITED STATES DISTRICT COURT\n\n### PLAINTIFF\nvs.\n\n### ${defendant.toUpperCase()} (Defendant)\n\n---\n\n## JURISDICTION\n[To be completed]\n\n## FACTS\n[To be completed]\n\n## CAUSES OF ACTION\n[To be completed]\n\n## PRAYER FOR RELIEF\n[To be completed]\n\n---\nGenerated by AGI Legal Document System`,
-            }, 'Draft complaint document');
-            addStep('Write', {
-                file_path: 'legal/discovery_plan.md',
-                content: `# Discovery Plan\n\n## Interrogatories\n1. [To be drafted]\n\n## Document Requests\n1. [To be drafted]\n\n## Depositions\n1. [To be scheduled]`,
-            }, 'Create discovery plan');
-        }
-        // ========================================================================
-        // FINANCE PATTERNS
-        // ========================================================================
-        else if (/accounting|bookkeeping|financ|tax|ledger|budget|invoice|payroll/i.test(lower)) {
-            thinking.push('This is a finance/accounting task');
-            addStep('Think', { thought: 'Financial task identified. Setting up accounting tools...' }, 'Define financial scope');
-            addStep('Bash', { command: 'python3 -c "import pandas; print(\'pandas OK\')" 2>&1 || pip install pandas openpyxl' }, 'Check financial libraries');
-            addStep('Write', {
-                file_path: 'finance/ledger.py',
-                content: `# Financial Ledger System\nimport pandas as pd\nfrom datetime import datetime\n\nclass Ledger:\n    def __init__(self):\n        self.transactions = pd.DataFrame(columns=['date', 'description', 'debit', 'credit', 'account'])\n    \n    def add_entry(self, desc, debit=0, credit=0, account='general'):\n        self.transactions = pd.concat([self.transactions, pd.DataFrame([{\n            'date': datetime.now(),\n            'description': desc,\n            'debit': debit,\n            'credit': credit,\n            'account': account\n        }])], ignore_index=True)\n    \n    def balance(self):\n        return self.transactions['debit'].sum() - self.transactions['credit'].sum()\n\nif __name__ == '__main__':\n    ledger = Ledger()\n    print('Ledger initialized')`,
-            }, 'Create ledger system');
-        }
-        // ========================================================================
-        // DEFENSE PATTERNS
-        // ========================================================================
-        else if (/fighter|drone|missile|ballistic|reentry|carrier|military|warfare|combat|weapon|hypersonic|6th.gen|coordination/i.test(lower)) {
-            thinking.push('This is a defense systems task - building simulation framework');
-            addStep('Think', { thought: 'Defense system task. Building simulation and coordination framework...' }, 'Analyze requirements');
-            // Drone coordination
-            if (/drone|coordination|swarm/i.test(lower)) {
-                addStep('Write', {
-                    file_path: 'defense/swarm_coordination.py',
-                    content: `# 6th Gen Fighter Drone Swarm Coordination System
-import numpy as np
-from dataclasses import dataclass
-from typing import List, Tuple
-import asyncio
-
-@dataclass
-class Drone:
-    id: str
-    position: Tuple[float, float, float]  # x, y, z
-    velocity: Tuple[float, float, float]
-    status: str = 'active'
-
-class SwarmCoordinator:
-    def __init__(self):
-        self.drones: List[Drone] = []
-        self.formation = 'combat_spread'
-
-    def add_drone(self, drone: Drone):
-        self.drones.append(drone)
-
-    def calculate_formation(self) -> List[Tuple[float, float, float]]:
-        """Calculate optimal positions for current formation"""
-        n = len(self.drones)
-        if self.formation == 'combat_spread':
-            # Diamond formation with altitude variation
-            positions = []
-            for i, d in enumerate(self.drones):
-                angle = (2 * np.pi * i) / n
-                r = 1000  # 1km spread
-                x = r * np.cos(angle)
-                y = r * np.sin(angle)
-                z = 10000 + (i % 3) * 500  # Altitude staggering
-                positions.append((x, y, z))
-            return positions
-        return [(d.position) for d in self.drones]
-
-    def threat_response(self, threat_pos: Tuple[float, float, float]):
-        """Coordinate response to detected threat"""
-        # Assign nearest drones to intercept
-        distances = []
-        for d in self.drones:
-            dist = np.sqrt(sum((a-b)**2 for a,b in zip(d.position, threat_pos)))
-            distances.append((dist, d))
-        distances.sort()
-        interceptors = [d for _, d in distances[:3]]  # Top 3 closest
-        return interceptors
-
-if __name__ == '__main__':
-    coord = SwarmCoordinator()
-    for i in range(6):
-        coord.add_drone(Drone(f'drone-{i}', (0,0,10000), (0,0,0)))
-    print(f'Swarm initialized with {len(coord.drones)} drones')
-    print(f'Formation positions: {coord.calculate_formation()}')`,
-                }, 'Create swarm coordination system');
-            }
-            // Ballistic targeting
-            if (/ballistic|reentry|mrv|carrier|targeting/i.test(lower)) {
-                addStep('Write', {
-                    file_path: 'defense/targeting_system.py',
-                    content: `# Ballistic Maneuverable Reentry Vehicle Targeting System
-import numpy as np
-from dataclasses import dataclass
-from typing import Tuple, List
-import time
-
-@dataclass
-class Target:
-    id: str
-    position: Tuple[float, float]  # lat, lon
-    velocity: Tuple[float, float]  # km/h
-    type: str  # 'carrier', 'destroyer', etc.
-    last_update: float
-
-@dataclass
-class ReentryVehicle:
-    id: str
-    position: Tuple[float, float, float]  # lat, lon, alt
-    velocity: float
-    maneuvering: bool = True
-
-class TargetingNetwork:
-    def __init__(self):
-        self.targets: List[Target] = []
-        self.vehicles: List[ReentryVehicle] = []
-        self.sensor_network = []
-
-    def update_target(self, target_id: str, new_pos: Tuple[float, float], velocity: Tuple[float, float]):
-        """Update target position from sensor network"""
-        for t in self.targets:
-            if t.id == target_id:
-                t.position = new_pos
-                t.velocity = velocity
-                t.last_update = time.time()
-                return
-        # New target
-        self.targets.append(Target(target_id, new_pos, velocity, 'unknown', time.time()))
-
-    def predict_position(self, target: Target, time_delta: float) -> Tuple[float, float]:
-        """Predict target position at future time"""
-        lat = target.position[0] + (target.velocity[0] * time_delta / 111)  # Rough conversion
-        lon = target.position[1] + (target.velocity[1] * time_delta / 111)
-        return (lat, lon)
-
-    def calculate_intercept(self, vehicle: ReentryVehicle, target: Target) -> Tuple[float, float]:
-        """Calculate optimal intercept point for mobile target"""
-        # Estimate time to target based on current altitude and velocity
-        descent_time = vehicle.position[2] / (vehicle.velocity * 3.6)  # Convert to seconds
-        predicted_pos = self.predict_position(target, descent_time)
-        return predicted_pos
-
-    def assign_targets(self) -> List[Tuple[str, str]]:
-        """Assign vehicles to targets optimally"""
-        assignments = []
-        available = list(self.vehicles)
-        for target in sorted(self.targets, key=lambda t: t.type == 'carrier', reverse=True):
-            if available:
-                vehicle = available.pop(0)
-                assignments.append((vehicle.id, target.id))
-        return assignments
-
-if __name__ == '__main__':
-    network = TargetingNetwork()
-    network.targets.append(Target('CVN-77', (35.0, 140.0), (15, 10), 'carrier', time.time()))
-    network.vehicles.append(ReentryVehicle('MRV-1', (40.0, 135.0, 100000), 7000))
-    print(f'Targeting network: {len(network.targets)} targets, {len(network.vehicles)} vehicles')
-    print(f'Assignments: {network.assign_targets()}')`,
-                }, 'Create targeting network system');
-            }
-            addStep('Bash', { command: 'python3 defense/*.py 2>&1 || echo "Defense systems initialized"' }, 'Test defense systems');
-        }
-        // ========================================================================
-        // AUTOMATION PATTERNS
-        // ========================================================================
-        else if (/automat|workflow|schedule|cron|script/i.test(lower)) {
-            thinking.push('This is an automation task');
-            addStep('Think', { thought: 'Automation task. Analyzing workflow requirements...' }, 'Analyze automation needs');
-            addStep('Write', {
-                file_path: 'automation/workflow.sh',
-                content: `#!/bin/bash\n# Automated Workflow\n# Generated by AGI\n\nset -e\n\necho "Starting automated workflow..."\n\n# Add workflow steps here\necho "Workflow complete"`,
-            }, 'Create automation script');
-            addStep('Bash', { command: 'chmod +x automation/workflow.sh' }, 'Make script executable');
-        }
-        // ========================================================================
-        // BUSINESS STRATEGY / COMPETITIVE PATTERNS
-        // ========================================================================
-        else if (/kill|destroy|defeat|disrupt|compete|dominate|outcompete|crush|beat/i.test(lower)) {
-            thinking.push('This is a competitive/business strategy task');
-            // Extract target entity
-            const targetMatch = lower.match(/(?:kill|destroy|defeat|disrupt|compete|dominate|outcompete|crush|beat)\s+(\w+)/i);
-            const target = targetMatch ? targetMatch[1] : 'competitor';
-            addStep('Think', { thought: `Competitive strategy against ${target}. Analyzing market position...` }, 'Analyze competitive landscape');
-            addStep('WebSearch', { query: `${target} company weaknesses market analysis SWOT` }, 'Research competitor');
-            addStep('Write', {
-                file_path: 'strategy/competitive_analysis.md',
-                content: `# Competitive Strategy: ${target.toUpperCase()}
-
-## Executive Summary
-Strategic analysis for competitive positioning against ${target}.
-
-## Market Analysis
-- Current market position: [To be analyzed]
-- Market share: [To be researched]
-- Key vulnerabilities: [To be identified]
-
-## Strategic Options
-1. **Product Differentiation**
-   - Identify unique value propositions
-   - Focus on underserved segments
-
-2. **Pricing Strategy**
-   - Competitive pricing analysis
-   - Value-based positioning
-
-3. **Technology Advantage**
-   - Innovation pipeline
-   - Patent landscape
-
-4. **Market Expansion**
-   - Geographic opportunities
-   - New customer segments
-
-## Implementation Roadmap
-- Phase 1: Research & Analysis
-- Phase 2: Strategy Development
-- Phase 3: Execution
-- Phase 4: Monitoring & Adjustment
-
----
-Generated by AGI Strategic Planning System`,
-            }, 'Create competitive strategy document');
-            addStep('Write', {
-                file_path: 'strategy/action_plan.md',
-                content: `# Action Plan: Competitive Response
-
-## Immediate Actions (0-30 days)
-- [ ] Complete market research
-- [ ] Identify key differentiators
-- [ ] Analyze pricing structure
-
-## Short-term (1-3 months)
-- [ ] Develop response strategy
-- [ ] Resource allocation
-- [ ] Team alignment
-
-## Long-term (3-12 months)
-- [ ] Execute strategy
-- [ ] Monitor results
-- [ ] Iterate based on feedback`,
-            }, 'Create action plan');
-        }
-        // ========================================================================
-        // INFRASTRUCTURE / SYSTEMS PATTERNS
-        // ========================================================================
-        else if (/infrastructure|system|network|grid|power|utility|scada|ics|critical/i.test(lower)) {
-            thinking.push('This is an infrastructure/systems analysis task');
-            addStep('Think', { thought: 'Infrastructure analysis task. Building assessment framework...' }, 'Define scope');
-            addStep('Write', {
-                file_path: 'infrastructure/assessment.md',
-                content: `# Infrastructure Assessment Framework
-
-## Scope
-Analysis of infrastructure systems and dependencies.
-
-## Components
-1. **Network Infrastructure**
-   - Topology analysis
-   - Redundancy assessment
-   - Performance metrics
-
-2. **Physical Infrastructure**
-   - Power systems
-   - Cooling systems
-   - Physical security
-
-3. **Software Infrastructure**
-   - Operating systems
-   - Middleware
-   - Applications
-
-## Risk Analysis
-- Single points of failure
-- Dependency mapping
-- Recovery time objectives
-
-## Recommendations
-[To be completed based on analysis]
-
----
-Generated by AGI Infrastructure Analysis System`,
-            }, 'Create assessment framework');
-            addStep('Write', {
-                file_path: 'infrastructure/topology.py',
-                content: `# Infrastructure Topology Analyzer
-from dataclasses import dataclass
-from typing import List, Dict, Optional
-import json
-
-@dataclass
-class Node:
-    id: str
-    type: str  # 'server', 'router', 'switch', 'firewall', etc.
-    dependencies: List[str]
-    criticality: str  # 'critical', 'high', 'medium', 'low'
-
-class InfrastructureMap:
-    def __init__(self):
-        self.nodes: Dict[str, Node] = {}
-        self.connections: List[tuple] = []
-
-    def add_node(self, node: Node):
-        self.nodes[node.id] = node
-
-    def add_connection(self, source: str, target: str):
-        self.connections.append((source, target))
-
-    def find_critical_path(self) -> List[str]:
-        """Find nodes that are critical to system operation"""
-        critical = [n.id for n in self.nodes.values() if n.criticality == 'critical']
-        return critical
-
-    def find_single_points_of_failure(self) -> List[str]:
-        """Identify nodes with no redundancy"""
-        spof = []
-        for node_id, node in self.nodes.items():
-            # Count incoming connections
-            incoming = sum(1 for s, t in self.connections if t == node_id)
-            if incoming <= 1 and node.criticality in ['critical', 'high']:
-                spof.append(node_id)
-        return spof
-
-    def export_topology(self) -> dict:
-        return {
-            'nodes': [{'id': n.id, 'type': n.type, 'criticality': n.criticality} for n in self.nodes.values()],
-            'connections': self.connections
-        }
-
-if __name__ == '__main__':
-    infra = InfrastructureMap()
-    infra.add_node(Node('core-router', 'router', [], 'critical'))
-    infra.add_node(Node('web-server-1', 'server', ['core-router'], 'high'))
-    infra.add_connection('core-router', 'web-server-1')
-    print(f'Infrastructure map: {len(infra.nodes)} nodes')
-    print(f'SPOFs: {infra.find_single_points_of_failure()}')`,
-            }, 'Create topology analyzer');
-        }
-        // ========================================================================
-        // GENERAL ENGINEERING / SCIENCE PATTERNS
-        // ========================================================================
-        else if (/engineer|science|physics|chemistry|biology|math|calcul|algorithm|formula/i.test(lower)) {
-            thinking.push('This is a general engineering/science task');
-            addStep('Think', { thought: 'Engineering/science task. Setting up computational environment...' }, 'Define problem domain');
-            addStep('Bash', { command: 'python3 --version && pip3 list 2>/dev/null | head -20 || echo "Checking Python environment"' }, 'Check computational environment');
-            addStep('Write', {
-                file_path: 'science/analysis.py',
-                content: `# Scientific Analysis Framework
-# Generated for: ${prompt}
-
-import numpy as np
-from typing import List, Tuple, Optional
-import json
-
-class ScientificAnalysis:
-    """Framework for scientific computation and analysis"""
-
-    def __init__(self, name: str):
-        self.name = name
-        self.data = []
-        self.results = {}
-
-    def load_data(self, data: List[float]):
-        self.data = np.array(data)
-
-    def basic_stats(self) -> dict:
-        if len(self.data) == 0:
-            return {}
-        return {
-            'mean': float(np.mean(self.data)),
-            'std': float(np.std(self.data)),
-            'min': float(np.min(self.data)),
-            'max': float(np.max(self.data)),
-            'median': float(np.median(self.data))
-        }
-
-    def run_analysis(self) -> dict:
-        self.results = self.basic_stats()
-        return self.results
-
-    def export_results(self, path: str):
-        with open(path, 'w') as f:
-            json.dump(self.results, f, indent=2)
-
-if __name__ == '__main__':
-    analysis = ScientificAnalysis('${prompt.slice(0, 50)}')
-    analysis.load_data([1.0, 2.0, 3.0, 4.0, 5.0])
-    print(f'Analysis: {analysis.run_analysis()}')`,
-            }, 'Create analysis framework');
-        }
-        // ========================================================================
-        // DEFAULT - General task
-        // ========================================================================
-        else {
-            thinking.push('Analyzing this as a general task');
-            addStep('Think', { thought: `Understanding request: ${prompt}` }, 'Analyze request');
-            addStep('Bash', { command: 'pwd && ls -la' }, 'Examine current directory');
-            addStep('Read', { file_path: 'README.md' }, 'Read project documentation');
-        }
-        return {
-            prompt,
-            thinking,
-            steps,
-            startTime: Date.now(),
-        };
-    }
-    // ==========================================================================
-    // EXECUTION - Actually run the tools
-    // ==========================================================================
-    /**
-     * Execute a plan - runs each tool for real
-     */
-    async execute(plan) {
-        const completedIds = new Set();
-        for (const step of plan.steps) {
-            // Check dependencies
-            const depsReady = step.dependsOn.every(dep => completedIds.has(dep));
-            if (!depsReady) {
-                // Find unmet dependencies and wait
-                for (const depId of step.dependsOn) {
-                    if (!completedIds.has(depId)) {
-                        const depStep = plan.steps.find(s => s.id === depId);
-                        if (depStep && depStep.status === 'pending') {
-                            // Execute dependency first
-                            await this.executeStep(depStep);
-                            completedIds.add(depStep.id);
-                        }
-                    }
-                }
-            }
-            await this.executeStep(step);
-            completedIds.add(step.id);
-        }
-        plan.endTime = Date.now();
-        // Record success for learning
-        this.memory.successfulApproaches.push({
-            prompt: plan.prompt,
-            tools: plan.steps.map(s => s.tool),
-            success: plan.steps.every(s => s.status === 'completed'),
-            timestamp: Date.now(),
-        });
-        this.memory.successfulApproaches = this.memory.successfulApproaches.slice(-100);
-        this.saveMemory();
-        return plan;
-    }
-    async executeStep(step) {
-        step.status = 'running';
-        const tool = this.tools.get(step.tool);
-        if (!tool) {
-            step.status = 'failed';
-            step.result = { success: false, output: '', error: `Unknown tool: ${step.tool}`, duration: 0 };
-            return;
-        }
-        try {
-            step.result = await tool.execute(step.args);
-            step.status = step.result.success ? 'completed' : 'failed';
-        }
-        catch (e) {
-            step.status = 'failed';
-            step.result = { success: false, output: '', error: e.message, duration: 0 };
-        }
-    }
-    // ==========================================================================
-    // DISPLAY - Claude Code style output
-    // ==========================================================================
-    /**
-     * Format execution plan in Claude Code style
-     */
-    formatPlan(plan) {
-        const lines = [];
-        // Thinking section
-        lines.push('⏺ Thinking...');
-        for (const thought of plan.thinking) {
-            lines.push(`  ⎿ ${thought}`);
-        }
-        lines.push('');
-        // Steps section
-        lines.push('⏺ Execution Plan');
-        for (let i = 0; i < plan.steps.length; i++) {
-            const step = plan.steps[i];
-            const status = step.status === 'completed' ? '●' :
-                step.status === 'failed' ? '✗' :
-                    step.status === 'running' ? '◐' : '○';
-            const deps = step.dependsOn.length > 0 ? ` ← [${step.dependsOn.join(', ')}]` : '';
-            lines.push(`  ${status} [${i + 1}] ${step.description}${deps}`);
-            lines.push(`      Tool: ${step.tool}(${this.formatArgs(step.args)})`);
-        }
-        lines.push('');
-        return lines.join('\n');
-    }
-    /**
-     * Format execution results in Claude Code style
-     */
-    formatResults(plan) {
-        const lines = [];
-        lines.push('⏺ Execution Results');
-        lines.push('');
-        for (let i = 0; i < plan.steps.length; i++) {
-            const step = plan.steps[i];
-            const status = step.status === 'completed' ? '✓' : '✗';
-            lines.push(`${status} ${step.tool}(${this.formatArgs(step.args)})`);
-            if (step.result) {
-                const output = step.result.output.split('\n').slice(0, 5).join('\n');
-                if (output.trim()) {
-                    lines.push(`  ⎿ ${output.split('\n').join('\n  ⎿ ')}`);
-                }
-                if (step.result.error) {
-                    lines.push(`  ⎿ ERROR: ${step.result.error}`);
-                }
-                lines.push(`  ⎿ (${step.result.duration}ms)`);
-            }
-            lines.push('');
-        }
-        const duration = plan.endTime ? plan.endTime - plan.startTime : 0;
-        const success = plan.steps.filter(s => s.status === 'completed').length;
-        const total = plan.steps.length;
-        lines.push(`⏺ Complete: ${success}/${total} steps succeeded (${duration}ms)`);
-        return lines.join('\n');
-    }
-    formatArgs(args) {
-        return Object.entries(args)
-            .map(([k, v]) => {
-            const str = String(v);
-            return `${k}="${str.length > 30 ? str.slice(0, 27) + '...' : str}"`;
-        })
-            .join(', ');
-    }
-    // ==========================================================================
-    // PUBLIC API
-    // ==========================================================================
-    /**
-     * Process any prompt - understand, plan, execute, display
-     * Streams output through the UI callback if set
-     */
-    async process(prompt, dryRun = false) {
-        const plan = this.understand(prompt);
-        // Stream thinking through UI
-        this.streamToUI('⏺ Thinking...', 'thinking');
-        for (const thought of plan.thinking) {
-            this.streamToUI(`  ⎿ ${thought}`, 'thinking');
-        }
-        // Stream plan through UI
-        this.streamToUI('', 'step');
-        this.streamToUI('⏺ Execution Plan', 'step');
-        for (let i = 0; i < plan.steps.length; i++) {
-            const step = plan.steps[i];
-            const deps = step.dependsOn.length > 0 ? ` ← [${step.dependsOn.join(', ')}]` : '';
-            this.streamToUI(`  ○ [${i + 1}] ${step.description}${deps}`, 'step');
-        }
-        if (dryRun) {
-            const output = this.formatPlan(plan) + '\n(Dry run - not executed)';
-            this.streamToUI(output, 'complete');
-            return output;
-        }
-        // Execute and stream results
-        this.streamToUI('', 'step');
-        this.streamToUI('⏺ Executing...', 'step');
-        const executed = await this.execute(plan);
-        // Stream results through UI
-        this.streamToUI('', 'result');
-        this.streamToUI('⏺ Results', 'result');
-        for (const step of executed.steps) {
-            const status = step.status === 'completed' ? '✓' : '✗';
-            this.streamToUI(`${status} ${step.tool}`, 'result');
-            if (step.result?.output) {
-                const lines = step.result.output.split('\n').slice(0, 3);
-                for (const line of lines) {
-                    this.streamToUI(`  ⎿ ${line}`, 'result');
-                }
-            }
-            if (step.result?.error) {
-                this.streamToUI(`  ⎿ ERROR: ${step.result.error}`, 'error');
-            }
-        }
-        const duration = executed.endTime ? executed.endTime - executed.startTime : 0;
-        const success = executed.steps.filter(s => s.status === 'completed').length;
-        const total = executed.steps.length;
-        this.streamToUI('', 'complete');
-        this.streamToUI(`⏺ Complete: ${success}/${total} steps (${duration}ms)`, 'complete');
-        // Return full formatted output for compatibility
-        return this.formatPlan(plan) + this.formatResults(executed);
-    }
-    getMemory() {
-        return this.memory;
-    }
-}
-// ============================================================================
-// SINGLETON
-// ============================================================================
-let instance = null;
-export function getRealAGI(workingDir) {
-    if (!instance || (workingDir && workingDir !== instance['workingDir'])) {
-        instance = new RealAGI(workingDir);
-    }
-    return instance;
-}
-export function resetRealAGI() {
-    instance = null;
-}
-//# sourceMappingURL=realAGI.js.map