@actuallyjamez/elysian 0.5.0 → 0.6.0

package/dist/cli/commands/build.js

@@ -2,9 +2,8 @@
  * Build command - Production build of all lambdas
  */
 import { defineCommand } from "citty";
-import { readdirSync, mkdirSync, existsSync } from "fs";
+import { readdirSync, mkdirSync, existsSync, rmSync } from "fs";
 import { join } from "path";
-import pc from "picocolors";
 import { loadConfig } from "../../core/config";
 import { bundleLambda } from "../../core/bundler";
 import { packageLambda } from "../../core/packager";
@@ -13,19 +12,7 @@ import { writeTerraformVars } from "../../core/terraform";
 import { shouldGenerateOpenApi, writeOpenApiLambda, cleanupOpenApiLambda, } from "../../core/openapi";
 import { createWrapperEntry } from "../../core/handler-wrapper";
 import { getLambdaBundleName } from "../../core/naming";
-import { version } from "../../core/version";
-function formatDuration(ms) {
-    if (ms < 1000)
-        return `${ms}ms`;
-    return `${(ms / 1000).toFixed(2)}s`;
-}
-function formatSize(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)} KB`;
-    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
-}
+import { ui, pc, formatDuration, formatSize } from "../ui";
 export const buildCommand = defineCommand({
     meta: {
         name: "build",
@@ -45,16 +32,14 @@ export const buildCommand = defineCommand({
             process.env.NODE_ENV = "production";
         }
         // Header
-        console.log();
-        console.log(`  ${pc.bold(pc.cyan("elysian"))} ${pc.dim(`v${version}`)} ${args.prod ? pc.yellow("production") : pc.dim("development")}`);
-        console.log();
+        ui.header(args.prod ? pc.yellow("production") : "development");
         // Load config
         let config;
         try {
             config = await loadConfig();
         }
         catch (error) {
-            console.log(`  ${pc.red("✗")} ${error instanceof Error ? error.message : error}`);
+            ui.error(error instanceof Error ? error.message : String(error));
             process.exit(1);
         }
         const name = config.name;
@@ -63,7 +48,7 @@ export const buildCommand = defineCommand({
         const terraformDir = join(process.cwd(), config.terraform.outputDir);
         // Ensure directories exist
         if (!existsSync(lambdasDir)) {
-            console.log(`  ${pc.red("✗")} Lambdas directory not found: ${lambdasDir}`);
+            ui.error(`Lambdas directory not found: ${lambdasDir}`);
             process.exit(1);
         }
         mkdirSync(outputDir, { recursive: true });
@@ -71,7 +56,7 @@ export const buildCommand = defineCommand({
         // Get lambda files
         let lambdaFiles = readdirSync(lambdasDir).filter((f) => f.endsWith(".ts") && !f.startsWith("__"));
         if (lambdaFiles.length === 0) {
-            console.log(`  ${pc.yellow("!")} No lambda files found in ${config.lambdasDir}`);
+            ui.warn(`No lambda files found in ${config.lambdasDir}`);
             return;
         }
         // Generate OpenAPI aggregator if enabled
@@ -80,54 +65,53 @@ export const buildCommand = defineCommand({
             lambdaFiles.push("__openapi__.ts");
         }
         // Build phase
-        console.log(`  ${pc.green("✓")} Compiling ${lambdaFiles.length} lambdas...`);
+        ui.success(`Compiling ${lambdaFiles.length} lambdas...`);
         const tempDir = join(outputDir, "__temp__");
         mkdirSync(tempDir, { recursive: true });
         const buildResults = [];
         for (const file of lambdaFiles) {
-            const name = file.replace(/\.ts$/, "");
-            const bundleName = getLambdaBundleName(name, name);
+            const lambdaName = file.replace(/\.ts$/, "");
+            const bundleName = getLambdaBundleName(name, lambdaName);
             const inputPath = join(lambdasDir, file);
             // Create wrapper entry that imports the original and exports handler
-            const wrapperPath = join(tempDir, `${name}-wrapper.ts`);
+            const wrapperPath = join(tempDir, `${lambdaName}-wrapper.ts`);
             const wrapperContent = createWrapperEntry(inputPath);
             await Bun.write(wrapperPath, wrapperContent);
             // Bundle the wrapper with prefixed name
             const result = await bundleLambda(bundleName, wrapperPath, outputDir, config);
-            buildResults.push({ ...result, name, bundleName });
+            buildResults.push({ ...result, name: lambdaName, bundleName });
             if (!result.success) {
-                console.log(`  ${pc.red("✗")} Failed to build ${name}: ${result.error}`);
+                ui.error(`Failed to build ${lambdaName}: ${result.error}`);
                 process.exit(1);
             }
         }
         // Clean up temp directory
-        const { rmSync } = await import("fs");
         rmSync(tempDir, { recursive: true, force: true });
         // Clean up generated OpenAPI file
         if (shouldGenerateOpenApi(config)) {
             await cleanupOpenApiLambda(lambdasDir);
         }
         // Package phase
-        console.log(`  ${pc.green("✓")} Packaging lambdas...`);
+        ui.success("Packaging lambdas...");
         const packageSizes = new Map();
         for (const file of lambdaFiles) {
-            const name = file.replace(/\.ts$/, "");
-            const bundleName = getLambdaBundleName(name, name);
+            const lambdaName = file.replace(/\.ts$/, "");
+            const bundleName = getLambdaBundleName(name, lambdaName);
             const jsPath = join(outputDir, `${bundleName}.js`);
             const result = await packageLambda(bundleName, jsPath, outputDir);
             if (!result.success) {
-                console.log(`  ${pc.red("✗")} Failed to package ${name}: ${result.error}`);
+                ui.error(`Failed to package ${lambdaName}: ${result.error}`);
                 process.exit(1);
             }
             // Get zip size (store by original name for display)
             const zipPath = join(outputDir, `${bundleName}.zip`);
             const stat = await Bun.file(zipPath).stat();
             if (stat) {
-                packageSizes.set(name, stat.size);
+                packageSizes.set(lambdaName, stat.size);
             }
         }
         // Generate manifest
-        console.log(`  ${pc.green("✓")} Generating manifest...`);
+        ui.success("Generating manifest...");
         try {
             const manifest = await generateManifest(lambdaFiles, outputDir, config.openapi.enabled, name);
             // Write JSON manifest
@@ -137,10 +121,8 @@ export const buildCommand = defineCommand({
             await writeTerraformVars(manifest, config);
             // Duration
             const duration = Date.now() - startTime;
-            // Route table header
-            console.log();
-            console.log(`  ${pc.bold("Routes")}`);
-            console.log();
+            // Route table
+            ui.section("Routes");
             // Group routes by lambda (use original name for display)
             const routesByLambda = new Map();
             for (const route of manifest.routes) {
@@ -152,47 +134,24 @@ export const buildCommand = defineCommand({
                 existing.push(route);
                 routesByLambda.set(displayName, existing);
             }
-            // Method colors
-            const methodColor = (method) => {
-                switch (method) {
-                    case "GET":
-                        return pc.green;
-                    case "POST":
-                        return pc.blue;
-                    case "PUT":
-                        return pc.yellow;
-                    case "DELETE":
-                        return pc.red;
-                    case "PATCH":
-                        return pc.magenta;
-                    default:
-                        return pc.white;
-                }
-            };
             // Find longest path for alignment
             const maxPathLen = Math.max(...manifest.routes.map((r) => r.path.length));
             for (const [displayName, routes] of routesByLambda) {
                 const size = packageSizes.get(displayName);
-                const sizeStr = size ? pc.dim(` (${formatSize(size)})`) : "";
-                console.log(`  ${pc.dim("λ")} ${pc.bold(displayName)}${sizeStr}`);
+                const sizeStr = size ? formatSize(size) : undefined;
+                ui.labeled(displayName, sizeStr);
                 for (const route of routes) {
-                    const method = methodColor(route.method)(route.method.padEnd(6));
-                    const path = route.path.padEnd(maxPathLen + 2);
-                    const params = route.pathParameters.length > 0
-                        ? pc.dim(` [${route.pathParameters.join(", ")}]`)
-                        : "";
-                    console.log(`    ${method} ${path}${params}`);
+                    ui.route(route.method, route.path, route.pathParameters, maxPathLen);
                 }
-                console.log();
+                ui.blank();
             }
             // Summary footer
-            console.log(pc.dim("  " + "─".repeat(40)));
-            console.log();
-            console.log(`  ${pc.green("✓")} Compiled ${pc.bold(String(manifest.lambdas.length))} lambdas (${manifest.routes.length} routes) in ${pc.bold(formatDuration(duration))}`);
-            console.log();
+            ui.divider();
+            ui.success(`Compiled ${pc.bold(String(manifest.lambdas.length))} lambdas (${manifest.routes.length} routes) in ${pc.bold(formatDuration(duration))}`);
+            ui.blank();
         }
         catch (error) {
-            console.log(`  ${pc.red("✗")} ${error instanceof Error ? error.message : String(error)}`);
+            ui.error(error instanceof Error ? error.message : String(error));
             process.exit(1);
         }
     },

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

@@ -1,5 +1,5 @@
 /**
- * Dev command - Watch mode for development
+ * Dev command - Watch mode with LocalStack integration
  */
 export declare const devCommand: import("citty").CommandDef<{
     "no-package": {
@@ -7,4 +7,9 @@ export declare const devCommand: import("citty").CommandDef<{
         description: string;
         default: false;
     };
+    "no-localstack": {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
 }>;

package/dist/cli/commands/dev.js

@@ -1,19 +1,23 @@
 /**
- * Dev command - Watch mode for development
+ * Dev command - Watch mode with LocalStack integration
  */
 import { defineCommand } from "citty";
-import consola from "consola";
-import { watch, readdirSync, mkdirSync, existsSync } from "fs";
+import { watch, readdirSync, mkdirSync, existsSync, rmSync } from "fs";
 import { join } from "path";
 import { loadConfig } from "../../core/config";
 import { bundleLambda } from "../../core/bundler";
 import { packageLambda } from "../../core/packager";
 import { createWrapperEntry } from "../../core/handler-wrapper";
 import { getLambdaBundleName } from "../../core/naming";
+import { generateManifest, writeManifest } from "../../core/manifest";
+import { writeTerraformVars } from "../../core/terraform";
+import { shouldGenerateOpenApi, writeOpenApiLambda, cleanupOpenApiLambda, } from "../../core/openapi";
+import { detectLocalStack, isTerraformInitialized, runTfLocalInit, runTfLocalApply, getTerraformOutputs, } from "../../core/localstack";
+import { ui, pc, createSpinner, formatDuration } from "../ui";
 export const devCommand = defineCommand({
     meta: {
         name: "dev",
-        description: "Watch mode - rebuild lambdas on file changes",
+        description: "Watch mode - rebuild lambdas on file changes with LocalStack deploy",
     },
     args: {
         "no-package": {
@@ -21,91 +25,331 @@ export const devCommand = defineCommand({
             description: "Skip creating zip files (faster rebuilds)",
             default: false,
         },
+        "no-localstack": {
+            type: "boolean",
+            description: "Disable LocalStack integration",
+            default: false,
+        },
     },
     async run({ args }) {
-        consola.start("Loading configuration...");
+        // Initial setup
+        ui.header(pc.dim("dev"));
+        // Load config
         let config;
         try {
             config = await loadConfig();
+            ui.success("Loaded configuration");
         }
         catch (error) {
-            consola.error(error instanceof Error ? error.message : error);
+            ui.error(error instanceof Error ? error.message : String(error));
             process.exit(1);
         }
         const name = config.name;
         const lambdasDir = join(process.cwd(), config.lambdasDir);
         const outputDir = join(process.cwd(), config.outputDir);
+        const terraformDir = join(process.cwd(), config.terraform.outputDir);
         const tempDir = join(outputDir, "__temp__");
         // Ensure directories exist
         if (!existsSync(lambdasDir)) {
-            consola.error(`Lambdas directory not found: ${lambdasDir}`);
+            ui.error(`Lambdas directory not found: ${lambdasDir}`);
             process.exit(1);
         }
         mkdirSync(outputDir, { recursive: true });
         mkdirSync(tempDir, { recursive: true });
+        // Detect LocalStack
+        let localstackEnabled = false;
+        if (!args["no-localstack"]) {
+            const detection = await detectLocalStack();
+            if (detection.available) {
+                localstackEnabled = true;
+                ui.success("LocalStack detected");
+                // Check if terraform is initialized
+                if (!isTerraformInitialized(terraformDir)) {
+                    const spinner = createSpinner("Initializing terraform...").start();
+                    const initResult = await runTfLocalInit(terraformDir);
+                    if (!initResult.success) {
+                        spinner.fail("tflocal init failed");
+                        console.log(pc.dim(initResult.error));
+                        ui.warn("Continuing without LocalStack deploy");
+                        localstackEnabled = false;
+                    }
+                    else {
+                        spinner.succeed("Terraform initialized");
+                    }
+                }
+            }
+            else {
+                if (!detection.localstackRunning) {
+                    ui.warn("LocalStack not running - skipping deploy");
+                }
+                if (!detection.tfLocalInstalled) {
+                    ui.warn("tflocal not installed - skipping deploy");
+                }
+            }
+        }
         // Get initial lambda files
-        const lambdaFiles = readdirSync(lambdasDir).filter((f) => f.endsWith(".ts") && !f.startsWith("__"));
+        let lambdaFiles = readdirSync(lambdasDir).filter((f) => f.endsWith(".ts") && !f.startsWith("__"));
         if (lambdaFiles.length === 0) {
-            consola.warn("No lambda files found in", config.lambdasDir);
+            ui.warn(`No lambda files found in ${config.lambdasDir}`);
         }
+        // Track last terraform outputs and build info for display
+        let lastOutputs = null;
+        let lastBuildInfo = null;
         // Build function for a single lambda
         async function buildSingleLambda(filename) {
-            const name = filename.replace(/\.ts$/, "");
-            const bundleName = getLambdaBundleName(name, name);
+            const lambdaName = filename.replace(/\.ts$/, "");
+            const bundleName = getLambdaBundleName(name, lambdaName);
             const inputPath = join(lambdasDir, filename);
             // Create wrapper entry
-            const wrapperPath = join(tempDir, `${name}-wrapper.ts`);
+            const wrapperPath = join(tempDir, `${lambdaName}-wrapper.ts`);
             const wrapperContent = createWrapperEntry(inputPath);
             await Bun.write(wrapperPath, wrapperContent);
             // Bundle with prefixed name
             const buildResult = await bundleLambda(bundleName, wrapperPath, outputDir, config);
             if (!buildResult.success) {
-                consola.error(`Failed to build ${name}: ${buildResult.error}`);
                 return false;
             }
-            consola.success(`Built ${bundleName}.js`);
             // Package if not disabled
             if (!args["no-package"]) {
                 const jsPath = join(outputDir, `${bundleName}.js`);
                 const packageResult = await packageLambda(bundleName, jsPath, outputDir);
                 if (!packageResult.success) {
-                    consola.error(`Failed to package ${name}: ${packageResult.error}`);
                     return false;
                 }
-                consola.success(`Packaged ${bundleName}.zip`);
             }
             return true;
         }
-        // Initial build of all lambdas
-        consola.start("Initial build...");
-        for (const file of lambdaFiles) {
-            await buildSingleLambda(file);
+        // Build all lambdas (including OpenAPI if enabled)
+        async function buildAll() {
+            // Refresh lambda file list
+            lambdaFiles = readdirSync(lambdasDir).filter((f) => f.endsWith(".ts") && !f.startsWith("__"));
+            const filesToBuild = [...lambdaFiles];
+            // Generate OpenAPI aggregator if enabled
+            if (shouldGenerateOpenApi(config)) {
+                await writeOpenApiLambda(lambdaFiles, lambdasDir, config);
+                filesToBuild.push("__openapi__.ts");
+            }
+            // Build all lambdas
+            for (const file of filesToBuild) {
+                const success = await buildSingleLambda(file);
+                if (!success) {
+                    return { success: false, count: 0 };
+                }
+            }
+            // Cleanup OpenAPI source file
+            if (shouldGenerateOpenApi(config)) {
+                await cleanupOpenApiLambda(lambdasDir);
+            }
+            return { success: true, count: filesToBuild.length };
+        }
+        // Generate manifest and terraform vars
+        async function generateManifestFiles() {
+            try {
+                const filesToManifest = [...lambdaFiles];
+                if (shouldGenerateOpenApi(config)) {
+                    filesToManifest.push("__openapi__.ts");
+                }
+                const manifest = await generateManifest(filesToManifest, outputDir, config.openapi.enabled, name);
+                const manifestPath = join(outputDir, "manifest.json");
+                await writeManifest(manifest, manifestPath);
+                await writeTerraformVars(manifest, config);
+                return { success: true, routes: manifest.routes.length };
+            }
+            catch {
+                return { success: false, routes: 0 };
+            }
         }
-        consola.info("Initial build complete");
-        console.log("");
-        consola.box("Watch mode active\n\n" +
-            `Watching: ${config.lambdasDir}/\n` +
-            `Output:   ${config.outputDir}/\n\n` +
-            "Press Ctrl+C to stop");
-        // Set up file watcher
-        const watcher = watch(lambdasDir, { recursive: false }, async (event, filename) => {
-            if (!filename || !filename.endsWith(".ts") || filename.startsWith("__")) {
+        // Deploy to LocalStack
+        async function deployToLocalStack() {
+            const applyResult = await runTfLocalApply(terraformDir);
+            if (!applyResult.success) {
+                return false;
+            }
+            // Get and store outputs (transformed to LocalStack URLs)
+            lastOutputs = await getTerraformOutputs(terraformDir, true);
+            return true;
+        }
+        // Show the final status screen (Vite-like)
+        function showReadyScreen(trigger, failed) {
+            ui.clear();
+            ui.header(pc.dim("dev"));
+            if (failed) {
+                ui.error("Build failed");
+                if (trigger) {
+                    ui.info(`Triggered by: ${trigger}`);
+                }
+            }
+            else if (lastBuildInfo) {
+                ui.success(`Ready in ${pc.bold(formatDuration(lastBuildInfo.duration))}`);
+                ui.blank();
+                // Show outputs prominently
+                if (lastOutputs && Object.keys(lastOutputs).length > 0) {
+                    for (const [key, value] of Object.entries(lastOutputs)) {
+                        const valueStr = typeof value === "string" ? value : JSON.stringify(value);
+                        console.log(`  ${pc.dim("➜")}  ${pc.bold(key)}: ${pc.cyan(valueStr)}`);
+                    }
+                }
+                ui.blank();
+                console.log(pc.dim(`  ${lastBuildInfo.lambdas} lambda${lastBuildInfo.lambdas === 1 ? "" : "s"} · ${lastBuildInfo.routes} routes`));
+            }
+            // Watch status
+            ui.blank();
+            console.log(pc.dim("  ─────────────────────────────────────"));
+            ui.blank();
+            const watchDirs = [config.lambdasDir];
+            if (localstackEnabled) {
+                watchDirs.push(config.terraform.outputDir);
+            }
+            console.log(`  ${pc.dim("watching:")} ${watchDirs.join(", ")}`);
+            if (localstackEnabled) {
+                console.log(`  ${pc.dim("deploy:")}   ${pc.green("localstack")}`);
+            }
+            ui.blank();
+            console.log(pc.dim("  press ctrl+c to stop"));
+            ui.blank();
+        }
+        // Run the full build and deploy cycle
+        async function runBuildCycle(trigger) {
+            const cycleStart = Date.now();
+            // Show building status
+            ui.clear();
+            ui.header(pc.dim("dev"));
+            if (trigger) {
+                ui.info(`Change: ${trigger}`);
+                ui.blank();
+            }
+            // Build
+            const buildSpinner = createSpinner("Building...").start();
+            const buildResult = await buildAll();
+            if (!buildResult.success) {
+                buildSpinner.fail("Build failed");
+                showReadyScreen(trigger, true);
+                return;
+            }
+            buildSpinner.succeed(`Built ${buildResult.count} lambda${buildResult.count === 1 ? "" : "s"}`);
+            // Generate manifest
+            const manifestSpinner = createSpinner("Generating manifest...").start();
+            const manifestResult = await generateManifestFiles();
+            if (!manifestResult.success) {
+                manifestSpinner.fail("Manifest failed");
+                showReadyScreen(trigger, true);
+                return;
+            }
+            manifestSpinner.succeed("Generated manifest");
+            // Deploy if LocalStack enabled
+            if (localstackEnabled) {
+                const deploySpinner = createSpinner("Deploying...").start();
+                const deploySuccess = await deployToLocalStack();
+                if (!deploySuccess) {
+                    deploySpinner.fail("Deploy failed");
+                    showReadyScreen(trigger, true);
+                    return;
+                }
+                deploySpinner.succeed("Deployed");
+            }
+            // Store build info
+            const duration = Date.now() - cycleStart;
+            lastBuildInfo = {
+                lambdas: buildResult.count,
+                routes: manifestResult.routes,
+                duration,
+            };
+            // Show ready screen
+            showReadyScreen(trigger);
+        }
+        // Run terraform-only deploy
+        async function runTerraformCycle(trigger) {
+            const cycleStart = Date.now();
+            ui.clear();
+            ui.header(pc.dim("dev"));
+            ui.info(`Terraform: ${trigger}`);
+            ui.blank();
+            const deploySpinner = createSpinner("Deploying...").start();
+            const deploySuccess = await deployToLocalStack();
+            if (!deploySuccess) {
+                deploySpinner.fail("Deploy failed");
+                showReadyScreen(trigger, true);
                 return;
             }
-            console.log("");
-            consola.info(`Change detected: ${filename}`);
-            const success = await buildSingleLambda(filename);
-            if (success) {
-                consola.ready("Rebuild complete");
+            deploySpinner.succeed("Deployed");
+            // Update duration
+            if (lastBuildInfo) {
+                lastBuildInfo.duration = Date.now() - cycleStart;
             }
+            showReadyScreen(trigger);
+        }
+        // Debounce timer for file changes
+        let debounceTimer = null;
+        const DEBOUNCE_MS = 150;
+        // Pending changes during debounce
+        let pendingTrigger = null;
+        let pendingIsTerraform = false;
+        // Handle file change with debouncing
+        function handleFileChange(trigger, isTerraform = false) {
+            pendingTrigger = trigger;
+            pendingIsTerraform = isTerraform;
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+            }
+            debounceTimer = setTimeout(async () => {
+                debounceTimer = null;
+                const triggerName = pendingTrigger || trigger;
+                const terraformOnly = pendingIsTerraform;
+                pendingTrigger = null;
+                pendingIsTerraform = false;
+                if (terraformOnly && localstackEnabled) {
+                    await runTerraformCycle(triggerName);
+                }
+                else {
+                    await runBuildCycle(triggerName);
+                }
+            }, DEBOUNCE_MS);
+        }
+        // Initial build
+        await runBuildCycle();
+        // Set up lambda file watcher
+        const lambdaWatcher = watch(lambdasDir, { recursive: false }, (event, filename) => {
+            if (!filename ||
+                !filename.endsWith(".ts") ||
+                filename.startsWith("__")) {
+                return;
+            }
+            handleFileChange(filename, false);
         });
+        // Set up terraform watcher if LocalStack is enabled
+        let terraformWatcher = null;
+        if (localstackEnabled && existsSync(terraformDir)) {
+            terraformWatcher = watch(terraformDir, { recursive: false }, (event, filename) => {
+                if (!filename)
+                    return;
+                // Skip auto-generated files
+                if (filename === config.terraform.tfvarsFilename ||
+                    filename.endsWith(".auto.tfvars") ||
+                    filename.startsWith(".terraform") ||
+                    filename.endsWith(".tfstate") ||
+                    filename.endsWith(".tfstate.backup")) {
+                    return;
+                }
+                // Only watch .tf files
+                if (!filename.endsWith(".tf")) {
+                    return;
+                }
+                handleFileChange(filename, true);
+            });
+        }
         // Handle graceful shutdown
         process.on("SIGINT", () => {
-            console.log("");
-            consola.info("Stopping watcher...");
-            watcher.close();
+            ui.blank();
+            ui.info("Stopping...");
+            lambdaWatcher.close();
+            if (terraformWatcher) {
+                terraformWatcher.close();
+            }
+            // Clear debounce timer
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+            }
             // Clean up temp directory
-            const { rmSync } = require("fs");
             try {
                 rmSync(tempDir, { recursive: true, force: true });
             }