@actuallyjamez/elysian 0.5.1 → 0.7.0

package/dist/cli/commands/generate-iac.js

@@ -2,13 +2,13 @@
  * Generate IAC command - Regenerate Terraform files without rebuilding
  */
 import { defineCommand } from "citty";
-import consola from "consola";
 import { readdirSync, existsSync, mkdirSync } from "fs";
 import { join } from "path";
 import { loadConfig } from "../../core/config";
 import { generateManifest, writeManifest } from "../../core/manifest";
 import { writeTerraformVars } from "../../core/terraform";
 import { getOriginalLambdaName } from "../../core/naming";
+import { ui, pc, formatDuration } from "../ui";
 export const generateIacCommand = defineCommand({
     meta: {
         name: "generate-iac",
@@ -16,13 +16,15 @@ export const generateIacCommand = defineCommand({
     },
     args: {},
     async run() {
-        consola.start("Loading configuration...");
+        const startTime = Date.now();
+        ui.header();
+        // Load config
         let config;
         try {
             config = await loadConfig();
         }
         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;
@@ -30,7 +32,8 @@ export const generateIacCommand = defineCommand({
         const terraformDir = join(process.cwd(), config.terraform.outputDir);
         // Check that build output exists
         if (!existsSync(outputDir)) {
-            consola.error(`Build output directory not found: ${outputDir}\nRun 'elysian build' first.`);
+            ui.error(`Build output directory not found: ${outputDir}`);
+            ui.info("Run 'elysian build' first");
             process.exit(1);
         }
         // Ensure terraform directory exists
@@ -38,7 +41,8 @@ export const generateIacCommand = defineCommand({
         // Get built lambda files (they have the apiName prefix)
         const jsFiles = readdirSync(outputDir).filter((f) => f.endsWith(".js") && !f.startsWith("__temp__"));
         if (jsFiles.length === 0) {
-            consola.error(`No built lambda files found in ${outputDir}\nRun 'elysian build' first.`);
+            ui.error(`No built lambda files found in ${outputDir}`);
+            ui.info("Run 'elysian build' first");
             process.exit(1);
         }
         // Convert bundle names back to .ts names for manifest generation
@@ -48,35 +52,49 @@ export const generateIacCommand = defineCommand({
             const originalName = getOriginalLambdaName(name, bundleName);
             return `${originalName}.ts`;
         });
-        consola.info(`Found ${lambdaFiles.length} built lambda(s)`);
+        ui.success(`Found ${lambdaFiles.length} built lambda${lambdaFiles.length === 1 ? "" : "s"}`);
         // Generate manifest
-        consola.start("Generating route manifest...");
+        ui.info("Generating route manifest...");
         try {
             const manifest = await generateManifest(lambdaFiles, outputDir, config.openapi.enabled, name);
             // Write JSON manifest
             const manifestPath = join(outputDir, "manifest.json");
             await writeManifest(manifest, manifestPath);
-            consola.success("Generated manifest.json");
+            ui.success("Generated manifest.json");
             // Write Terraform variables
-            const tfvarsPath = await writeTerraformVars(manifest, config);
-            consola.success(`Generated ${config.terraform.tfvarsFilename}`);
-            // Print summary
-            console.log("");
-            consola.box(`Infrastructure files generated\n\n` +
-                `Lambdas: ${manifest.lambdas.length}\n` +
-                `Routes:  ${manifest.routes.length}\n\n` +
-                `Output: ${config.terraform.outputDir}/${config.terraform.tfvarsFilename}`);
-            // Print route summary
-            console.log("\nRoute Summary:");
+            await writeTerraformVars(manifest, config);
+            ui.success(`Generated ${config.terraform.tfvarsFilename}`);
+            // Route table
+            ui.section("Routes");
+            // Group routes by lambda
+            const routesByLambda = new Map();
             for (const route of manifest.routes) {
-                const params = route.pathParameters.length > 0
-                    ? ` [${route.pathParameters.join(", ")}]`
-                    : "";
-                console.log(`  ${route.method.padEnd(6)} ${route.path.padEnd(30)} → ${route.lambda}${params}`);
+                const displayName = route.lambda.startsWith(`${name}-`)
+                    ? route.lambda.slice(name.length + 1)
+                    : route.lambda;
+                const existing = routesByLambda.get(displayName) || [];
+                existing.push(route);
+                routesByLambda.set(displayName, existing);
             }
+            // Find longest path for alignment
+            const maxPathLen = Math.max(...manifest.routes.map((r) => r.path.length));
+            for (const [displayName, routes] of routesByLambda) {
+                ui.labeled(displayName);
+                for (const route of routes) {
+                    ui.route(route.method, route.path, route.pathParameters, maxPathLen);
+                }
+                ui.blank();
+            }
+            // Summary
+            ui.divider();
+            const duration = Date.now() - startTime;
+            ui.success(`Generated infrastructure for ${pc.bold(String(manifest.lambdas.length))} lambdas (${manifest.routes.length} routes) in ${pc.bold(formatDuration(duration))}`);
+            ui.blank();
+            ui.keyValue("Output", `${config.terraform.outputDir}/${config.terraform.tfvarsFilename}`);
+            ui.blank();
         }
         catch (error) {
-            consola.error(error instanceof Error ? error.message : error);
+            ui.error(error instanceof Error ? error.message : String(error));
             process.exit(1);
         }
     },

package/dist/cli/commands/init/scaffold.js

@@ -4,9 +4,9 @@
 import { existsSync, mkdirSync } from "fs";
 import { join } from "path";
 import { spawn } from "bun";
-import consola from "consola";
 import { configTemplate, exampleLambdaTemplate, packageJsonTemplate, gitignoreTemplate, tsconfigTemplate, } from "./templates";
 import { templates as tfTemplates, appendProviders, getMissingVariables, appendMain, appendOutputs, } from "./terraform";
+import { ui } from "../../ui";
 /**
  * Read file content or return empty string if not exists
  */
@@ -150,7 +150,7 @@ export async function installDependencies(cwd, packageManager) {
     const devDeps = ["@types/bun", "typescript"];
     const addCmd = packageManager === "npm" ? "install" : "add";
     const devFlag = packageManager === "npm" ? "--save-dev" : "-D";
-    consola.start("Installing dependencies...");
+    ui.info("Installing dependencies...");
     // Install main dependencies
     const addProc = spawn([packageManager, addCmd, ...deps], {
         cwd,
@@ -173,7 +173,7 @@ export async function installDependencies(cwd, packageManager) {
         const stderr = await new Response(devProc.stderr).text();
         throw new Error(`Failed to install dev dependencies: ${stderr}`);
     }
-    consola.success("Dependencies installed");
+    ui.success("Dependencies installed");
 }
 /**
  * Get relative path for display
@@ -185,12 +185,12 @@ export function getRelativePath(cwd, fullPath) {
  * Print scaffold results
  */
 export function printResults(cwd, result) {
-    console.log("");
+    ui.blank();
     for (const path of result.created) {
-        consola.success(`Created ${getRelativePath(cwd, path)}`);
+        ui.success(`Created ${getRelativePath(cwd, path)}`);
     }
     for (const path of result.updated) {
-        consola.success(`Updated ${getRelativePath(cwd, path)}`);
+        ui.success(`Updated ${getRelativePath(cwd, path)}`);
     }
     // Don't print skipped files - too noisy
 }

package/dist/cli/commands/init/templates.js

@@ -19,8 +19,8 @@ export function exampleLambdaTemplate() {
     return `import { createLambda, t } from "@actuallyjamez/elysian";
 
 export default createLambda()
-	.get("/hello", ({ query }) => {
-		return \`Hello, \${query.name ?? "World"}!\`;
+	.get("/", ({ query }) => {
+		return \`Hello, \${query.name ?? "Elysian"}!\`;
 	}, {
 		response: t.String(),
 		query: t.Object({

package/dist/cli/commands/init.js

@@ -2,13 +2,12 @@
  * Init command - Interactive wizard to initialize elysian projects
  */
 import { defineCommand } from "citty";
-import consola from "consola";
-import pc from "picocolors";
 import { existsSync, mkdirSync } from "fs";
 import { resolve, basename } from "path";
 import { detectProject, } from "./init/detect";
 import { promptTargetDirectory, runFreshProjectWizard, runExistingProjectWizard, } from "./init/prompts";
 import { scaffoldProject, installDependencies, printResults, } from "./init/scaffold";
+import { ui } from "../ui";
 export const initCommand = defineCommand({
     meta: {
         name: "init",
@@ -22,11 +21,12 @@ export const initCommand = defineCommand({
         },
     },
     async run({ args }) {
+        ui.header();
         const originalCwd = process.cwd();
         // Step 1: Get target directory
         const targetDir = await promptTargetDirectory(basename(originalCwd));
         if (!targetDir) {
-            consola.info("Cancelled");
+            ui.info("Cancelled");
             process.exit(0);
         }
         // Resolve the target directory
@@ -35,13 +35,13 @@ export const initCommand = defineCommand({
         // Create directory if it doesn't exist
         if (!existsSync(cwd)) {
             mkdirSync(cwd, { recursive: true });
-            consola.success(`Created directory: ${targetDir}`);
+            ui.success(`Created directory: ${targetDir}`);
         }
         // Detect project state in target directory
         const info = await detectProject(cwd);
         // Check for existing config (unless force)
         if (info.hasElysianConfig && !args.force) {
-            consola.error("elysian.config.ts already exists. Use --force to overwrite.");
+            ui.error("elysian.config.ts already exists. Use --force to overwrite.");
             process.exit(1);
         }
         // Run appropriate wizard based on whether directory is empty
@@ -49,7 +49,7 @@ export const initCommand = defineCommand({
         if (info.isEmpty) {
             const result = await runFreshProjectWizard(name);
             if (!result) {
-                consola.info("Cancelled");
+                ui.info("Cancelled");
                 process.exit(0);
             }
             answers = {
@@ -60,7 +60,7 @@ export const initCommand = defineCommand({
         else {
             const result = await runExistingProjectWizard(name, info.packageManager);
             if (!result) {
-                consola.info("Cancelled");
+                ui.info("Cancelled");
                 process.exit(0);
             }
             answers = {
@@ -78,29 +78,29 @@ export const initCommand = defineCommand({
                 await installDependencies(cwd, answers.packageManager);
             }
             catch (error) {
-                consola.error(error instanceof Error ? error.message : "Failed to install dependencies");
-                consola.info(`You can manually install with: ${answers.packageManager} add elysia @actuallyjamez/elysian`);
+                ui.error(error instanceof Error ? error.message : "Failed to install dependencies");
+                ui.info(`You can manually install with: ${answers.packageManager} add elysia @actuallyjamez/elysian`);
             }
         }
         // Print next steps
-        console.log("");
+        ui.blank();
         const pm = answers.packageManager;
         const runCmd = pm === "npm" ? "npm run" : pm;
+        ui.success("Project initialized!");
+        ui.blank();
+        ui.section("Next steps");
         // If we created in a subdirectory, tell user to cd into it
-        const cdStep = targetDir !== "." ? `cd ${targetDir}\n` : "";
-        console.log(`  ${pc.green("✓")} Project initialized!`);
-        console.log();
-        console.log(`  ${pc.bold("Next steps")}:`);
-        console.log();
-        if (cdStep) {
-            console.log(`    ${cdStep}`);
+        if (targetDir !== ".") {
+            console.log(`    cd ${targetDir}`);
+            ui.blank();
         }
         if (!answers.installDeps) {
             console.log(`    ${pm} add elysia @actuallyjamez/elysian`);
-            console.log();
+            ui.blank();
         }
         console.log(`    ${runCmd} elysian build`);
-        console.log();
+        ui.blank();
         console.log(`    cd terraform && terraform init && terraform apply`);
+        ui.blank();
     },
 });

package/dist/cli/ui.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Shared CLI UI utilities for consistent styling across commands
+ */
+import pc from "picocolors";
+/**
+ * Format duration in human-readable format
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * Format bytes in human-readable format
+ */
+export declare function formatSize(bytes: number): string;
+/**
+ * Get color function for HTTP method
+ */
+export declare function methodColor(method: string): (text: string) => string;
+/**
+ * Spinner class for showing progress on long-running operations
+ */
+export declare class Spinner {
+    private message;
+    private frameIndex;
+    private interval;
+    private startTime;
+    constructor(message: string);
+    start(): this;
+    stop(): number;
+    succeed(message?: string): number;
+    fail(message?: string): number;
+    update(message: string): void;
+}
+/**
+ * Create a new spinner
+ */
+export declare function createSpinner(message: string): Spinner;
+/**
+ * UI output functions with consistent styling
+ */
+export declare const ui: {
+    /**
+     * Clear the terminal screen
+     */
+    clear: () => void;
+    /**
+     * Print header with version and optional mode
+     */
+    header: (mode?: string) => void;
+    /**
+     * Success message with green checkmark
+     */
+    success: (msg: string) => void;
+    /**
+     * Error message with red X
+     */
+    error: (msg: string) => void;
+    /**
+     * Warning message with yellow exclamation
+     */
+    warn: (msg: string) => void;
+    /**
+     * Info message with dim arrow
+     */
+    info: (msg: string) => void;
+    /**
+     * Print a section header
+     */
+    section: (title: string) => void;
+    /**
+     * Print a horizontal divider
+     */
+    divider: () => void;
+    /**
+     * Print a blank line
+     */
+    blank: () => void;
+    /**
+     * Print indented text
+     */
+    indent: (msg: string, level?: number) => void;
+    /**
+     * Print a key-value pair
+     */
+    keyValue: (key: string, value: string, indent?: number) => void;
+    /**
+     * Print a labeled item (like lambda name with size)
+     */
+    labeled: (label: string, suffix?: string) => void;
+    /**
+     * Print a route line with method coloring
+     */
+    route: (method: string, path: string, params?: string[], maxPathLen?: number) => void;
+    /**
+     * Print watch mode status box
+     */
+    watchBox: (options: {
+        watching: string[];
+        output: string;
+        localstack?: boolean;
+    }) => void;
+    /**
+     * Print terraform outputs
+     */
+    outputs: (outputs: Record<string, unknown>) => void;
+    /**
+     * Print build/deploy summary with timing
+     */
+    summary: (options: {
+        lambdas: number;
+        routes?: number;
+        duration: number;
+        action?: string;
+    }) => void;
+};
+export { pc };

package/dist/cli/ui.js

@@ -0,0 +1,233 @@
+/**
+ * Shared CLI UI utilities for consistent styling across commands
+ */
+import pc from "picocolors";
+import { version } from "../core/version";
+/**
+ * Format duration in human-readable format
+ */
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    return `${(ms / 1000).toFixed(2)}s`;
+}
+/**
+ * Format bytes in human-readable format
+ */
+export 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`;
+}
+/**
+ * Get color function for HTTP method
+ */
+export function methodColor(method) {
+    switch (method.toUpperCase()) {
+        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;
+    }
+}
+/**
+ * Spinner frames for loading animation
+ */
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/**
+ * Spinner class for showing progress on long-running operations
+ */
+export class Spinner {
+    message;
+    frameIndex = 0;
+    interval = null;
+    startTime = 0;
+    constructor(message) {
+        this.message = message;
+    }
+    start() {
+        this.startTime = Date.now();
+        this.frameIndex = 0;
+        // Write initial frame
+        process.stdout.write(`  ${pc.cyan(SPINNER_FRAMES[0])} ${this.message}`);
+        this.interval = setInterval(() => {
+            this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
+            // Move cursor to start of line and rewrite
+            process.stdout.write(`\r  ${pc.cyan(SPINNER_FRAMES[this.frameIndex])} ${this.message}`);
+        }, 80);
+        return this;
+    }
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        // Clear the spinner line
+        process.stdout.write("\r" + " ".repeat(this.message.length + 10) + "\r");
+        return Date.now() - this.startTime;
+    }
+    succeed(message) {
+        const duration = this.stop();
+        console.log(`  ${pc.green("✓")} ${message || this.message}`);
+        return duration;
+    }
+    fail(message) {
+        const duration = this.stop();
+        console.log(`  ${pc.red("✗")} ${message || this.message}`);
+        return duration;
+    }
+    update(message) {
+        this.message = message;
+    }
+}
+/**
+ * Create a new spinner
+ */
+export function createSpinner(message) {
+    return new Spinner(message);
+}
+/**
+ * UI output functions with consistent styling
+ */
+export const ui = {
+    /**
+     * Clear the terminal screen
+     */
+    clear: () => {
+        process.stdout.write("\x1B[2J\x1B[0f");
+    },
+    /**
+     * Print header with version and optional mode
+     */
+    header: (mode) => {
+        console.log();
+        console.log(`  ${pc.bold(pc.cyan("elysian"))} ${pc.dim(`v${version}`)}${mode ? ` ${mode}` : ""}`);
+        console.log();
+    },
+    /**
+     * Success message with green checkmark
+     */
+    success: (msg) => {
+        console.log(`  ${pc.green("✓")} ${msg}`);
+    },
+    /**
+     * Error message with red X
+     */
+    error: (msg) => {
+        console.log(`  ${pc.red("✗")} ${msg}`);
+    },
+    /**
+     * Warning message with yellow exclamation
+     */
+    warn: (msg) => {
+        console.log(`  ${pc.yellow("!")} ${msg}`);
+    },
+    /**
+     * Info message with dim arrow
+     */
+    info: (msg) => {
+        console.log(`  ${pc.dim("›")} ${msg}`);
+    },
+    /**
+     * Print a section header
+     */
+    section: (title) => {
+        console.log();
+        console.log(`  ${pc.bold(title)}`);
+        console.log();
+    },
+    /**
+     * Print a horizontal divider
+     */
+    divider: () => {
+        console.log();
+        console.log(pc.dim("  " + "─".repeat(40)));
+        console.log();
+    },
+    /**
+     * Print a blank line
+     */
+    blank: () => {
+        console.log();
+    },
+    /**
+     * Print indented text
+     */
+    indent: (msg, level = 1) => {
+        console.log("  ".repeat(level) + msg);
+    },
+    /**
+     * Print a key-value pair
+     */
+    keyValue: (key, value, indent = 1) => {
+        console.log("  ".repeat(indent) + `${pc.dim(key + ":")} ${value}`);
+    },
+    /**
+     * Print a labeled item (like lambda name with size)
+     */
+    labeled: (label, suffix) => {
+        const suffixStr = suffix ? pc.dim(` (${suffix})`) : "";
+        console.log(`  ${pc.dim("λ")} ${pc.bold(label)}${suffixStr}`);
+    },
+    /**
+     * Print a route line with method coloring
+     */
+    route: (method, path, params, maxPathLen) => {
+        const colorFn = methodColor(method);
+        const methodStr = colorFn(method.padEnd(6));
+        const pathStr = maxPathLen ? path.padEnd(maxPathLen + 2) : path;
+        const paramsStr = params && params.length > 0 ? pc.dim(` [${params.join(", ")}]`) : "";
+        console.log(`    ${methodStr} ${pathStr}${paramsStr}`);
+    },
+    /**
+     * Print watch mode status box
+     */
+    watchBox: (options) => {
+        console.log();
+        console.log(pc.dim("  " + "─".repeat(40)));
+        console.log();
+        for (const dir of options.watching) {
+            console.log(`  ${pc.dim("Watching")}  ${dir}`);
+        }
+        console.log(`  ${pc.dim("Output")}    ${options.output}`);
+        if (options.localstack) {
+            console.log(`  ${pc.dim("Deploy")}    ${pc.green("LocalStack")} ${pc.dim("(tflocal)")}`);
+        }
+        console.log();
+        console.log(`  ${pc.dim("Press Ctrl+C to stop")}`);
+        console.log();
+    },
+    /**
+     * Print terraform outputs
+     */
+    outputs: (outputs) => {
+        if (Object.keys(outputs).length === 0)
+            return;
+        console.log();
+        console.log(`  ${pc.bold("Outputs")}`);
+        console.log();
+        for (const [key, value] of Object.entries(outputs)) {
+            const valueStr = typeof value === "string" ? value : JSON.stringify(value);
+            console.log(`  ${pc.dim(key + ":")} ${pc.cyan(valueStr)}`);
+        }
+    },
+    /**
+     * Print build/deploy summary with timing
+     */
+    summary: (options) => {
+        const action = options.action || "Built";
+        const routeStr = options.routes !== undefined ? ` (${options.routes} routes)` : "";
+        console.log(`  ${pc.green("✓")} ${action} ${pc.bold(String(options.lambdas))} lambda${options.lambdas === 1 ? "" : "s"}${routeStr} in ${pc.bold(formatDuration(options.duration))}`);
+    },
+};
+export { pc };

package/dist/core/localstack.d.ts

@@ -0,0 +1,59 @@
+/**
+ * LocalStack detection and tflocal execution utilities
+ */
+export interface TerraformOutput {
+    [key: string]: {
+        value: unknown;
+        type?: string;
+        sensitive?: boolean;
+    };
+}
+export interface TfResult {
+    success: boolean;
+    error?: string;
+}
+/**
+ * Check if LocalStack is running by hitting the health endpoint
+ */
+export declare function isLocalStackRunning(endpoint?: string): Promise<boolean>;
+/**
+ * Check if tflocal CLI is installed
+ */
+export declare function isTfLocalInstalled(): Promise<boolean>;
+/**
+ * Check if terraform has been initialized in the given directory
+ */
+export declare function isTerraformInitialized(terraformDir: string): boolean;
+/**
+ * Run tflocal init
+ */
+export declare function runTfLocalInit(terraformDir: string): Promise<TfResult>;
+/**
+ * Run tflocal apply with auto-approve
+ */
+export declare function runTfLocalApply(terraformDir: string): Promise<TfResult>;
+/**
+ * Transform AWS URLs to LocalStack URLs
+ * Converts URLs like:
+ *   https://abc123.execute-api.eu-west-2.amazonaws.com/
+ * To:
+ *   http://abc123.execute-api.localhost.localstack.cloud:4566/
+ */
+export declare function transformToLocalStackUrl(value: unknown): unknown;
+/**
+ * Transform all URLs in terraform outputs to LocalStack format
+ */
+export declare function transformOutputsForLocalStack(outputs: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Get terraform outputs as JSON
+ */
+export declare function getTerraformOutputs(terraformDir: string, transformForLocalStack?: boolean): Promise<Record<string, unknown> | null>;
+/**
+ * Detect LocalStack availability
+ * Returns an object with detection results and reasons
+ */
+export declare function detectLocalStack(): Promise<{
+    available: boolean;
+    localstackRunning: boolean;
+    tfLocalInstalled: boolean;
+}>;