@codebakers/cli 3.7.2 → 3.8.1

package/dist/lib/engineering-state.js

@@ -0,0 +1,605 @@
+"use strict";
+/**
+ * ENGINEERING STATE PERSISTENCE
+ *
+ * Manages the .codebakers/ folder structure for local state persistence.
+ * This keeps the project state in sync between local and server.
+ *
+ * Folder structure:
+ * .codebakers/
+ *   project.json       - Main project configuration and scope
+ *   state.json         - Current build state (phase, progress, etc.)
+ *   graph.json         - Dependency graph
+ *   decisions/         - Agent decision log
+ *     001-scoping.json
+ *     002-architecture.json
+ *   artifacts/         - Generated documents
+ *     prd.md
+ *     tech-spec.md
+ *     api-docs.md
+ *   messages/          - Agent communication log
+ *     session-xxx.json
+ *   snapshots/         - Rollback points
+ *     snap-001/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EngineeringStateManager = void 0;
+exports.getStateManager = getStateManager;
+exports.hasEngineeringProject = hasEngineeringProject;
+exports.getProjectSummary = getProjectSummary;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const crypto_1 = require("crypto");
+// =============================================================================
+// STATE MANAGER
+// =============================================================================
+class EngineeringStateManager {
+    cwd;
+    stateDir;
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+        this.stateDir = (0, path_1.join)(cwd, '.codebakers');
+    }
+    // ========================================
+    // INITIALIZATION
+    // ========================================
+    /**
+     * Initialize the .codebakers folder structure
+     */
+    init() {
+        // Create main directory
+        if (!(0, fs_1.existsSync)(this.stateDir)) {
+            (0, fs_1.mkdirSync)(this.stateDir, { recursive: true });
+        }
+        // Create subdirectories
+        const subdirs = ['decisions', 'artifacts', 'messages', 'snapshots'];
+        for (const subdir of subdirs) {
+            const path = (0, path_1.join)(this.stateDir, subdir);
+            if (!(0, fs_1.existsSync)(path)) {
+                (0, fs_1.mkdirSync)(path, { recursive: true });
+            }
+        }
+    }
+    /**
+     * Check if project is initialized
+     */
+    isInitialized() {
+        return (0, fs_1.existsSync)((0, path_1.join)(this.stateDir, 'project.json'));
+    }
+    /**
+     * Get project hash from current directory
+     */
+    getProjectHash() {
+        // Try to get git remote first
+        try {
+            const gitDir = (0, path_1.join)(this.cwd, '.git');
+            if ((0, fs_1.existsSync)(gitDir)) {
+                const configPath = (0, path_1.join)(gitDir, 'config');
+                if ((0, fs_1.existsSync)(configPath)) {
+                    const config = (0, fs_1.readFileSync)(configPath, 'utf-8');
+                    const remoteMatch = config.match(/url = (.+)/);
+                    if (remoteMatch) {
+                        return (0, crypto_1.createHash)('sha256').update(remoteMatch[1]).digest('hex').slice(0, 16);
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore git errors
+        }
+        // Fall back to directory path hash
+        return (0, crypto_1.createHash)('sha256').update(this.cwd).digest('hex').slice(0, 16);
+    }
+    // ========================================
+    // PROJECT CONFIG
+    // ========================================
+    /**
+     * Create a new project configuration
+     */
+    createProject(name, description, scope = {}) {
+        this.init();
+        const defaultScope = {
+            targetAudience: 'consumers',
+            isFullBusiness: false,
+            needsMarketing: false,
+            needsAnalytics: false,
+            needsTeamFeatures: false,
+            needsAdminDashboard: false,
+            platforms: ['web'],
+            hasRealtime: false,
+            hasPayments: false,
+            hasAuth: true,
+            hasFileUploads: false,
+            compliance: {
+                hipaa: false,
+                pci: false,
+                gdpr: false,
+                soc2: false,
+                coppa: false,
+            },
+            expectedUsers: 'small',
+            launchTimeline: 'flexible',
+        };
+        const project = {
+            id: (0, crypto_1.createHash)('sha256').update(Date.now().toString() + Math.random()).digest('hex').slice(0, 16),
+            name,
+            description,
+            projectHash: this.getProjectHash(),
+            scope: { ...defaultScope, ...scope },
+            stack: this.detectStack(),
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        this.saveProject(project);
+        this.initializeState();
+        return project;
+    }
+    /**
+     * Get project configuration
+     */
+    getProject() {
+        const path = (0, path_1.join)(this.stateDir, 'project.json');
+        if (!(0, fs_1.existsSync)(path))
+            return null;
+        try {
+            return JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Save project configuration
+     */
+    saveProject(project) {
+        project.updatedAt = new Date().toISOString();
+        (0, fs_1.writeFileSync)((0, path_1.join)(this.stateDir, 'project.json'), JSON.stringify(project, null, 2));
+    }
+    /**
+     * Update project scope
+     */
+    updateScope(scope) {
+        const project = this.getProject();
+        if (!project)
+            return null;
+        project.scope = { ...project.scope, ...scope };
+        this.saveProject(project);
+        return project;
+    }
+    // ========================================
+    // BUILD STATE
+    // ========================================
+    /**
+     * Initialize build state
+     */
+    initializeState() {
+        const initialGates = {
+            scoping: { status: 'pending' },
+            requirements: { status: 'pending' },
+            architecture: { status: 'pending' },
+            design_review: { status: 'pending' },
+            implementation: { status: 'pending' },
+            code_review: { status: 'pending' },
+            testing: { status: 'pending' },
+            security_review: { status: 'pending' },
+            documentation: { status: 'pending' },
+            staging: { status: 'pending' },
+            launch: { status: 'pending' },
+        };
+        const state = {
+            sessionId: null,
+            currentPhase: 'scoping',
+            currentAgent: 'orchestrator',
+            isRunning: false,
+            gates: initialGates,
+            overallProgress: 0,
+            lastActivity: new Date().toISOString(),
+            pendingApprovals: [],
+            blockers: [],
+        };
+        this.saveState(state);
+    }
+    /**
+     * Get build state
+     */
+    getState() {
+        const path = (0, path_1.join)(this.stateDir, 'state.json');
+        if (!(0, fs_1.existsSync)(path))
+            return null;
+        try {
+            return JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Save build state
+     */
+    saveState(state) {
+        state.lastActivity = new Date().toISOString();
+        (0, fs_1.writeFileSync)((0, path_1.join)(this.stateDir, 'state.json'), JSON.stringify(state, null, 2));
+    }
+    /**
+     * Update current phase
+     */
+    setPhase(phase, agent) {
+        const state = this.getState();
+        if (!state)
+            return;
+        state.currentPhase = phase;
+        state.currentAgent = agent;
+        state.gates[phase] = { status: 'in_progress' };
+        this.saveState(state);
+    }
+    /**
+     * Pass a gate
+     */
+    passGate(phase, artifacts = [], approvedBy = 'auto') {
+        const state = this.getState();
+        if (!state)
+            return;
+        state.gates[phase] = {
+            status: 'passed',
+            passedAt: new Date().toISOString(),
+            approvedBy,
+            artifacts,
+        };
+        // Calculate progress
+        const phases = Object.keys(state.gates);
+        const passed = phases.filter(p => state.gates[p].status === 'passed').length;
+        state.overallProgress = Math.round((passed / phases.length) * 100);
+        this.saveState(state);
+    }
+    /**
+     * Fail a gate
+     */
+    failGate(phase, reason) {
+        const state = this.getState();
+        if (!state)
+            return;
+        state.gates[phase] = {
+            status: 'failed',
+            failedReason: reason,
+        };
+        this.saveState(state);
+    }
+    // ========================================
+    // DEPENDENCY GRAPH
+    // ========================================
+    /**
+     * Get dependency graph
+     */
+    getGraph() {
+        const path = (0, path_1.join)(this.stateDir, 'graph.json');
+        if (!(0, fs_1.existsSync)(path)) {
+            return { nodes: [], edges: [] };
+        }
+        try {
+            return JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+        }
+        catch {
+            return { nodes: [], edges: [] };
+        }
+    }
+    /**
+     * Save dependency graph
+     */
+    saveGraph(graph) {
+        (0, fs_1.writeFileSync)((0, path_1.join)(this.stateDir, 'graph.json'), JSON.stringify(graph, null, 2));
+    }
+    /**
+     * Add a node to the graph
+     */
+    addNode(node) {
+        const graph = this.getGraph();
+        const newNode = {
+            id: (0, crypto_1.createHash)('sha256').update(node.filePath + Date.now()).digest('hex').slice(0, 12),
+            ...node,
+            createdAt: new Date().toISOString(),
+            modifiedAt: new Date().toISOString(),
+        };
+        // Check if node with same path already exists
+        const existingIndex = graph.nodes.findIndex(n => n.filePath === node.filePath);
+        if (existingIndex >= 0) {
+            graph.nodes[existingIndex] = {
+                ...graph.nodes[existingIndex],
+                ...newNode,
+                id: graph.nodes[existingIndex].id, // Keep original ID
+                createdAt: graph.nodes[existingIndex].createdAt,
+            };
+        }
+        else {
+            graph.nodes.push(newNode);
+        }
+        this.saveGraph(graph);
+        return newNode;
+    }
+    /**
+     * Add an edge to the graph
+     */
+    addEdge(edge) {
+        const graph = this.getGraph();
+        // Check if edge already exists
+        const exists = graph.edges.some(e => e.sourceId === edge.sourceId && e.targetId === edge.targetId && e.type === edge.type);
+        if (exists) {
+            return graph.edges.find(e => e.sourceId === edge.sourceId && e.targetId === edge.targetId && e.type === edge.type);
+        }
+        const newEdge = {
+            id: (0, crypto_1.createHash)('sha256').update(edge.sourceId + edge.targetId + Date.now()).digest('hex').slice(0, 12),
+            ...edge,
+        };
+        graph.edges.push(newEdge);
+        this.saveGraph(graph);
+        return newEdge;
+    }
+    /**
+     * Find nodes affected by a change
+     */
+    findAffectedNodes(nodeId) {
+        const graph = this.getGraph();
+        // Find direct dependents (nodes that import this one)
+        const directEdges = graph.edges.filter(e => e.targetId === nodeId);
+        const direct = directEdges
+            .map(e => graph.nodes.find(n => n.id === e.sourceId))
+            .filter((n) => n !== undefined);
+        // Find transitive dependents (BFS)
+        const visited = new Set([nodeId]);
+        const queue = [...direct.map(n => n.id)];
+        const transitive = [];
+        while (queue.length > 0) {
+            const currentId = queue.shift();
+            if (visited.has(currentId))
+                continue;
+            visited.add(currentId);
+            const current = graph.nodes.find(n => n.id === currentId);
+            if (current && !direct.includes(current)) {
+                transitive.push(current);
+            }
+            // Add nodes that depend on current
+            const dependentEdges = graph.edges.filter(e => e.targetId === currentId);
+            for (const edge of dependentEdges) {
+                if (!visited.has(edge.sourceId)) {
+                    queue.push(edge.sourceId);
+                }
+            }
+        }
+        return { direct, transitive };
+    }
+    // ========================================
+    // DECISIONS
+    // ========================================
+    /**
+     * Record a decision
+     */
+    recordDecision(decision) {
+        const decisionsDir = (0, path_1.join)(this.stateDir, 'decisions');
+        const files = (0, fs_1.existsSync)(decisionsDir) ? (0, fs_1.readdirSync)(decisionsDir) : [];
+        const index = String(files.length + 1).padStart(3, '0');
+        const fullDecision = {
+            id: (0, crypto_1.createHash)('sha256').update(Date.now().toString() + Math.random()).digest('hex').slice(0, 12),
+            timestamp: new Date().toISOString(),
+            ...decision,
+        };
+        const filename = `${index}-${decision.phase}.json`;
+        (0, fs_1.writeFileSync)((0, path_1.join)(decisionsDir, filename), JSON.stringify(fullDecision, null, 2));
+        return fullDecision;
+    }
+    /**
+     * Get all decisions
+     */
+    getDecisions() {
+        const decisionsDir = (0, path_1.join)(this.stateDir, 'decisions');
+        if (!(0, fs_1.existsSync)(decisionsDir))
+            return [];
+        const files = (0, fs_1.readdirSync)(decisionsDir).filter(f => f.endsWith('.json'));
+        return files.map(f => {
+            try {
+                return JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(decisionsDir, f), 'utf-8'));
+            }
+            catch {
+                return null;
+            }
+        }).filter((d) => d !== null);
+    }
+    // ========================================
+    // ARTIFACTS
+    // ========================================
+    /**
+     * Save an artifact (PRD, tech spec, etc.)
+     */
+    saveArtifact(name, content) {
+        (0, fs_1.writeFileSync)((0, path_1.join)(this.stateDir, 'artifacts', name), content);
+    }
+    /**
+     * Get an artifact
+     */
+    getArtifact(name) {
+        const path = (0, path_1.join)(this.stateDir, 'artifacts', name);
+        if (!(0, fs_1.existsSync)(path))
+            return null;
+        try {
+            return (0, fs_1.readFileSync)(path, 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * List all artifacts
+     */
+    listArtifacts() {
+        const artifactsDir = (0, path_1.join)(this.stateDir, 'artifacts');
+        if (!(0, fs_1.existsSync)(artifactsDir))
+            return [];
+        return (0, fs_1.readdirSync)(artifactsDir);
+    }
+    // ========================================
+    // MESSAGES
+    // ========================================
+    /**
+     * Record a message
+     */
+    recordMessage(message) {
+        const state = this.getState();
+        const sessionId = state?.sessionId || 'default';
+        const messagesPath = (0, path_1.join)(this.stateDir, 'messages', `${sessionId}.json`);
+        let messages = [];
+        if ((0, fs_1.existsSync)(messagesPath)) {
+            try {
+                messages = JSON.parse((0, fs_1.readFileSync)(messagesPath, 'utf-8'));
+            }
+            catch {
+                messages = [];
+            }
+        }
+        const fullMessage = {
+            id: (0, crypto_1.createHash)('sha256').update(Date.now().toString() + Math.random()).digest('hex').slice(0, 12),
+            timestamp: new Date().toISOString(),
+            ...message,
+        };
+        messages.push(fullMessage);
+        (0, fs_1.writeFileSync)(messagesPath, JSON.stringify(messages, null, 2));
+        return fullMessage;
+    }
+    /**
+     * Get messages for current session
+     */
+    getMessages() {
+        const state = this.getState();
+        const sessionId = state?.sessionId || 'default';
+        const messagesPath = (0, path_1.join)(this.stateDir, 'messages', `${sessionId}.json`);
+        if (!(0, fs_1.existsSync)(messagesPath))
+            return [];
+        try {
+            return JSON.parse((0, fs_1.readFileSync)(messagesPath, 'utf-8'));
+        }
+        catch {
+            return [];
+        }
+    }
+    // ========================================
+    // STACK DETECTION
+    // ========================================
+    /**
+     * Detect the tech stack from package.json
+     */
+    detectStack() {
+        const stack = {
+            framework: 'nextjs',
+            database: 'supabase',
+            orm: 'drizzle',
+            auth: 'supabase',
+            ui: 'shadcn',
+        };
+        const packageJsonPath = (0, path_1.join)(this.cwd, 'package.json');
+        if (!(0, fs_1.existsSync)(packageJsonPath))
+            return stack;
+        try {
+            const pkg = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, 'utf-8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            // Framework detection
+            if (deps['next'])
+                stack.framework = 'nextjs';
+            else if (deps['@remix-run/react'])
+                stack.framework = 'remix';
+            else if (deps['react'])
+                stack.framework = 'react';
+            else if (deps['vue'])
+                stack.framework = 'vue';
+            else if (deps['svelte'])
+                stack.framework = 'svelte';
+            // ORM detection
+            if (deps['drizzle-orm'])
+                stack.orm = 'drizzle';
+            else if (deps['prisma'])
+                stack.orm = 'prisma';
+            else if (deps['typeorm'])
+                stack.orm = 'typeorm';
+            else if (deps['mongoose'])
+                stack.orm = 'mongoose';
+            // Database detection
+            if (deps['@supabase/supabase-js'])
+                stack.database = 'supabase';
+            else if (deps['@planetscale/database'])
+                stack.database = 'planetscale';
+            else if (deps['firebase'])
+                stack.database = 'firebase';
+            else if (deps['pg'])
+                stack.database = 'postgres';
+            else if (deps['mysql2'])
+                stack.database = 'mysql';
+            else if (deps['mongodb'])
+                stack.database = 'mongodb';
+            // Auth detection
+            if (deps['@supabase/auth-helpers-nextjs'] || deps['@supabase/supabase-js'])
+                stack.auth = 'supabase';
+            else if (deps['@clerk/nextjs'])
+                stack.auth = 'clerk';
+            else if (deps['next-auth'])
+                stack.auth = 'next-auth';
+            else if (deps['@auth/core'])
+                stack.auth = 'authjs';
+            else if (deps['firebase'])
+                stack.auth = 'firebase';
+            // UI detection
+            if (deps['@radix-ui/react-slot'] || (0, fs_1.existsSync)((0, path_1.join)(this.cwd, 'components', 'ui')))
+                stack.ui = 'shadcn';
+            else if (deps['@chakra-ui/react'])
+                stack.ui = 'chakra';
+            else if (deps['@mui/material'])
+                stack.ui = 'mui';
+            else if (deps['antd'])
+                stack.ui = 'antd';
+            // Payments detection
+            if (deps['stripe'])
+                stack.payments = 'stripe';
+            else if (deps['@paypal/react-paypal-js'])
+                stack.payments = 'paypal';
+            else if (deps['square'])
+                stack.payments = 'square';
+        }
+        catch {
+            // Return default stack on error
+        }
+        return stack;
+    }
+    // ========================================
+    // SUMMARY
+    // ========================================
+    /**
+     * Get a summary of current engineering state
+     */
+    getSummary() {
+        const graph = this.getGraph();
+        return {
+            project: this.getProject(),
+            state: this.getState(),
+            graphStats: { nodes: graph.nodes.length, edges: graph.edges.length },
+            decisions: this.getDecisions().length,
+            artifacts: this.listArtifacts(),
+        };
+    }
+}
+exports.EngineeringStateManager = EngineeringStateManager;
+// =============================================================================
+// CONVENIENCE FUNCTIONS
+// =============================================================================
+/**
+ * Get the state manager for current directory
+ */
+function getStateManager(cwd) {
+    return new EngineeringStateManager(cwd);
+}
+/**
+ * Check if engineering project exists in current directory
+ */
+function hasEngineeringProject(cwd) {
+    return getStateManager(cwd).isInitialized();
+}
+/**
+ * Quick summary of current project state
+ */
+function getProjectSummary(cwd) {
+    return getStateManager(cwd).getSummary();
+}