@actuallyjamez/elysian 0.4.0 → 0.5.1

package/README.md

@@ -1,23 +1,31 @@
 # elysian
 
-Automatic Lambda bundler for [Elysia](https://elysiajs.com/) with AWS API Gateway and Terraform integration.
+> Automatic Lambda bundler for [Elysia](https://elysiajs.com/) with AWS API Gateway and Terraform integration.
 
 ## Features
 
 - **Zero-config Lambda handlers** - Just export your Elysia routes as default, handlers are auto-generated
+- **Interactive init wizard** - Sets up fresh or existing projects with smart defaults
+- **Package manager detection** - Automatically detects bun/npm/pnpm/yarn from lockfiles
 - **Automatic OpenAPI aggregation** - All routes are aggregated into a single OpenAPI spec endpoint
-- **Terraform integration** - Generates `tfvars` files for seamless infrastructure deployment
+- **Smart Terraform integration** - Generates modular Terraform files that won't overwrite your existing config
 - **Type-safe configuration** - Full TypeScript support with `defineConfig()`
 - **Watch mode** - Fast rebuilds during development
 
 ## Installation
 
 ```bash
-# Configure GitHub registry for @actuallyjamez scope
-echo "@actuallyjamez:registry=https://npm.pkg.github.com" >> .npmrc
-
-# Install
+# With bun (recommended)
 bun add elysia @actuallyjamez/elysian
+
+# With npm
+npm install elysia @actuallyjamez/elysian
+
+# With pnpm
+pnpm add elysia @actuallyjamez/elysian
+
+# With yarn
+yarn add elysia @actuallyjamez/elysian
 ```
 
 ## Quick Start
@@ -25,13 +33,41 @@ bun add elysia @actuallyjamez/elysian
 ### 1. Initialize your project
 
 ```bash
-bunx @actuallyjamez/elysian init --name my-api
+# Interactive wizard - prompts for everything you need
+elysian init
 ```
 
-This creates:
-- `elysian.config.ts` - Configuration file
-- `src/lambdas/hello.ts` - Example lambda
-- `terraform/main.tf` - Terraform infrastructure
+The wizard will:
+- Ask where to create the project (default: current directory)
+- Detect your package manager automatically
+- Create all necessary files
+- Install dependencies (fresh projects only)
+
+**Fresh project example:**
+```
+? Where would you like to create your project? my-api
+✔ Created directory: my-api
+
+ℹ Creating new elysian project: my-api
+
+? Package manager: bun
+✔ Created package.json
+✔ Created elysian.config.ts
+✔ Created src/lambdas/hello.ts
+✔ Created terraform/providers.tf
+...
+```
+
+**Existing project example:**
+```
+ℹ Adding elysian to: my-existing-app
+
+ℹ Detected package manager: bun
+? Install dependencies? Yes
+✔ Created elysian.config.ts
+✔ Updated terraform/variables.tf
+...
+```
 
 ### 2. Write your lambdas
 
@@ -54,16 +90,16 @@ export default createLambda()
   });
 ```
 
-**That's it!** No need to export a handler - the bundler wraps your default export automatically.
+**That's it!** No need to export a handler - bundler wraps your default export automatically.
 
 ### 3. Build
 
 ```bash
 # Development build
-bunx elysian build
+elysian build
 
 # Production build (minified)
-bunx elysian build --prod
+elysian build --prod
 ```
 
 ### 4. Deploy
@@ -82,30 +118,32 @@ Create `elysian.config.ts` in your project root:
 import { defineConfig } from "@actuallyjamez/elysian";
 
 export default defineConfig({
-  // Required
-  apiName: "my-api",
+  // Required: Used for naming your AWS resources
+  name: "my-api",
 
-  // Optional (showing defaults)
+  // Optional: Lambda source directory (default: "src/lambdas")
   lambdasDir: "src/lambdas",
+
+  // Optional: Build output directory (default: "dist")
   outputDir: "dist",
 
-  // OpenAPI configuration
+  // Optional: OpenAPI configuration (default: enabled)
+  // Note: title and version have smart defaults
   openapi: {
     enabled: true,
-    title: "My API",
-    version: "1.0.0",
+    // title defaults to `name` if not provided
+    // version defaults to package.json version if not provided
     description: "API description",
   },
 
-  // Terraform output configuration
+  // Optional: Terraform output directory (default: "terraform")
   terraform: {
     outputDir: "terraform",
-    tfvarsFilename: "api-routes.auto.tfvars", // Won't overwrite your existing tfvars
   },
 
-  // Lambda defaults (used in generated tfvars)
+  // Optional: Lambda defaults
   lambda: {
-    runtime: "nodejs20.x",
+    runtime: "nodejs22.x",
     memorySize: 256,
     timeout: 30,
   },
@@ -114,37 +152,66 @@ export default defineConfig({
 
 ## CLI Commands
 
+### `elysian init`
+
+Interactive wizard to initialize a new elysian project.
+
+```bash
+# Initialize in current directory
+elysian init
+
+# Initialize in subdirectory (creates it if needed)
+elysian init
+# Answer: my-new-api
+
+# Force overwrite existing files
+elysian init --force
+```
+
+**What it creates (fresh project):**
+- `package.json` - With build scripts
+- `tsconfig.json` - TypeScript configuration
+- `.gitignore` - Ignores node_modules, dist, terraform state
+- `elysian.config.ts` - Elysian configuration
+- `src/lambdas/hello.ts` - Example lambda
+- `terraform/providers.tf` - AWS provider configuration
+- `terraform/variables.tf` - Terraform variables
+- `terraform/main.tf` - Lambda and API Gateway resources
+- `terraform/outputs.tf` - API endpoint output
+
+**What it does (existing project):**
+- Detects package manager from lockfiles
+- Creates `elysian.config.ts` (doesn't overwrite if exists)
+- Creates example lambda only if no `.ts` files in `src/lambdas/`
+- Smart-appends to existing Terraform files (won't overwrite your config)
+
 ### `elysian build`
 
 Build all lambdas for deployment.
 
 ```bash
-bunx elysian build          # Development build
-bunx elysian build --prod   # Production build (minified)
+# Development build
+elysian build
+
+# Production build (minified, no sourcemaps)
+elysian build --prod
 ```
 
 **Output:**
 - `dist/*.js` - Bundled lambda code
 - `dist/*.zip` - Lambda deployment packages
 - `dist/manifest.json` - Route manifest (for debugging)
-- `terraform/api-routes.auto.tfvars` - Terraform variables
 
 ### `elysian dev`
 
 Watch mode for development - rebuilds on file changes.
 
 ```bash
-bunx elysian dev              # Watch with packaging
-bunx elysian dev --no-package # Skip zip creation (faster)
-```
+# Watch with packaging
+elysian dev
 
-### `elysian init`
-
-Initialize a new project with example files.
-
-```bash
-bunx elysian init --name my-api
-bunx elysian init --force  # Overwrite existing files
+# Watch without zip creation (faster)
+elysian dev --no-package
 ```
 
 ### `elysian generate-iac`
@@ -152,15 +219,28 @@ bunx elysian init --force  # Overwrite existing files
 Regenerate Terraform files without rebuilding lambdas.
 
 ```bash
-bunx elysian generate-iac
+elysian generate-iac
 ```
 
+**Smart Terraform file handling:**
+- `providers.tf` - Adds AWS provider if missing
+- `variables.tf` - Adds missing variables only
+- `main.tf` - Adds Lambda/API Gateway resources if missing
+- `outputs.tf` - Adds API endpoint output if missing
+
 ## How It Works
 
 ### 1. Route Discovery
 
 The bundler scans your `lambdasDir` for `.ts` files. Each file becomes a separate Lambda function.
 
+```
+src/lambdas/
+├── users.ts    → users.zip → AWS Lambda (users-api)
+├── posts.ts    → posts.zip → AWS Lambda (posts-api)
+└── auth.ts     → auth.zip  → AWS Lambda (auth-api)
+```
+
 ### 2. Handler Injection
 
 When you export an Elysia app as default:
@@ -187,7 +267,14 @@ An `__openapi__` lambda is automatically generated that imports all your routes
 
 ### 4. Terraform Integration
 
-The generated `tfvars` file contains:
+The generated Terraform files are modular and won't overwrite your existing configuration:
+
+- **providers.tf** - AWS provider with version `~> 6.0`
+- **variables.tf** - All variables (region, lambda config, routes)
+- **main.tf** - API Gateway, Lambda, IAM resources
+- **outputs.tf** - API endpoint URL
+
+The `terraform/api-routes.auto.tfvars` file is auto-generated on each build with:
 - List of Lambda names
 - Route-to-Lambda mappings (with API Gateway path format)
 - Lambda configuration defaults
@@ -197,22 +284,28 @@ The generated `tfvars` file contains:
 ```
 my-api/
 ├── elysian.config.ts         # Configuration
+├── package.json              # Dependencies & scripts
+├── tsconfig.json            # TypeScript config
+├── .gitignore               # Git ignore patterns
 ├── src/
 │   └── lambdas/
-│       ├── users.ts          # → users.zip Lambda
-│       ├── posts.ts          # → posts.zip Lambda
-│       └── auth.ts           # → auth.zip Lambda
-├── dist/                     # Build output
-│   ├── users.js
-│   ├── users.zip
-│   ├── posts.js
-│   ├── posts.zip
-│   ├── __openapi__.js        # Auto-generated
+│       ├── users.ts          # → my-api-users.zip Lambda
+│       ├── posts.ts          # → my-api-posts.zip Lambda
+│       └── auth.ts           # → my-api-auth.zip Lambda
+├── dist/                    # Build output
+│   ├── my-api-users.js
+│   ├── my-api-users.zip
+│   ├── my-api-posts.js
+│   ├── my-api-posts.zip
+│   ├── __openapi__.js       # Auto-generated
 │   ├── __openapi__.zip
 │   └── manifest.json
 └── terraform/
-    ├── main.tf
-    └── api-routes.auto.tfvars  # Auto-generated
+    ├── providers.tf          # AWS provider
+    ├── variables.tf         # Terraform variables
+    ├── main.tf             # Resources (Lambda, API Gateway, IAM)
+    ├── outputs.tf          # Outputs
+    └── api-routes.auto.tfvars  # Auto-generated on build
 ```
 
 ## Requirements

package/dist/cli/commands/build.js

@@ -57,7 +57,7 @@ export const buildCommand = defineCommand({
             console.log(`  ${pc.red("✗")} ${error instanceof Error ? error.message : error}`);
             process.exit(1);
         }
-        const apiName = config.apiName;
+        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);
@@ -85,18 +85,18 @@ export const buildCommand = defineCommand({
         mkdirSync(tempDir, { recursive: true });
         const buildResults = [];
         for (const file of lambdaFiles) {
-            const name = file.replace(/\.ts$/, "");
-            const bundleName = getLambdaBundleName(apiName, 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}`);
+                console.log(`  ${pc.red("✗")} Failed to build ${lambdaName}: ${result.error}`);
                 process.exit(1);
             }
         }
@@ -111,25 +111,25 @@ export const buildCommand = defineCommand({
         console.log(`  ${pc.green("✓")} Packaging lambdas...`);
         const packageSizes = new Map();
         for (const file of lambdaFiles) {
-            const name = file.replace(/\.ts$/, "");
-            const bundleName = getLambdaBundleName(apiName, 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}`);
+                console.log(`  ${pc.red("✗")} 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...`);
         try {
-            const manifest = await generateManifest(lambdaFiles, outputDir, config.openapi.enabled, apiName);
+            const manifest = await generateManifest(lambdaFiles, outputDir, config.openapi.enabled, name);
             // Write JSON manifest
             const manifestPath = join(outputDir, "manifest.json");
             await writeManifest(manifest, manifestPath);
@@ -145,8 +145,8 @@ export const buildCommand = defineCommand({
             const routesByLambda = new Map();
             for (const route of manifest.routes) {
                 // Extract display name (original name) from bundle name
-                const displayName = route.lambda.startsWith(`${apiName}-`)
-                    ? route.lambda.slice(apiName.length + 1)
+                const displayName = route.lambda.startsWith(`${name}-`)
+                    ? route.lambda.slice(name.length + 1)
                     : route.lambda;
                 const existing = routesByLambda.get(displayName) || [];
                 existing.push(route);

package/dist/cli/commands/dev.js

@@ -32,7 +32,7 @@ export const devCommand = defineCommand({
             consola.error(error instanceof Error ? error.message : error);
             process.exit(1);
         }
-        const apiName = config.apiName;
+        const name = config.name;
         const lambdasDir = join(process.cwd(), config.lambdasDir);
         const outputDir = join(process.cwd(), config.outputDir);
         const tempDir = join(outputDir, "__temp__");
@@ -51,7 +51,7 @@ export const devCommand = defineCommand({
         // Build function for a single lambda
         async function buildSingleLambda(filename) {
             const name = filename.replace(/\.ts$/, "");
-            const bundleName = getLambdaBundleName(apiName, name);
+            const bundleName = getLambdaBundleName(name, name);
             const inputPath = join(lambdasDir, filename);
             // Create wrapper entry
             const wrapperPath = join(tempDir, `${name}-wrapper.ts`);

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

@@ -25,7 +25,7 @@ export const generateIacCommand = defineCommand({
             consola.error(error instanceof Error ? error.message : error);
             process.exit(1);
         }
-        const apiName = config.apiName;
+        const name = config.name;
         const outputDir = join(process.cwd(), config.outputDir);
         const terraformDir = join(process.cwd(), config.terraform.outputDir);
         // Check that build output exists
@@ -45,14 +45,14 @@ export const generateIacCommand = defineCommand({
         // The manifest generator will re-add the prefix
         const lambdaFiles = jsFiles.map((f) => {
             const bundleName = f.replace(/\.js$/, "");
-            const originalName = getOriginalLambdaName(apiName, bundleName);
+            const originalName = getOriginalLambdaName(name, bundleName);
             return `${originalName}.ts`;
         });
         consola.info(`Found ${lambdaFiles.length} built lambda(s)`);
         // Generate manifest
         consola.start("Generating route manifest...");
         try {
-            const manifest = await generateManifest(lambdaFiles, outputDir, config.openapi.enabled, apiName);
+            const manifest = await generateManifest(lambdaFiles, outputDir, config.openapi.enabled, name);
             // Write JSON manifest
             const manifestPath = join(outputDir, "manifest.json");
             await writeManifest(manifest, manifestPath);

package/dist/cli/commands/init/detect.d.ts

@@ -24,7 +24,7 @@ export interface ProjectInfo {
     hasLambdasDir: boolean;
     /** Whether there are any .ts files in src/lambdas/ */
     hasLambdaFiles: boolean;
-    /** Directory name (for default apiName) */
+    /** Directory name (for default name) */
     directoryName: string;
 }
 /**

package/dist/cli/commands/init/prompts.d.ts

@@ -4,7 +4,7 @@
 import type { PackageManager } from "./detect";
 export interface WizardAnswers {
     targetDir: string;
-    apiName: string;
+    name: string;
     packageManager: PackageManager;
     installDeps: boolean;
 }
@@ -16,8 +16,8 @@ export declare function promptTargetDirectory(currentDirName: string): Promise<s
 /**
  * Run wizard for a fresh (empty) project
  */
-export declare function runFreshProjectWizard(apiName: string): Promise<Omit<WizardAnswers, "targetDir" | "apiName"> | null>;
+export declare function runFreshProjectWizard(apiName: string): Promise<Omit<WizardAnswers, "targetDir"> | null>;
 /**
  * Run wizard for an existing project
  */
-export declare function runExistingProjectWizard(apiName: string, detectedPackageManager: PackageManager | null): Promise<Omit<WizardAnswers, "targetDir" | "apiName"> | null>;
+export declare function runExistingProjectWizard(apiName: string, detectedPackageManager: PackageManager | null): Promise<Omit<WizardAnswers, "targetDir"> | null>;

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

@@ -46,6 +46,7 @@ export async function runFreshProjectWizard(apiName) {
         return null;
     }
     return {
+        name: apiName,
         packageManager: packageManager,
         installDeps: true, // Always install for fresh projects
     };
@@ -87,6 +88,7 @@ export async function runExistingProjectWizard(apiName, detectedPackageManager)
         return null;
     }
     return {
+        name: apiName,
         packageManager,
         installDeps: installDeps,
     };

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

@@ -49,7 +49,7 @@ export async function scaffoldProject(cwd, info, answers, force) {
     // For fresh projects, create package.json, .gitignore, tsconfig.json
     if (info.isEmpty) {
         const packageJsonPath = join(cwd, "package.json");
-        await writeFile(packageJsonPath, packageJsonTemplate(answers.apiName), result, false);
+        await writeFile(packageJsonPath, packageJsonTemplate(answers.name), result, false);
         const gitignorePath = join(cwd, ".gitignore");
         if (!existsSync(gitignorePath)) {
             await writeFile(gitignorePath, gitignoreTemplate(), result, false);
@@ -62,7 +62,7 @@ export async function scaffoldProject(cwd, info, answers, force) {
     // Create elysian.config.ts
     const configPath = join(cwd, "elysian.config.ts");
     if (!existsSync(configPath) || force) {
-        await writeFile(configPath, configTemplate(answers.apiName), result, existsSync(configPath));
+        await writeFile(configPath, configTemplate(answers.name), result, existsSync(configPath));
     }
     else {
         result.skipped.push(configPath);
@@ -73,13 +73,13 @@ export async function scaffoldProject(cwd, info, answers, force) {
         await writeFile(exampleLambdaPath, exampleLambdaTemplate(), result, false);
     }
     // Handle Terraform files
-    await scaffoldTerraform(cwd, info, answers.apiName, result);
+    await scaffoldTerraform(cwd, info, answers.name, result);
     return result;
 }
 /**
  * Scaffold Terraform files with smart appending
  */
-async function scaffoldTerraform(cwd, info, apiName, result) {
+async function scaffoldTerraform(cwd, info, name, result) {
     const tfDir = join(cwd, "terraform");
     // providers.tf
     const providersPath = join(tfDir, "providers.tf");
@@ -100,7 +100,7 @@ async function scaffoldTerraform(cwd, info, apiName, result) {
     const variablesPath = join(tfDir, "variables.tf");
     if (info.terraformFiles.variables) {
         const existing = await readFileOrEmpty(variablesPath);
-        const updated = getMissingVariables(existing, apiName);
+        const updated = getMissingVariables(existing, name);
         if (updated !== existing) {
             await writeFile(variablesPath, updated, result, true);
         }
@@ -109,7 +109,7 @@ async function scaffoldTerraform(cwd, info, apiName, result) {
         }
     }
     else {
-        await writeFile(variablesPath, tfTemplates.variables(apiName), result, false);
+        await writeFile(variablesPath, tfTemplates.variables(name), result, false);
     }
     // main.tf
     const mainPath = join(tfDir, "main.tf");

package/dist/cli/commands/init/templates.d.ts

@@ -4,7 +4,7 @@
 /**
  * elysian.config.ts template
  */
-export declare function configTemplate(apiName: string): string;
+export declare function configTemplate(name: string): string;
 /**
  * Example lambda template
  */
@@ -12,7 +12,7 @@ export declare function exampleLambdaTemplate(): string;
 /**
  * package.json template for fresh projects
  */
-export declare function packageJsonTemplate(apiName: string): string;
+export declare function packageJsonTemplate(name: string): string;
 /**
  * .gitignore template
  */

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

@@ -4,15 +4,11 @@
 /**
  * elysian.config.ts template
  */
-export function configTemplate(apiName) {
+export function configTemplate(name) {
     return `import { defineConfig } from "@actuallyjamez/elysian";
 
 export default defineConfig({
-	apiName: "${apiName}",
-	openapi: {
-		title: "${apiName}",
-		version: "1.0.0",
-	},
+	name: "${name}",
 });
 `;
 }
@@ -40,9 +36,9 @@ export default createLambda()
 /**
  * package.json template for fresh projects
  */
-export function packageJsonTemplate(apiName) {
+export function packageJsonTemplate(name) {
     return JSON.stringify({
-        name: apiName,
+        name: name,
         version: "0.1.0",
         type: "module",
         scripts: {

package/dist/cli/commands/init/terraform.d.ts

@@ -24,7 +24,7 @@ export declare function appendProviders(existing: string): string;
 /**
  * Get missing variables and return the block to append
  */
-export declare function getMissingVariables(existing: string, apiName: string): string;
+export declare function getMissingVariables(existing: string, name: string): string;
 /**
  * Smart append to main.tf - only add if API Gateway resource is missing
  */
@@ -38,7 +38,7 @@ export declare function appendOutputs(existing: string): string;
  */
 export declare const templates: {
     providers: string;
-    variables: (apiName: string) => string;
+    variables: (name: string) => string;
     main: string;
     outputs: string;
 };

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

@@ -58,7 +58,7 @@ export function appendProviders(existing) {
 /**
  * Get missing variables and return the block to append
  */
-export function getMissingVariables(existing, apiName) {
+export function getMissingVariables(existing, name) {
     const variables = {
         region: `
 variable "region" {
@@ -95,9 +95,9 @@ variable "lambda_timeout" {
   default = 30
 }`,
         api_name: `
-variable "api_name" {
+	variable "api_name" {
   type    = string
-  default = "${apiName}"
+  default = "${name}"
 }`,
         tags: `
 variable "tags" {
@@ -252,7 +252,7 @@ export function appendOutputs(existing) {
  */
 export const templates = {
     providers: PROVIDERS_BLOCK.trim() + "\n",
-    variables: (apiName) => `# Elysian: Terraform Variables
+    variables: (name) => `# Elysian: Terraform Variables
 
 variable "region" {
   type    = string
@@ -290,7 +290,7 @@ variable "lambda_timeout" {
 
 variable "api_name" {
   type    = string
-  default = "${apiName}"
+  default = "${name}"
 }
 
 variable "tags" {

package/dist/cli/commands/init.js

@@ -3,6 +3,7 @@
  */
 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";
@@ -30,7 +31,7 @@ export const initCommand = defineCommand({
         }
         // Resolve the target directory
         const cwd = resolve(originalCwd, targetDir);
-        const apiName = basename(cwd);
+        const name = basename(cwd);
         // Create directory if it doesn't exist
         if (!existsSync(cwd)) {
             mkdirSync(cwd, { recursive: true });
@@ -46,26 +47,24 @@ export const initCommand = defineCommand({
         // Run appropriate wizard based on whether directory is empty
         let answers;
         if (info.isEmpty) {
-            const result = await runFreshProjectWizard(apiName);
+            const result = await runFreshProjectWizard(name);
             if (!result) {
                 consola.info("Cancelled");
                 process.exit(0);
             }
             answers = {
                 targetDir,
-                apiName,
                 ...result,
             };
         }
         else {
-            const result = await runExistingProjectWizard(apiName, info.packageManager);
+            const result = await runExistingProjectWizard(name, info.packageManager);
             if (!result) {
                 consola.info("Cancelled");
                 process.exit(0);
             }
             answers = {
                 targetDir,
-                apiName,
                 ...result,
             };
         }
@@ -88,12 +87,20 @@ export const initCommand = defineCommand({
         const pm = answers.packageManager;
         const runCmd = pm === "npm" ? "npm run" : pm;
         // If we created in a subdirectory, tell user to cd into it
-        const cdStep = targetDir !== "." ? `cd ${targetDir}\n\n` : "";
-        consola.box("Project initialized!\n\n" +
-            "Next steps:\n\n" +
-            cdStep +
-            (answers.installDeps ? "" : `${pm} add elysia @actuallyjamez/elysian\n\n`) +
-            `${runCmd} elysian build\n\n` +
-            "cd terraform && terraform init && terraform apply");
+        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 (!answers.installDeps) {
+            console.log(`    ${pm} add elysia @actuallyjamez/elysian`);
+            console.log();
+        }
+        console.log(`    ${runCmd} elysian build`);
+        console.log();
+        console.log(`    cd terraform && terraform init && terraform apply`);
     },
 });

package/dist/core/config.d.ts

@@ -4,9 +4,9 @@
 export interface OpenAPIConfig {
     /** Enable OpenAPI auto-aggregation (default: true) */
     enabled?: boolean;
-    /** API title for OpenAPI spec */
+    /** API title for OpenAPI spec (defaults to name if not provided) */
     title?: string;
-    /** API version for OpenAPI spec */
+    /** API version for OpenAPI spec (defaults to package.json version if not provided) */
     version?: string;
     /** API description for OpenAPI spec */
     description?: string;
@@ -35,7 +35,7 @@ export interface TerraformConfig {
 }
 export interface ElysianConfig {
     /** Name of the API (used for resource naming) */
-    apiName: string;
+    name: string;
     /** Directory containing lambda files (default: "src/lambdas") */
     lambdasDir?: string;
     /** Output directory for built lambdas (default: "dist") */
@@ -50,7 +50,7 @@ export interface ElysianConfig {
     terraform?: TerraformConfig;
 }
 export interface ResolvedConfig {
-    apiName: string;
+    name: string;
     lambdasDir: string;
     outputDir: string;
     openapi: Required<OpenAPIConfig>;
@@ -65,7 +65,7 @@ export declare function defineConfig(config: ElysianConfig): ElysianConfig;
 /**
  * Resolve configuration with defaults applied
  */
-export declare function resolveConfig(config: ElysianConfig): ResolvedConfig;
+export declare function resolveConfig(config: ElysianConfig, cwd: string): Promise<ResolvedConfig>;
 /**
  * Load configuration from elysian.config.ts
  */

package/dist/core/config.js

@@ -25,6 +25,19 @@ const DEFAULT_CONFIG = {
         tfvarsFilename: "api-routes.auto.tfvars",
     },
 };
+/**
+ * Read version from package.json
+ */
+async function readPackageVersion(cwd) {
+    const packagePath = `${cwd}/package.json`;
+    try {
+        const content = await Bun.file(packagePath).json();
+        return content.version || null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Define configuration with type safety and defaults
  */
@@ -34,15 +47,16 @@ export function defineConfig(config) {
 /**
  * Resolve configuration with defaults applied
  */
-export function resolveConfig(config) {
+export async function resolveConfig(config, cwd) {
+    const pkgVersion = await readPackageVersion(cwd);
     return {
-        apiName: config.apiName,
+        name: config.name,
         lambdasDir: config.lambdasDir ?? DEFAULT_CONFIG.lambdasDir,
         outputDir: config.outputDir ?? DEFAULT_CONFIG.outputDir,
         openapi: {
             enabled: config.openapi?.enabled ?? DEFAULT_CONFIG.openapi.enabled,
-            title: config.openapi?.title ?? DEFAULT_CONFIG.openapi.title,
-            version: config.openapi?.version ?? DEFAULT_CONFIG.openapi.version,
+            title: config.openapi?.title ?? config.name,
+            version: config.openapi?.version ?? pkgVersion ?? DEFAULT_CONFIG.openapi.version,
             description: config.openapi?.description ?? DEFAULT_CONFIG.openapi.description,
         },
         build: {
@@ -70,10 +84,10 @@ export async function loadConfig(cwd = process.cwd()) {
     try {
         const configModule = await import(configPath);
         const config = configModule.default;
-        if (!config.apiName) {
-            throw new Error("apiName is required in elysian.config.ts");
+        if (!config.name) {
+            throw new Error("name is required in elysian.config.ts");
         }
-        return resolveConfig(config);
+        return resolveConfig(config, cwd);
     }
     catch (error) {
         if (error.code === "ERR_MODULE_NOT_FOUND") {

package/dist/core/manifest.d.ts

@@ -36,7 +36,7 @@ export declare function generateRouteName(lambda: string, method: string, path:
 /**
  * Generate manifest by introspecting built lambda modules
  */
-export declare function generateManifest(lambdaFiles: string[], outputDir: string, openapiEnabled?: boolean, apiName?: string): Promise<ApiManifest>;
+export declare function generateManifest(lambdaFiles: string[], outputDir: string, openapiEnabled?: boolean, name?: string): Promise<ApiManifest>;
 /**
  * Write manifest to JSON file
  */

package/dist/core/manifest.js

@@ -31,7 +31,7 @@ export function generateRouteName(lambda, method, path) {
 /**
  * Generate manifest by introspecting built lambda modules
  */
-export async function generateManifest(lambdaFiles, outputDir, openapiEnabled = true, apiName = "") {
+export async function generateManifest(lambdaFiles, outputDir, openapiEnabled = true, name = "") {
     const manifest = {
         lambdas: [],
         routes: [],
@@ -43,7 +43,7 @@ export async function generateManifest(lambdaFiles, outputDir, openapiEnabled =
     for (const file of sortedFiles) {
         const originalName = file.replace(/\.ts$/, "");
         // Use prefixed bundle name for file lookup
-        const bundleName = apiName ? getLambdaBundleName(apiName, originalName) : originalName;
+        const bundleName = name ? getLambdaBundleName(name, originalName) : originalName;
         const modulePath = isAbsolute(outputDir)
             ? join(outputDir, `${bundleName}.js`)
             : join(process.cwd(), outputDir, `${bundleName}.js`);
@@ -71,12 +71,12 @@ export async function generateManifest(lambdaFiles, outputDir, openapiEnabled =
                 });
                 // Determine which lambda should handle this route
                 let targetLambda = bundleName;
-                // OpenAPI routes always go to the __openapi__ lambda if enabled
+                // OpenAPI routes always go to __openapi__ lambda if enabled
                 if (openapiEnabled && path.startsWith("/openapi")) {
-                    targetLambda = apiName ? getLambdaBundleName(apiName, "__openapi__") : "__openapi__";
+                    targetLambda = name ? getLambdaBundleName(name, "__openapi__") : "__openapi__";
                 }
                 else if (originalName === "__openapi__") {
-                    // Skip non-openapi routes from the openapi aggregator lambda
+                    // Skip non-openapi routes from openapi aggregator lambda
                     continue;
                 }
                 // Check for route conflicts

package/dist/core/naming.d.ts

@@ -1,12 +1,13 @@
 /**
- * Naming utilities for lambda bundles
+ * Lambda naming utilities
  */
 /**
- * Generate the prefixed lambda name for bundle files
- * Format: {apiName}-{lambdaName}
+ * Generate Lambda bundle name with API name prefix
+ * Format: {name}-{lambdaName}
  */
-export declare function getLambdaBundleName(apiName: string, lambdaName: string): string;
+export declare function getLambdaBundleName(name: string, lambdaName: string): string;
 /**
- * Extract the original lambda name from a prefixed bundle name
+ * Extract original lambda name from bundle name
+ * Reverses getLambdaBundleName()
  */
-export declare function getOriginalLambdaName(apiName: string, bundleName: string): string;
+export declare function getOriginalLambdaName(name: string, bundleName: string): string;

package/dist/core/naming.js

@@ -1,18 +1,19 @@
 /**
- * Naming utilities for lambda bundles
+ * Lambda naming utilities
  */
 /**
- * Generate the prefixed lambda name for bundle files
- * Format: {apiName}-{lambdaName}
+ * Generate Lambda bundle name with API name prefix
+ * Format: {name}-{lambdaName}
  */
-export function getLambdaBundleName(apiName, lambdaName) {
-    return `${apiName}-${lambdaName}`;
+export function getLambdaBundleName(name, lambdaName) {
+    return `${name}-${lambdaName}`;
 }
 /**
- * Extract the original lambda name from a prefixed bundle name
+ * Extract original lambda name from bundle name
+ * Reverses getLambdaBundleName()
  */
-export function getOriginalLambdaName(apiName, bundleName) {
-    const prefix = `${apiName}-`;
+export function getOriginalLambdaName(name, bundleName) {
+    const prefix = `${name}-`;
     if (bundleName.startsWith(prefix)) {
         return bundleName.slice(prefix.length);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@actuallyjamez/elysian",
-	"version": "0.4.0",
+	"version": "0.5.1",
 	"description": "Automatic Lambda bundler for Elysia with API Gateway and Terraform integration",
 	"type": "module",
 	"main": "./dist/index.js",