nexusforge-cli 1.1.1 → 1.2.1

package/dist/modules/forgeEngine.js

@@ -0,0 +1,652 @@
+/**
+ * NexusForge Forge Engine
+ * Autonomous building and execution system
+ * Ported from Python: nexusforge/modules/architecture/forge_engine.py
+ */
+import { resolve, join } from 'path';
+import { mkdirSync, existsSync, writeFileSync, readdirSync, statSync } from 'fs';
+// ============================================================================
+// ENUMS
+// ============================================================================
+export var ForgeMode;
+(function (ForgeMode) {
+    ForgeMode["ARCHITECT"] = "architect";
+    ForgeMode["BUILDER"] = "builder";
+    ForgeMode["ANALYST"] = "analyst";
+    ForgeMode["OPTIMIZER"] = "optimizer";
+    ForgeMode["DEBUGGER"] = "debugger";
+    ForgeMode["MENTOR"] = "mentor";
+    ForgeMode["REFACTOR"] = "refactor";
+    ForgeMode["SECURITY"] = "security";
+})(ForgeMode || (ForgeMode = {}));
+export var BuildPhase;
+(function (BuildPhase) {
+    BuildPhase["PLANNING"] = "planning";
+    BuildPhase["SCAFFOLDING"] = "scaffolding";
+    BuildPhase["IMPLEMENTING"] = "implementing";
+    BuildPhase["TESTING"] = "testing";
+    BuildPhase["VALIDATING"] = "validating";
+    BuildPhase["OPTIMIZING"] = "optimizing";
+    BuildPhase["DOCUMENTING"] = "documenting";
+    BuildPhase["DEPLOYING"] = "deploying";
+    BuildPhase["COMPLETE"] = "complete";
+    BuildPhase["FAILED"] = "failed";
+})(BuildPhase || (BuildPhase = {}));
+export var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus["PENDING"] = "pending";
+    TaskStatus["IN_PROGRESS"] = "in_progress";
+    TaskStatus["BLOCKED"] = "blocked";
+    TaskStatus["COMPLETED"] = "completed";
+    TaskStatus["FAILED"] = "failed";
+    TaskStatus["CANCELLED"] = "cancelled";
+})(TaskStatus || (TaskStatus = {}));
+// ============================================================================
+// TECH STACK INFERENCE
+// ============================================================================
+const TECH_HINTS = {
+    web: ['HTML', 'CSS', 'JavaScript'],
+    react: ['React', 'Node.js', 'Webpack', 'Babel'],
+    vue: ['Vue.js', 'Node.js', 'Webpack'],
+    angular: ['Angular', 'TypeScript', 'RxJS'],
+    next: ['Next.js', 'React', 'Node.js'],
+    python: ['Python', 'pip', 'virtualenv'],
+    api: ['FastAPI', 'PostgreSQL', 'Redis'],
+    'rest api': ['FastAPI', 'OpenAPI', 'Pydantic'],
+    graphql: ['GraphQL', 'Apollo', 'PostgreSQL'],
+    mobile: ['React Native', 'Expo', 'TypeScript'],
+    ios: ['Swift', 'UIKit', 'CocoaPods'],
+    android: ['Kotlin', 'Android SDK', 'Gradle'],
+    desktop: ['Electron', 'TypeScript', 'Node.js'],
+    cli: ['Node.js', 'TypeScript', 'Commander'],
+    bot: ['Node.js', 'Discord.js'],
+    ml: ['Python', 'TensorFlow', 'NumPy', 'scikit-learn'],
+    data: ['Python', 'Pandas', 'Jupyter', 'Matplotlib'],
+    rust: ['Rust', 'Cargo', 'tokio'],
+    go: ['Go', 'Go Modules'],
+    docker: ['Docker', 'Docker Compose'],
+    kubernetes: ['Kubernetes', 'Helm', 'kubectl'],
+    typescript: ['TypeScript', 'Node.js'],
+    express: ['Express', 'Node.js'],
+    nestjs: ['NestJS', 'TypeScript', 'Node.js'],
+    django: ['Django', 'Python', 'PostgreSQL'],
+    flask: ['Flask', 'Python'],
+};
+// ============================================================================
+// FORGE ENGINE CLASS
+// ============================================================================
+export class ForgeEngine {
+    workspace;
+    projectName;
+    activeMode;
+    taskQueue;
+    completedTasks;
+    failedTasks;
+    currentTask;
+    blueprint;
+    forgeState;
+    constructor(workspace, projectName) {
+        this.workspace = workspace ? resolve(workspace) : process.cwd();
+        this.projectName = projectName || this.workspace.split(/[/\\]/).pop() || 'project';
+        this.activeMode = ForgeMode.BUILDER;
+        this.taskQueue = [];
+        this.completedTasks = [];
+        this.failedTasks = [];
+        this.forgeState = {
+            totalBuilds: 0,
+            successfulBuilds: 0,
+            failedBuilds: 0,
+            linesWritten: 0,
+            testsPassed: 0,
+            optimizationsMade: 0,
+            bugsFixed: 0,
+        };
+        // Ensure workspace exists
+        if (!existsSync(this.workspace)) {
+            mkdirSync(this.workspace, { recursive: true });
+        }
+    }
+    // ========================================================================
+    // DIRECTIVE PROCESSING
+    // ========================================================================
+    async processDirective(directive, context) {
+        const mode = this.determineMode(directive);
+        this.activeMode = mode;
+        const task = {
+            id: `task_${Date.now()}`,
+            directive,
+            mode,
+            phase: BuildPhase.PLANNING,
+            priority: 5,
+            dependencies: [],
+            artifacts: {},
+            progress: 0,
+            status: TaskStatus.PENDING,
+            createdAt: Date.now(),
+        };
+        this.taskQueue.push(task);
+        this.currentTask = task;
+        try {
+            const blueprint = await this.generateBlueprint(directive, mode, context);
+            this.blueprint = blueprint;
+            task.status = TaskStatus.COMPLETED;
+            task.phase = BuildPhase.PLANNING;
+            task.progress = 100;
+            task.completedAt = Date.now();
+            return blueprint;
+        }
+        catch (error) {
+            task.status = TaskStatus.FAILED;
+            task.error = error instanceof Error ? error.message : 'Unknown error';
+            throw error;
+        }
+    }
+    determineMode(directive) {
+        const directiveLower = directive.toLowerCase();
+        const modePatterns = {
+            [ForgeMode.BUILDER]: ['build', 'create', 'implement', 'make', 'develop', 'generate'],
+            [ForgeMode.ANALYST]: ['analyze', 'review', 'audit', 'examine', 'inspect', 'check'],
+            [ForgeMode.OPTIMIZER]: ['optimize', 'improve', 'speed up', 'enhance', 'performance'],
+            [ForgeMode.DEBUGGER]: ['debug', 'fix', 'solve', 'troubleshoot', 'repair'],
+            [ForgeMode.MENTOR]: ['explain', 'how', 'why', 'teach', 'describe', 'what is'],
+            [ForgeMode.ARCHITECT]: ['design', 'architect', 'plan', 'structure', 'layout'],
+            [ForgeMode.REFACTOR]: ['refactor', 'restructure', 'reorganize', 'clean up'],
+            [ForgeMode.SECURITY]: ['secure', 'security', 'vulnerabilities', 'audit security'],
+        };
+        for (const [mode, patterns] of Object.entries(modePatterns)) {
+            if (patterns.some(word => directiveLower.includes(word))) {
+                return mode;
+            }
+        }
+        return ForgeMode.BUILDER;
+    }
+    async generateBlueprint(directive, mode, context) {
+        const requirements = this.extractRequirements(directive);
+        const techStack = this.inferTechStack(directive);
+        const architecture = this.designArchitecture(directive, mode);
+        const fileStructure = this.planFileStructure(directive, techStack);
+        const dependencies = this.identifyDependencies(techStack);
+        const testStrategy = this.planTesting(techStack);
+        return {
+            name: this.generateProjectName(directive),
+            description: `Project generated from: ${directive}`,
+            requirements,
+            architecture,
+            techStack,
+            fileStructure,
+            dependencies,
+            testStrategy,
+            deploymentConfig: this.planDeployment(techStack),
+            qualityMetrics: {
+                targetCoverage: 80,
+                complexityLimit: 10,
+                maintainabilityIndex: 70,
+            },
+            timelineEstimate: this.estimateTimeline(requirements, fileStructure),
+        };
+    }
+    extractRequirements(directive) {
+        const requirements = [];
+        const patterns = [
+            /should\s+(.+?)(?:\.|,|and|$)/gi,
+            /must\s+(.+?)(?:\.|,|and|$)/gi,
+            /need(?:s)?\s+to\s+(.+?)(?:\.|,|and|$)/gi,
+            /feature(?:s)?:?\s*(.+?)(?:\.|$)/gi,
+            /(?:can|able to)\s+(.+?)(?:\.|,|and|$)/gi,
+        ];
+        for (const pattern of patterns) {
+            let match;
+            while ((match = pattern.exec(directive)) !== null) {
+                if (match[1]?.trim()) {
+                    requirements.push(match[1].trim());
+                }
+            }
+        }
+        if (requirements.length === 0) {
+            requirements.push('Build according to best practices');
+            requirements.push(directive);
+        }
+        return [...new Set(requirements)];
+    }
+    inferTechStack(directive) {
+        const directiveLower = directive.toLowerCase();
+        const stack = new Set();
+        for (const [keyword, techs] of Object.entries(TECH_HINTS)) {
+            if (directiveLower.includes(keyword)) {
+                techs.forEach(tech => stack.add(tech));
+            }
+        }
+        if (stack.size === 0) {
+            stack.add('Node.js');
+            stack.add('TypeScript');
+        }
+        return [...stack].sort();
+    }
+    designArchitecture(directive, mode) {
+        const architecture = {
+            type: 'modular',
+            layers: [],
+            patterns: [],
+            principles: ['SOLID', 'DRY', 'KISS'],
+        };
+        const directiveLower = directive.toLowerCase();
+        if (directiveLower.includes('api')) {
+            architecture.layers = ['API', 'Service', 'Repository', 'Database'];
+            architecture.patterns = ['REST', 'Repository', 'Dependency Injection'];
+        }
+        else if (directiveLower.includes('web')) {
+            architecture.layers = ['Presentation', 'Business Logic', 'Data Access'];
+            architecture.patterns = ['MVC', 'Component-Based', 'State Management'];
+        }
+        else if (directiveLower.includes('cli')) {
+            architecture.layers = ['CLI Interface', 'Core Logic', 'Utilities'];
+            architecture.patterns = ['Command Pattern', 'Strategy Pattern'];
+        }
+        else {
+            architecture.layers = ['Presentation', 'Business', 'Data'];
+            architecture.patterns = ['Layered', 'Service-Oriented'];
+        }
+        return architecture;
+    }
+    planFileStructure(directive, techStack) {
+        const structure = {
+            'src/': 'Source code',
+            'tests/': 'Test files',
+            'docs/': 'Documentation',
+            'config/': 'Configuration files',
+        };
+        if (techStack.includes('TypeScript') || techStack.includes('Node.js')) {
+            structure['src/index.ts'] = 'Main entry point';
+            structure['package.json'] = 'Package configuration';
+            structure['tsconfig.json'] = 'TypeScript configuration';
+        }
+        if (techStack.includes('Python')) {
+            structure['src/__init__.py'] = 'Package initialization';
+            structure['requirements.txt'] = 'Python dependencies';
+            structure['setup.py'] = 'Package setup';
+        }
+        if (techStack.includes('React') || techStack.includes('Vue.js')) {
+            structure['src/components/'] = 'UI components';
+            structure['src/pages/'] = 'Page components';
+            structure['src/styles/'] = 'Stylesheets';
+            structure['public/'] = 'Static assets';
+        }
+        if (techStack.includes('FastAPI') || techStack.includes('Express')) {
+            structure['src/api/'] = 'API endpoints';
+            structure['src/models/'] = 'Data models';
+            structure['src/services/'] = 'Business logic';
+        }
+        return structure;
+    }
+    identifyDependencies(techStack) {
+        const dependencies = {};
+        const depMap = {
+            'FastAPI': { fastapi: '^0.104.0', uvicorn: '^0.24.0', pydantic: '^2.5.0' },
+            'React': { react: '^18.2.0', 'react-dom': '^18.2.0' },
+            'Vue.js': { vue: '^3.3.0' },
+            'Express': { express: '^4.18.0' },
+            'TypeScript': { typescript: '^5.3.0', '@types/node': '^20.10.0' },
+            'Commander': { commander: '^12.0.0' },
+        };
+        for (const tech of techStack) {
+            if (tech in depMap) {
+                Object.assign(dependencies, depMap[tech]);
+            }
+        }
+        return dependencies;
+    }
+    planTesting(techStack) {
+        const isPython = techStack.includes('Python');
+        const isJS = techStack.some(t => ['React', 'Node.js', 'Vue.js', 'TypeScript'].includes(t));
+        return {
+            framework: isPython ? 'pytest' : 'jest',
+            coverageTarget: 80,
+            types: ['unit', 'integration'],
+            tools: isPython
+                ? ['pytest', 'pytest-cov', 'pytest-asyncio']
+                : ['jest', '@testing-library/react', 'supertest'],
+        };
+    }
+    planDeployment(techStack) {
+        return {
+            platform: 'cloud',
+            containerized: techStack.includes('Docker'),
+            orchestration: techStack.includes('Kubernetes'),
+            ciCd: true,
+        };
+    }
+    generateProjectName(directive) {
+        const words = directive.toLowerCase().match(/\b[a-z]+\b/g) || [];
+        const meaningful = words.filter(w => w.length > 3 && !['create', 'build', 'make', 'implement', 'that', 'with', 'the'].includes(w));
+        return meaningful.slice(0, 2).join('_') || 'generated_project';
+    }
+    estimateTimeline(requirements, fileStructure) {
+        const base = 10;
+        const requirementsTime = requirements.length * 5;
+        const filesTime = Object.keys(fileStructure).length * 2;
+        return base + requirementsTime + filesTime;
+    }
+    // ========================================================================
+    // FORGE EXECUTION
+    // ========================================================================
+    async forge(blueprint, phases) {
+        const startTime = Date.now();
+        const bp = blueprint || this.blueprint;
+        if (!bp) {
+            throw new Error('No blueprint available for forging');
+        }
+        const result = {
+            success: false,
+            filesCreated: [],
+            filesModified: [],
+            testsWritten: 0,
+            testCoverage: 0,
+            documentationGenerated: false,
+            deploymentReady: false,
+            errors: [],
+            warnings: [],
+            duration: 0,
+            metrics: {},
+        };
+        const phasesToExecute = phases || [
+            BuildPhase.SCAFFOLDING,
+            BuildPhase.IMPLEMENTING,
+            BuildPhase.TESTING,
+            BuildPhase.VALIDATING,
+            BuildPhase.OPTIMIZING,
+            BuildPhase.DOCUMENTING,
+        ];
+        try {
+            for (const phase of phasesToExecute) {
+                switch (phase) {
+                    case BuildPhase.SCAFFOLDING:
+                        await this.createProjectStructure(bp, result);
+                        break;
+                    case BuildPhase.IMPLEMENTING:
+                        await this.implementFeatures(bp, result);
+                        break;
+                    case BuildPhase.TESTING:
+                        await this.generateTests(bp, result);
+                        break;
+                    case BuildPhase.VALIDATING:
+                        await this.validateBuild(bp, result);
+                        break;
+                    case BuildPhase.OPTIMIZING:
+                        await this.optimizeCode(bp, result);
+                        break;
+                    case BuildPhase.DOCUMENTING:
+                        await this.generateDocumentation(bp, result);
+                        break;
+                }
+            }
+            result.success = true;
+            result.deploymentReady = true;
+            this.forgeState.totalBuilds++;
+            this.forgeState.successfulBuilds++;
+            this.forgeState.lastBuild = new Date().toISOString();
+        }
+        catch (error) {
+            result.success = false;
+            result.errors.push(error instanceof Error ? error.message : 'Unknown error');
+            this.forgeState.failedBuilds++;
+        }
+        finally {
+            result.duration = Date.now() - startTime;
+        }
+        return result;
+    }
+    async createProjectStructure(bp, result) {
+        for (const [path, purpose] of Object.entries(bp.fileStructure)) {
+            const fullPath = join(this.workspace, path);
+            if (path.endsWith('/')) {
+                if (!existsSync(fullPath)) {
+                    mkdirSync(fullPath, { recursive: true });
+                }
+                const readmePath = join(fullPath, 'README.md');
+                writeFileSync(readmePath, `# ${path}\n\n${purpose}\n`);
+                result.filesCreated.push(readmePath.replace(this.workspace, ''));
+            }
+            else {
+                const dir = fullPath.substring(0, fullPath.lastIndexOf('/') || fullPath.lastIndexOf('\\'));
+                if (dir && !existsSync(dir)) {
+                    mkdirSync(dir, { recursive: true });
+                }
+                if (!existsSync(fullPath)) {
+                    writeFileSync(fullPath, `// ${purpose}\n`);
+                    result.filesCreated.push(path);
+                }
+            }
+        }
+    }
+    async implementFeatures(bp, result) {
+        // Placeholder - actual implementation would generate code
+    }
+    async generateTests(bp, result) {
+        result.testsWritten = bp.requirements.length;
+        result.testCoverage = 0;
+    }
+    async validateBuild(bp, result) {
+        // Placeholder - would run validations
+    }
+    async optimizeCode(bp, result) {
+        this.forgeState.optimizationsMade++;
+    }
+    async generateDocumentation(bp, result) {
+        const readmePath = join(this.workspace, 'README.md');
+        const content = `# ${bp.name}
+
+${bp.description}
+
+## Requirements
+
+${bp.requirements.map(r => `- ${r}`).join('\n')}
+
+## Architecture
+
+Type: ${bp.architecture.type}
+Layers: ${bp.architecture.layers.join(', ')}
+
+## Tech Stack
+
+${bp.techStack.map(t => `- ${t}`).join('\n')}
+
+## Installation
+
+\`\`\`bash
+npm install
+\`\`\`
+
+## Usage
+
+[Usage instructions]
+
+## Testing
+
+\`\`\`bash
+npm test
+\`\`\`
+
+## License
+
+MIT
+`;
+        writeFileSync(readmePath, content);
+        result.documentationGenerated = true;
+        result.filesCreated.push('README.md');
+    }
+    // ========================================================================
+    // MODE OPERATIONS
+    // ========================================================================
+    switchMode(mode) {
+        const oldMode = this.activeMode;
+        this.activeMode = mode;
+        console.log(`Switched mode: ${oldMode} → ${mode}`);
+    }
+    getActiveMode() {
+        return this.activeMode;
+    }
+    async analyzeCodebase() {
+        this.switchMode(ForgeMode.ANALYST);
+        return {
+            filesAnalyzed: 0,
+            issuesFound: [],
+            suggestions: [],
+        };
+    }
+    async optimizeProject() {
+        this.switchMode(ForgeMode.OPTIMIZER);
+        return {
+            optimizations: [],
+            performanceGain: 0.0,
+        };
+    }
+    async debugIssue(issue) {
+        this.switchMode(ForgeMode.DEBUGGER);
+        this.forgeState.bugsFixed++;
+        return {
+            issue,
+            solution: '',
+            fixed: false,
+        };
+    }
+    async explainConcept(concept) {
+        this.switchMode(ForgeMode.MENTOR);
+        return `Explanation of ${concept} would go here`;
+    }
+    // ========================================================================
+    // UTILITY METHODS
+    // ========================================================================
+    getForgeStats() {
+        return {
+            ...this.forgeState,
+            activeMode: this.activeMode,
+            currentTask: this.currentTask,
+            queuedTasks: this.taskQueue.length,
+            completedTasks: this.completedTasks.length,
+            failedTasks: this.failedTasks.length,
+        };
+    }
+    getCreatedFiles() {
+        const created = [];
+        if (existsSync(this.workspace)) {
+            const walk = (dir) => {
+                const files = readdirSync(dir);
+                for (const file of files) {
+                    const fullPath = join(dir, file);
+                    const stat = statSync(fullPath);
+                    if (stat.isDirectory()) {
+                        walk(fullPath);
+                    }
+                    else {
+                        created.push(fullPath.replace(this.workspace, ''));
+                    }
+                }
+            };
+            walk(this.workspace);
+        }
+        return created;
+    }
+    getBlueprint() {
+        return this.blueprint;
+    }
+    getWorkspace() {
+        return this.workspace;
+    }
+    getProjectName() {
+        return this.projectName;
+    }
+}
+// ============================================================================
+// FORGE ORCHESTRATOR
+// ============================================================================
+export class ForgeOrchestrator {
+    engines;
+    activeProject;
+    constructor() {
+        this.engines = new Map();
+    }
+    createForge(projectName, workspace) {
+        const engine = new ForgeEngine(workspace, projectName);
+        this.engines.set(projectName, engine);
+        this.activeProject = projectName;
+        return engine;
+    }
+    getForge(projectName) {
+        return this.engines.get(projectName);
+    }
+    getActiveForge() {
+        if (this.activeProject) {
+            return this.engines.get(this.activeProject);
+        }
+        return undefined;
+    }
+    listProjects() {
+        return [...this.engines.keys()];
+    }
+    async buildMultiProject(directives, parallel = false) {
+        const results = {};
+        if (parallel) {
+            const tasks = Object.entries(directives).map(async ([projectName, directive]) => {
+                const engine = this.engines.get(projectName);
+                if (engine) {
+                    const blueprint = await engine.processDirective(directive);
+                    const result = await engine.forge(blueprint);
+                    return { projectName, result };
+                }
+                return { projectName, result: null };
+            });
+            const buildResults = await Promise.all(tasks);
+            for (const { projectName, result } of buildResults) {
+                if (result) {
+                    results[projectName] = result;
+                }
+            }
+        }
+        else {
+            for (const [projectName, directive] of Object.entries(directives)) {
+                const engine = this.engines.get(projectName);
+                if (engine) {
+                    const blueprint = await engine.processDirective(directive);
+                    results[projectName] = await engine.forge(blueprint);
+                }
+            }
+        }
+        return results;
+    }
+    getOrchestratorStats() {
+        const projectStats = {};
+        for (const [name, engine] of this.engines) {
+            projectStats[name] = engine.getForgeStats();
+        }
+        return {
+            totalProjects: this.engines.size,
+            activeProject: this.activeProject,
+            projects: projectStats,
+        };
+    }
+}
+// ============================================================================
+// GLOBAL INSTANCES
+// ============================================================================
+let forgeEngineInstance = null;
+let forgeOrchestratorInstance = null;
+export function getForgeEngine(workspace) {
+    if (!forgeEngineInstance) {
+        forgeEngineInstance = new ForgeEngine(workspace);
+    }
+    return forgeEngineInstance;
+}
+export function getForgeOrchestrator() {
+    if (!forgeOrchestratorInstance) {
+        forgeOrchestratorInstance = new ForgeOrchestrator();
+    }
+    return forgeOrchestratorInstance;
+}
+export function resetForgeEngine() {
+    forgeEngineInstance = null;
+}
+// ============================================================================
+// EXPORT
+// ============================================================================
+export default ForgeEngine;
+//# sourceMappingURL=forgeEngine.js.map