@creact-labs/creact 0.1.0

package/dist/cli/commands/DevCommand.js

@@ -0,0 +1,385 @@
+"use strict";
+/**
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+
+ * you may not use this file except in compliance with the License.
+
+ * You may obtain a copy of the License at
+
+ *
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ *
+
+ * Unless required by applicable law or agreed to in writing, software
+
+ * distributed under the License is distributed on an "AS IS" BASIS,
+
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+ * See the License for the specific language governing permissions and
+
+ * limitations under the License.
+
+ *
+
+ * Copyright 2025 Daniel Coutinho Ribeiro
+
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevCommand = void 0;
+/**
+ * Dev Command - hot reload development mode with auto/manual approval
+ */
+const BaseCommand_1 = require("../core/BaseCommand");
+const CLIContext_1 = require("../core/CLIContext");
+const Output_1 = require("../../utils/Output");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const readline_1 = require("readline");
+const Reconciler_1 = require("../../core/Reconciler");
+const Logger_1 = require("../../utils/Logger");
+const chalk_1 = __importDefault(require("chalk"));
+const logger = Logger_1.LoggerFactory.getLogger('cli');
+class DevCommand extends BaseCommand_1.BaseCommand {
+    constructor() {
+        super(...arguments);
+        this.isWatching = false;
+        this.watchTimeout = null;
+        this.autoApprove = false;
+        this.currentReadline = null;
+        this.state = {
+            lastCloudDOM: null,
+            lastStackName: null,
+            instance: null,
+        };
+    }
+    getName() {
+        return 'dev';
+    }
+    getDescription() {
+        return 'Hot reload development mode with auto/manual approval';
+    }
+    async execute() {
+        this.output = (0, Output_1.createOutputManager)({
+            json: this.json,
+            quiet: !!this.context.flags.quiet,
+            verbose: this.verbose,
+        });
+        try {
+            // Check for auto-approve flag
+            this.autoApprove = !!this.context.flags['auto-approve'] || !!this.context.flags.auto;
+            // Find entry file
+            logger.debug('DevCommand: Starting execution');
+            let entryPath;
+            try {
+                entryPath = CLIContext_1.CLIContextManager.findEntryFile(this.context.flags.entry);
+                logger.debug(`DevCommand: Entry file resolved to ${entryPath}`);
+            }
+            catch (error) {
+                this.output.showError('Entry file resolution failed', {
+                    cause: error.message,
+                    stackTrace: this.verbose ? error.stack : undefined,
+                });
+                return { exitCode: 1 };
+            }
+            // Show mode information
+            this.output.showInfo('Starting CReact development mode...');
+            const mode = this.autoApprove ? chalk_1.default.yellow('Auto-approve') : chalk_1.default.blue('Manual approval');
+            this.output.showInfo(`Mode: ${mode}`);
+            if (!this.autoApprove) {
+                this.output.showInfo('Tip: Use --auto-approve to automatically deploy changes');
+            }
+            // Start file watching BEFORE initial deploy
+            this.startWatching(entryPath);
+            // Initial build and deploy
+            await this.performInitialDeploy(entryPath);
+            // Keep process alive
+            this.output.showInfo('Watching for changes... (Press Ctrl+C to stop)');
+            // Handle graceful shutdown
+            process.on('SIGINT', () => {
+                this.output.showInfo('\nStopping development mode...');
+                this.stopWatching();
+                process.exit(0);
+            });
+            // Keep the process alive indefinitely
+            await this.keepAlive();
+            return { exitCode: 0 };
+        }
+        catch (error) {
+            this.output.showError('Dev mode failed to start', {
+                cause: error.message,
+                stackTrace: this.verbose ? error.stack : undefined,
+            });
+            return { exitCode: 1 };
+        }
+    }
+    async performInitialDeploy(entryPath) {
+        try {
+            this.output.showInfo('Building initial state...');
+            const result = await CLIContext_1.CLIContextManager.createCLIInstance(entryPath, this.verbose);
+            logger.debug(`DevCommand: Initial CloudDOM built with ${result.cloudDOM.length} resources`);
+            // Load backend state for comparison
+            let previousCloudDOM = [];
+            try {
+                const backendState = await result.instance.getBackendProvider().getState(result.stackName);
+                previousCloudDOM = backendState?.cloudDOM || [];
+                logger.debug(`DevCommand: Previous CloudDOM loaded with ${previousCloudDOM.length} resources`);
+            }
+            catch (error) {
+                logger.debug(`DevCommand: Could not load previous state: ${error.message}`);
+            }
+            // Compute diff using Reconciler
+            const reconciler = new Reconciler_1.Reconciler();
+            const changeSet = reconciler.reconcile(previousCloudDOM, result.cloudDOM);
+            const totalChanges = (0, Reconciler_1.getTotalChanges)(changeSet);
+            logger.debug(`DevCommand: Total changes: ${totalChanges}`);
+            // Store state for future comparisons
+            this.state.lastCloudDOM = result.cloudDOM;
+            this.state.lastStackName = result.stackName;
+            this.state.instance = result.instance;
+            // Check if there are any changes
+            if (totalChanges === 0) {
+                this.output.showSuccess('No changes detected - infrastructure is up to date');
+                return;
+            }
+            this.output.showSuccess(`Changes detected: ${totalChanges} changes`);
+            // Show plan
+            this.output.showPlanHeader(result.stackName);
+            this.output.showPlanChanges(changeSet);
+            this.output.showPlanSummary(changeSet);
+            if (this.autoApprove) {
+                this.output.showWarning('Auto-approving changes...');
+                await this.deployChanges(result, changeSet);
+            }
+            else {
+                const shouldDeploy = await this.promptForApproval();
+                if (shouldDeploy) {
+                    await this.deployChanges(result, changeSet);
+                }
+                else {
+                    this.output.showInfo('Deployment skipped');
+                }
+            }
+        }
+        catch (error) {
+            this.output.showError('Initial deployment failed', {
+                cause: error.message,
+                stackTrace: this.verbose ? error.stack : undefined,
+            });
+        }
+    }
+    async performHotReload(entryPath) {
+        try {
+            this.output.showHotReloadStart();
+            if (!this.state.lastCloudDOM || !this.state.instance) {
+                this.output.showError('No previous state found');
+                return;
+            }
+            // Create new instance
+            const result = await CLIContext_1.CLIContextManager.createCLIInstance(entryPath, this.verbose);
+            logger.debug(`DevCommand: Hot reload CloudDOM built with ${result.cloudDOM.length} resources`);
+            // Compute diff using Reconciler
+            const reconciler = new Reconciler_1.Reconciler();
+            const changeSet = reconciler.reconcile(this.state.lastCloudDOM, result.cloudDOM);
+            const totalChanges = (0, Reconciler_1.getTotalChanges)(changeSet);
+            logger.debug(`DevCommand: Hot reload total changes: ${totalChanges}`);
+            // Always update state to preserve reactive changes
+            this.state.lastCloudDOM = result.cloudDOM;
+            this.state.instance = result.instance;
+            // Check if there are any changes
+            if (totalChanges === 0) {
+                this.output.showSuccess('No changes detected');
+                return;
+            }
+            this.output.showSuccess(`Changes detected: ${totalChanges} changes`);
+            // Show plan
+            this.output.showPlanHeader(result.stackName);
+            this.output.showPlanChanges(changeSet);
+            this.output.showPlanSummary(changeSet);
+            if (this.autoApprove) {
+                this.output.showWarning('Auto-approving changes...');
+                await this.deployChanges(result, changeSet);
+            }
+            else {
+                const shouldDeploy = await this.promptForApproval();
+                if (shouldDeploy) {
+                    await this.deployChanges(result, changeSet);
+                }
+                else {
+                    this.output.showInfo('Changes skipped');
+                }
+            }
+        }
+        catch (error) {
+            this.output.showError('Hot reload failed', {
+                cause: error.message,
+                stackTrace: this.verbose ? error.stack : undefined,
+            });
+        }
+    }
+    async deployChanges(result, changeSet) {
+        try {
+            // Reactive deployment loop - continue until no more changes
+            let deploymentCycle = 1;
+            let hasMoreChanges = true;
+            let currentCloudDOM = result.cloudDOM;
+            while (hasMoreChanges) {
+                if (deploymentCycle > 1) {
+                    this.output.showInfo(`\nReactive deployment cycle #${deploymentCycle}`);
+                }
+                this.output.showDeployHeader();
+                const startTime = Date.now();
+                // Deploy
+                await result.instance.deploy(currentCloudDOM, result.stackName, 'dev-user');
+                const duration = (Date.now() - startTime) / 1000;
+                // Update state
+                this.state.lastCloudDOM = currentCloudDOM;
+                const deployResult = {
+                    resourceCount: currentCloudDOM.length,
+                    duration,
+                    creates: changeSet.creates.length,
+                    updates: changeSet.updates.length,
+                    deletes: changeSet.deletes.length,
+                };
+                this.output.showDeploySummary(deployResult);
+                // Check if reactive changes were detected
+                const reactiveInfo = await result.instance.getReactiveDeploymentInfo(result.stackName);
+                if (reactiveInfo && (0, Reconciler_1.getTotalChanges)(reactiveInfo.changeSet) > 0) {
+                    this.output.showReactiveChangesDetected();
+                    this.output.showPlanChanges(reactiveInfo.changeSet);
+                    this.output.showPlanSummary(reactiveInfo.changeSet);
+                    let shouldContinue = this.autoApprove;
+                    if (!this.autoApprove) {
+                        shouldContinue = await this.promptForApproval();
+                    }
+                    else {
+                        this.output.showWarning('Auto-approving reactive changes...');
+                    }
+                    if (shouldContinue) {
+                        currentCloudDOM = reactiveInfo.cloudDOM;
+                        changeSet = reactiveInfo.changeSet;
+                        deploymentCycle++;
+                    }
+                    else {
+                        this.output.showInfo('Reactive changes skipped');
+                        hasMoreChanges = false;
+                    }
+                }
+                else {
+                    hasMoreChanges = false;
+                }
+            }
+        }
+        catch (error) {
+            this.output.showError('Deployment failed', {
+                cause: error.message,
+                stackTrace: this.verbose ? error.stack : undefined,
+            });
+        }
+    }
+    async promptForApproval() {
+        // Close any existing readline interface
+        if (this.currentReadline) {
+            this.currentReadline.close();
+            this.currentReadline = null;
+        }
+        const rl = (0, readline_1.createInterface)({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        this.currentReadline = rl;
+        return new Promise((resolve) => {
+            rl.question(chalk_1.default.bold('Deploy these changes? (y/N/a=auto-approve): '), (answer) => {
+                this.currentReadline = null;
+                rl.close();
+                const response = answer.toLowerCase().trim();
+                if (response === 'a' || response === 'auto') {
+                    this.output.showWarning('Switching to auto-approve mode');
+                    this.autoApprove = true;
+                    resolve(true);
+                }
+                else if (response === 'y' || response === 'yes') {
+                    resolve(true);
+                }
+                else {
+                    resolve(false);
+                }
+            });
+        });
+    }
+    startWatching(entryPath) {
+        if (this.isWatching)
+            return;
+        this.isWatching = true;
+        const absoluteEntryPath = (0, path_1.resolve)(process.cwd(), entryPath);
+        const entryDir = (0, path_1.dirname)(absoluteEntryPath);
+        logger.debug(`DevCommand: Watching directory: ${entryDir}`);
+        try {
+            (0, fs_1.watch)(entryDir, { recursive: true }, (eventType, filename) => {
+                if (!filename)
+                    return;
+                // Skip certain file types
+                if (this.shouldIgnoreFile(filename)) {
+                    return;
+                }
+                logger.debug(`DevCommand: File event: ${eventType} - ${filename}`);
+                // Debounce file changes
+                if (this.watchTimeout) {
+                    clearTimeout(this.watchTimeout);
+                }
+                this.watchTimeout = setTimeout(() => {
+                    // Skip hot reload if we don't have initial state yet
+                    if (!this.state.lastCloudDOM) {
+                        logger.debug('DevCommand: Skipping hot reload - waiting for initial deployment');
+                        return;
+                    }
+                    // Cancel any pending prompts
+                    if (this.currentReadline) {
+                        this.output.showInfo('\nNew changes detected, canceling previous prompt...');
+                        this.currentReadline.close();
+                        this.currentReadline = null;
+                    }
+                    this.output.showFileChanged(filename);
+                    this.performHotReload(entryPath);
+                }, 300);
+            });
+            logger.debug('DevCommand: File watcher started successfully');
+        }
+        catch (error) {
+            logger.warn(`DevCommand: Could not watch ${entryDir}: ${error.message}`);
+        }
+    }
+    shouldIgnoreFile(filename) {
+        // Only watch TypeScript and JavaScript files
+        const allowedExtensions = ['.ts', '.tsx', '.js', '.jsx'];
+        const hasAllowedExtension = allowedExtensions.some((ext) => filename.endsWith(ext));
+        if (!hasAllowedExtension) {
+            return true;
+        }
+        // Ignore certain patterns
+        const ignoredPatterns = ['node_modules', '.git', 'dist', '.next', '.cache', 'test', 'spec'];
+        if (ignoredPatterns.some((pattern) => filename.includes(pattern))) {
+            return true;
+        }
+        return false;
+    }
+    async keepAlive() {
+        return new Promise(() => {
+            // This promise never resolves, keeping the process alive
+        });
+    }
+    stopWatching() {
+        this.isWatching = false;
+        if (this.watchTimeout) {
+            clearTimeout(this.watchTimeout);
+            this.watchTimeout = null;
+        }
+    }
+}
+exports.DevCommand = DevCommand;

package/dist/cli/commands/PlanCommand.d.ts

@@ -0,0 +1,39 @@
+/**
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+
+ * you may not use this file except in compliance with the License.
+
+ * You may obtain a copy of the License at
+
+ *
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ *
+
+ * Unless required by applicable law or agreed to in writing, software
+
+ * distributed under the License is distributed on an "AS IS" BASIS,
+
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+ * See the License for the specific language governing permissions and
+
+ * limitations under the License.
+
+ *
+
+ * Copyright 2025 Daniel Coutinho Ribeiro
+
+ */
+/**
+ * Plan Command - shows diff between current and previous CloudDOM
+ */
+import { BaseCommand, CommandResult } from '../core/BaseCommand';
+export declare class PlanCommand extends BaseCommand {
+    getName(): string;
+    getDescription(): string;
+    execute(): Promise<CommandResult>;
+    private printVerboseOutput;
+}

package/dist/cli/commands/PlanCommand.js

@@ -0,0 +1,164 @@
+"use strict";
+/**
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+
+ * you may not use this file except in compliance with the License.
+
+ * You may obtain a copy of the License at
+
+ *
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ *
+
+ * Unless required by applicable law or agreed to in writing, software
+
+ * distributed under the License is distributed on an "AS IS" BASIS,
+
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+ * See the License for the specific language governing permissions and
+
+ * limitations under the License.
+
+ *
+
+ * Copyright 2025 Daniel Coutinho Ribeiro
+
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanCommand = void 0;
+/**
+ * Plan Command - shows diff between current and previous CloudDOM
+ */
+const BaseCommand_1 = require("../core/BaseCommand");
+const CLIContext_1 = require("../core/CLIContext");
+const Output_1 = require("../../utils/Output");
+const Reconciler_1 = require("../../core/Reconciler");
+const Logger_1 = require("../../utils/Logger");
+const logger = Logger_1.LoggerFactory.getLogger('cli');
+class PlanCommand extends BaseCommand_1.BaseCommand {
+    getName() {
+        return 'plan';
+    }
+    getDescription() {
+        return 'Show diff between current and previous CloudDOM';
+    }
+    async execute() {
+        const output = (0, Output_1.createOutputManager)({
+            json: this.json,
+            quiet: !!this.context.flags.quiet,
+            verbose: this.verbose,
+        });
+        try {
+            // Find entry file
+            logger.debug('PlanCommand: Starting execution');
+            let entryPath;
+            try {
+                entryPath = CLIContext_1.CLIContextManager.findEntryFile(this.context.flags.entry);
+                logger.debug(`PlanCommand: Entry file resolved to ${entryPath}`);
+            }
+            catch (error) {
+                output.showError('Entry file resolution failed', {
+                    cause: error.message,
+                    stackTrace: this.verbose ? error.stack : undefined,
+                });
+                return { exitCode: 1 };
+            }
+            // Load entry file and create CLI instance
+            output.showInfo('Loading entry file and configuring providers...');
+            let result;
+            try {
+                result = await CLIContext_1.CLIContextManager.createCLIInstance(entryPath, this.verbose);
+                logger.debug(`PlanCommand: Current CloudDOM built with ${result.cloudDOM.length} resources`);
+            }
+            catch (error) {
+                output.showError('Failed to load entry file and configure providers', {
+                    cause: error.message,
+                    stackTrace: this.verbose ? error.stack : undefined,
+                });
+                return { exitCode: 1 };
+            }
+            output.showSuccess('Entry file loaded and providers configured');
+            // Load previous CloudDOM from backend
+            output.showInfo('Loading previous state...');
+            let previousCloudDOM = [];
+            try {
+                const previousState = await result.instance.getBackendProvider().getState(result.stackName);
+                if (previousState && previousState.cloudDOM) {
+                    previousCloudDOM = previousState.cloudDOM;
+                    logger.debug(`PlanCommand: Previous CloudDOM loaded with ${previousCloudDOM.length} resources`);
+                }
+                else {
+                    logger.debug('PlanCommand: No previous state found (first deployment)');
+                }
+            }
+            catch (stateError) {
+                logger.debug(`PlanCommand: Could not load previous state: ${stateError.message}`);
+                // Continue with empty previous state
+            }
+            output.showSuccess('Previous state loaded');
+            // Compute diff using Reconciler
+            output.showInfo('Computing changes...');
+            const reconciler = new Reconciler_1.Reconciler();
+            const changeSet = reconciler.reconcile(previousCloudDOM, result.cloudDOM);
+            logger.debug(`PlanCommand: Changes computed: ${changeSet.creates.length} creates, ${changeSet.updates.length} updates, ${changeSet.deletes.length} deletes, ${changeSet.replacements.length} replacements`);
+            output.showSuccess('Changes computed');
+            // Check if there are any changes
+            const hasChanges = changeSet.creates.length > 0 ||
+                changeSet.updates.length > 0 ||
+                changeSet.deletes.length > 0 ||
+                changeSet.replacements.length > 0 ||
+                changeSet.moves.length > 0;
+            // Display plan
+            output.showPlanHeader(result.stackName);
+            output.showPlanChanges(changeSet);
+            output.showPlanSummary(changeSet);
+            if (this.verbose && !this.json) {
+                this.printVerboseOutput(changeSet);
+            }
+            if (!hasChanges) {
+                return { exitCode: 0 };
+            }
+            // Output results
+            const totalChanges = changeSet.creates.length +
+                changeSet.updates.length +
+                changeSet.deletes.length +
+                changeSet.replacements.length +
+                changeSet.moves.length;
+            if (this.json) {
+                const diffVisualization = reconciler.generateDiffVisualization(changeSet);
+                console.log(JSON.stringify({
+                    status: 'success',
+                    message: `Plan complete: ${totalChanges} changes`,
+                    summary: diffVisualization.summary,
+                    changes: diffVisualization.changes,
+                    deployment: diffVisualization.deployment,
+                }, null, 2));
+            }
+            return { exitCode: 0 };
+        }
+        catch (error) {
+            output.showError('Plan failed', {
+                cause: error.message,
+                stackTrace: this.verbose ? error.stack : undefined,
+            });
+            return { exitCode: 1 };
+        }
+    }
+    printVerboseOutput(changeSet) {
+        console.log('\nDeployment Order:');
+        changeSet.deploymentOrder.forEach((nodeId, index) => {
+            console.log(`  ${String(index + 1).padStart(2)}. ${nodeId}`);
+        });
+        if (changeSet.parallelBatches.length > 1) {
+            console.log('\nParallel Batches:');
+            changeSet.parallelBatches.forEach((batch, index) => {
+                console.log(`  Batch ${index + 1}: ${batch.join(', ')}`);
+            });
+        }
+    }
+}
+exports.PlanCommand = PlanCommand;

package/dist/cli/commands/index.d.ts

@@ -0,0 +1,36 @@
+/**
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+
+ * you may not use this file except in compliance with the License.
+
+ * You may obtain a copy of the License at
+
+ *
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ *
+
+ * Unless required by applicable law or agreed to in writing, software
+
+ * distributed under the License is distributed on an "AS IS" BASIS,
+
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+ * See the License for the specific language governing permissions and
+
+ * limitations under the License.
+
+ *
+
+ * Copyright 2025 Daniel Coutinho Ribeiro
+
+ */
+/**
+ * Command exports - centralized command registration
+ */
+export { BuildCommand } from './BuildCommand';
+export { PlanCommand } from './PlanCommand';
+export { DeployCommand } from './DeployCommand';
+export { DevCommand } from './DevCommand';

package/dist/cli/commands/index.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+
+ * you may not use this file except in compliance with the License.
+
+ * You may obtain a copy of the License at
+
+ *
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ *
+
+ * Unless required by applicable law or agreed to in writing, software
+
+ * distributed under the License is distributed on an "AS IS" BASIS,
+
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+ * See the License for the specific language governing permissions and
+
+ * limitations under the License.
+
+ *
+
+ * Copyright 2025 Daniel Coutinho Ribeiro
+
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevCommand = exports.DeployCommand = exports.PlanCommand = exports.BuildCommand = void 0;
+/**
+ * Command exports - centralized command registration
+ */
+var BuildCommand_1 = require("./BuildCommand");
+Object.defineProperty(exports, "BuildCommand", { enumerable: true, get: function () { return BuildCommand_1.BuildCommand; } });
+var PlanCommand_1 = require("./PlanCommand");
+Object.defineProperty(exports, "PlanCommand", { enumerable: true, get: function () { return PlanCommand_1.PlanCommand; } });
+var DeployCommand_1 = require("./DeployCommand");
+Object.defineProperty(exports, "DeployCommand", { enumerable: true, get: function () { return DeployCommand_1.DeployCommand; } });
+var DevCommand_1 = require("./DevCommand");
+Object.defineProperty(exports, "DevCommand", { enumerable: true, get: function () { return DevCommand_1.DevCommand; } });