@creact-labs/creact 0.1.0

package/dist/cli/commands/BuildCommand.js

@@ -0,0 +1,151 @@
+"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.BuildCommand = void 0;
+/**
+ * Build Command - builds CloudDOM from entry file
+ */
+const BaseCommand_1 = require("../core/BaseCommand");
+const CLIContext_1 = require("../core/CLIContext");
+const Output_1 = require("../../utils/Output");
+const Logger_1 = require("../../utils/Logger");
+const logger = Logger_1.LoggerFactory.getLogger('cli');
+class BuildCommand extends BaseCommand_1.BaseCommand {
+    getName() {
+        return 'build';
+    }
+    getDescription() {
+        return 'Build CloudDOM from entry file';
+    }
+    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('BuildCommand: Starting execution');
+            let entryPath;
+            try {
+                entryPath = CLIContext_1.CLIContextManager.findEntryFile(this.context.flags.entry);
+                logger.debug(`BuildCommand: 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(`BuildCommand: 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');
+            // Success output
+            const message = `Build complete: ${result.cloudDOM.length} resources`;
+            if (this.verbose && !this.json) {
+                this.printVerboseOutput(result, output);
+            }
+            output.showSuccess(message);
+            if (this.json) {
+                console.log(JSON.stringify({
+                    status: 'success',
+                    resourceCount: result.cloudDOM.length,
+                    entryFile: entryPath,
+                    stackName: result.stackName,
+                    resources: result.cloudDOM.map((node) => ({
+                        id: node.id,
+                        type: node.construct?.name || 'Unknown',
+                        path: node.path,
+                    })),
+                }, null, 2));
+            }
+            return { exitCode: 0 };
+        }
+        catch (error) {
+            output.showError('Build failed', {
+                cause: error.message,
+                stackTrace: this.verbose ? error.stack : undefined,
+            });
+            return { exitCode: 1 };
+        }
+    }
+    printVerboseOutput(result, output) {
+        console.log('\nCloudDOM Summary:');
+        const resourceCounts = this.countResources(result.cloudDOM);
+        if (Object.keys(resourceCounts).length === 0) {
+            console.log('  No resources found');
+        }
+        else {
+            for (const [type, count] of Object.entries(resourceCounts)) {
+                console.log(`  ${type}: ${count}`);
+            }
+        }
+        // Show first few resource IDs for debugging
+        if (result.cloudDOM.length > 0) {
+            console.log('\nResource IDs:');
+            const sampleIds = result.cloudDOM.slice(0, 5).map((node) => node.id);
+            sampleIds.forEach((id) => {
+                console.log(`  • ${id}`);
+            });
+            if (result.cloudDOM.length > 5) {
+                console.log(`  ... and ${result.cloudDOM.length - 5} more`);
+            }
+        }
+    }
+    countResources(cloudDOM) {
+        const counts = {};
+        const walk = (nodes) => {
+            for (const node of nodes) {
+                const type = node.construct?.name || 'Unknown';
+                counts[type] = (counts[type] || 0) + 1;
+                if (node.children && node.children.length > 0) {
+                    walk(node.children);
+                }
+            }
+        };
+        walk(cloudDOM);
+        return counts;
+    }
+}
+exports.BuildCommand = BuildCommand;

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

@@ -0,0 +1,38 @@
+/**
+
+ * 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
+
+ */
+/**
+ * Deploy Command - deploys CloudDOM to cloud provider
+ */
+import { BaseCommand, CommandResult } from '../core/BaseCommand';
+export declare class DeployCommand extends BaseCommand {
+    getName(): string;
+    getDescription(): string;
+    execute(): Promise<CommandResult>;
+}

package/dist/cli/commands/DeployCommand.js

@@ -0,0 +1,194 @@
+"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.DeployCommand = void 0;
+/**
+ * Deploy Command - deploys CloudDOM to cloud provider
+ */
+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 DeployCommand extends BaseCommand_1.BaseCommand {
+    getName() {
+        return 'deploy';
+    }
+    getDescription() {
+        return 'Deploy CloudDOM to cloud provider';
+    }
+    async execute() {
+        const output = (0, Output_1.createOutputManager)({
+            json: this.json,
+            quiet: !!this.context.flags.quiet,
+            verbose: this.verbose,
+        });
+        const dryRun = !!this.context.flags['dry-run'];
+        try {
+            // Find entry file
+            logger.debug('DeployCommand: Starting execution');
+            let entryPath;
+            try {
+                entryPath = CLIContext_1.CLIContextManager.findEntryFile(this.context.flags.entry);
+                logger.debug(`DeployCommand: 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(`DeployCommand: 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');
+            // Validate providers
+            output.showInfo('Validating providers...');
+            if (!result.instance.getCloudProvider()) {
+                output.showError('Cloud provider not configured', {
+                    cause: 'CReact.cloudProvider must be set in entry file',
+                });
+                return { exitCode: 1 };
+            }
+            if (!result.instance.getBackendProvider()) {
+                output.showError('Backend provider not configured', {
+                    cause: 'CReact.backendProvider must be set in entry file',
+                });
+                return { exitCode: 1 };
+            }
+            output.showSuccess('Providers validated');
+            // Load previous state and show plan
+            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(`DeployCommand: Previous CloudDOM loaded with ${previousCloudDOM.length} resources`);
+                }
+                else {
+                    logger.debug('DeployCommand: No previous state found (first deployment)');
+                }
+            }
+            catch (stateError) {
+                logger.debug(`DeployCommand: Could not load previous state: ${stateError.message}`);
+            }
+            // Compute and show plan
+            const reconciler = new Reconciler_1.Reconciler();
+            const changeSet = reconciler.reconcile(previousCloudDOM, result.cloudDOM);
+            output.showPlanHeader(result.stackName);
+            output.showPlanChanges(changeSet);
+            output.showPlanSummary(changeSet);
+            if (dryRun) {
+                logger.debug('DeployCommand: Dry run mode - deployment will be simulated');
+                output.showInfo('Dry run mode - no changes will be applied');
+                return { exitCode: 0 };
+            }
+            // Deploy using CReact instance
+            output.showDeployHeader();
+            const startTime = Date.now();
+            const deployedResources = [];
+            try {
+                // Track deployment progress
+                for (const nodeId of changeSet.deploymentOrder) {
+                    const node = [...changeSet.creates, ...changeSet.updates].find((n) => n.id === nodeId);
+                    if (node) {
+                        const action = changeSet.creates.includes(node) ? 'Creating' : 'Updating';
+                        const resourceStart = Date.now();
+                        output.showResourceProgress(nodeId, action);
+                        // Actual deployment happens in CReact.deploy()
+                        // This is just for progress tracking
+                        deployedResources.push(nodeId);
+                        const resourceDuration = (Date.now() - resourceStart) / 1000;
+                        output.showResourceComplete(nodeId, action.replace('ing', 'ed'), resourceDuration);
+                    }
+                }
+                await result.instance.deploy(result.cloudDOM, result.stackName, 'cli-user');
+                const duration = (Date.now() - startTime) / 1000;
+                const deployResult = {
+                    resourceCount: result.cloudDOM.length,
+                    duration,
+                    creates: changeSet.creates.length,
+                    updates: changeSet.updates.length,
+                    deletes: changeSet.deletes.length,
+                };
+                output.showDeploySummary(deployResult);
+                if (this.json) {
+                    console.log(JSON.stringify({
+                        status: 'success',
+                        ...deployResult,
+                        stackName: result.stackName,
+                        entryFile: entryPath,
+                    }, null, 2));
+                }
+                return { exitCode: 0 };
+            }
+            catch (deployError) {
+                const duration = (Date.now() - startTime) / 1000;
+                const deployResult = {
+                    resourceCount: result.cloudDOM.length,
+                    duration,
+                    creates: changeSet.creates.length,
+                    updates: changeSet.updates.length,
+                    deletes: changeSet.deletes.length,
+                    errors: [{ resourceId: 'unknown', message: deployError.message }],
+                };
+                output.showDeploySummary(deployResult);
+                output.showError('Deployment failed', {
+                    cause: deployError.message,
+                    stackTrace: this.verbose ? deployError.stack : undefined,
+                });
+                return { exitCode: 1 };
+            }
+        }
+        catch (error) {
+            output.showError('Deploy command failed', {
+                cause: error.message,
+                stackTrace: this.verbose ? error.stack : undefined,
+            });
+            return { exitCode: 1 };
+        }
+    }
+}
+exports.DeployCommand = DeployCommand;

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

@@ -0,0 +1,52 @@
+/**
+
+ * 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
+
+ */
+/**
+ * Dev Command - hot reload development mode with auto/manual approval
+ */
+import { BaseCommand, CommandResult } from '../core/BaseCommand';
+export declare class DevCommand extends BaseCommand {
+    private isWatching;
+    private watchTimeout;
+    private autoApprove;
+    private currentReadline;
+    private output;
+    private state;
+    getName(): string;
+    getDescription(): string;
+    execute(): Promise<CommandResult>;
+    private performInitialDeploy;
+    private performHotReload;
+    private deployChanges;
+    private promptForApproval;
+    private startWatching;
+    private shouldIgnoreFile;
+    private keepAlive;
+    private stopWatching;
+}