@actuallyjamez/elysian 0.2.1 → 0.4.0

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

@@ -0,0 +1,33 @@
+/**
+ * Detection utilities for init wizard
+ */
+export type PackageManager = "bun" | "npm" | "pnpm" | "yarn";
+export interface ProjectInfo {
+    /** Whether the directory is empty (only hidden files allowed) */
+    isEmpty: boolean;
+    /** Detected package manager from lockfile, or null */
+    packageManager: PackageManager | null;
+    /** Name from package.json, or null */
+    packageName: string | null;
+    /** Whether elysian.config.ts exists */
+    hasElysianConfig: boolean;
+    /** Whether terraform/ directory exists */
+    hasTerraformDir: boolean;
+    /** Existing terraform files */
+    terraformFiles: {
+        providers: boolean;
+        variables: boolean;
+        main: boolean;
+        outputs: boolean;
+    };
+    /** Whether src/lambdas/ exists */
+    hasLambdasDir: boolean;
+    /** Whether there are any .ts files in src/lambdas/ */
+    hasLambdaFiles: boolean;
+    /** Directory name (for default apiName) */
+    directoryName: string;
+}
+/**
+ * Gather all project information for the init wizard
+ */
+export declare function detectProject(cwd: string): Promise<ProjectInfo>;

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

@@ -0,0 +1,98 @@
+/**
+ * Detection utilities for init wizard
+ */
+import { existsSync, readdirSync } from "fs";
+import { join, basename } from "path";
+/**
+ * Check if a directory is empty (ignoring hidden files like .git)
+ */
+function isDirectoryEmpty(cwd) {
+    try {
+        const files = readdirSync(cwd);
+        // Filter out hidden files (starting with .)
+        const visibleFiles = files.filter((f) => !f.startsWith("."));
+        return visibleFiles.length === 0;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Detect package manager from lockfiles
+ */
+function detectPackageManager(cwd) {
+    if (existsSync(join(cwd, "bun.lock")) || existsSync(join(cwd, "bun.lockb"))) {
+        return "bun";
+    }
+    if (existsSync(join(cwd, "pnpm-lock.yaml"))) {
+        return "pnpm";
+    }
+    if (existsSync(join(cwd, "yarn.lock"))) {
+        return "yarn";
+    }
+    if (existsSync(join(cwd, "package-lock.json"))) {
+        return "npm";
+    }
+    return null;
+}
+/**
+ * Read package name from package.json
+ */
+async function readPackageName(cwd) {
+    const packagePath = join(cwd, "package.json");
+    if (!existsSync(packagePath)) {
+        return null;
+    }
+    try {
+        const content = await Bun.file(packagePath).json();
+        return content.name || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check which terraform files exist
+ */
+function checkTerraformFiles(cwd) {
+    const tfDir = join(cwd, "terraform");
+    return {
+        providers: existsSync(join(tfDir, "providers.tf")),
+        variables: existsSync(join(tfDir, "variables.tf")),
+        main: existsSync(join(tfDir, "main.tf")),
+        outputs: existsSync(join(tfDir, "outputs.tf")),
+    };
+}
+/**
+ * Check if there are any .ts files in the lambdas directory
+ */
+function hasLambdaFiles(cwd) {
+    const lambdasDir = join(cwd, "src/lambdas");
+    if (!existsSync(lambdasDir)) {
+        return false;
+    }
+    try {
+        const files = readdirSync(lambdasDir);
+        return files.some((f) => f.endsWith(".ts"));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Gather all project information for the init wizard
+ */
+export async function detectProject(cwd) {
+    const packageName = await readPackageName(cwd);
+    return {
+        isEmpty: isDirectoryEmpty(cwd),
+        packageManager: detectPackageManager(cwd),
+        packageName,
+        hasElysianConfig: existsSync(join(cwd, "elysian.config.ts")),
+        hasTerraformDir: existsSync(join(cwd, "terraform")),
+        terraformFiles: checkTerraformFiles(cwd),
+        hasLambdasDir: existsSync(join(cwd, "src/lambdas")),
+        hasLambdaFiles: hasLambdaFiles(cwd),
+        directoryName: basename(cwd),
+    };
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Init module exports
+ */
+export { detectProject, type ProjectInfo, type PackageManager } from "./detect";
+export { promptTargetDirectory, runFreshProjectWizard, runExistingProjectWizard, type WizardAnswers, } from "./prompts";
+export { scaffoldProject, installDependencies, printResults, type ScaffoldResult, } from "./scaffold";

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

@@ -0,0 +1,6 @@
+/**
+ * Init module exports
+ */
+export { detectProject } from "./detect";
+export { promptTargetDirectory, runFreshProjectWizard, runExistingProjectWizard, } from "./prompts";
+export { scaffoldProject, installDependencies, printResults, } from "./scaffold";

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

@@ -0,0 +1,23 @@
+/**
+ * Wizard prompts using consola.prompt
+ */
+import type { PackageManager } from "./detect";
+export interface WizardAnswers {
+    targetDir: string;
+    apiName: string;
+    packageManager: PackageManager;
+    installDeps: boolean;
+}
+/**
+ * Run the initial wizard to get the target directory
+ * Returns the target directory path, or null if cancelled
+ */
+export declare function promptTargetDirectory(currentDirName: string): Promise<string | null>;
+/**
+ * Run wizard for a fresh (empty) project
+ */
+export declare function runFreshProjectWizard(apiName: string): Promise<Omit<WizardAnswers, "targetDir" | "apiName"> | null>;
+/**
+ * Run wizard for an existing project
+ */
+export declare function runExistingProjectWizard(apiName: string, detectedPackageManager: PackageManager | null): Promise<Omit<WizardAnswers, "targetDir" | "apiName"> | null>;

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

@@ -0,0 +1,93 @@
+/**
+ * Wizard prompts using consola.prompt
+ */
+import consola from "consola";
+const CANCEL_SYMBOL = Symbol.for("cancel");
+/**
+ * Check if user cancelled the prompt
+ */
+function isCancelled(value) {
+    return value === CANCEL_SYMBOL;
+}
+/**
+ * Run the initial wizard to get the target directory
+ * Returns the target directory path, or null if cancelled
+ */
+export async function promptTargetDirectory(currentDirName) {
+    console.log("");
+    const targetDir = await consola.prompt("Where would you like to create your project?", {
+        type: "text",
+        default: ".",
+        placeholder: ". (current directory)",
+        cancel: "symbol",
+    });
+    if (isCancelled(targetDir)) {
+        return null;
+    }
+    return targetDir;
+}
+/**
+ * Run wizard for a fresh (empty) project
+ */
+export async function runFreshProjectWizard(apiName) {
+    consola.info(`Creating new elysian project: ${apiName}\n`);
+    // Prompt for package manager
+    const packageManager = await consola.prompt("Package manager:", {
+        type: "select",
+        options: [
+            { value: "bun", label: "bun", hint: "recommended" },
+            { value: "npm", label: "npm" },
+            { value: "pnpm", label: "pnpm" },
+            { value: "yarn", label: "yarn" },
+        ],
+        cancel: "symbol",
+    });
+    if (isCancelled(packageManager)) {
+        return null;
+    }
+    return {
+        packageManager: packageManager,
+        installDeps: true, // Always install for fresh projects
+    };
+}
+/**
+ * Run wizard for an existing project
+ */
+export async function runExistingProjectWizard(apiName, detectedPackageManager) {
+    consola.info(`Adding elysian to: ${apiName}\n`);
+    // Use detected package manager or prompt
+    let packageManager;
+    if (detectedPackageManager) {
+        packageManager = detectedPackageManager;
+        consola.info(`Detected package manager: ${packageManager}`);
+    }
+    else {
+        const selected = await consola.prompt("Package manager:", {
+            type: "select",
+            options: [
+                { value: "bun", label: "bun", hint: "recommended" },
+                { value: "npm", label: "npm" },
+                { value: "pnpm", label: "pnpm" },
+                { value: "yarn", label: "yarn" },
+            ],
+            cancel: "symbol",
+        });
+        if (isCancelled(selected)) {
+            return null;
+        }
+        packageManager = selected;
+    }
+    // Prompt whether to install dependencies
+    const installDeps = await consola.prompt("Install dependencies?", {
+        type: "confirm",
+        initial: true,
+        cancel: "symbol",
+    });
+    if (isCancelled(installDeps)) {
+        return null;
+    }
+    return {
+        packageManager,
+        installDeps: installDeps,
+    };
+}

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

@@ -0,0 +1,26 @@
+/**
+ * File scaffolding logic
+ */
+import type { PackageManager, ProjectInfo } from "./detect";
+import type { WizardAnswers } from "./prompts";
+export interface ScaffoldResult {
+    created: string[];
+    updated: string[];
+    skipped: string[];
+}
+/**
+ * Scaffold all project files
+ */
+export declare function scaffoldProject(cwd: string, info: ProjectInfo, answers: WizardAnswers, force: boolean): Promise<ScaffoldResult>;
+/**
+ * Install dependencies using the specified package manager
+ */
+export declare function installDependencies(cwd: string, packageManager: PackageManager): Promise<void>;
+/**
+ * Get relative path for display
+ */
+export declare function getRelativePath(cwd: string, fullPath: string): string;
+/**
+ * Print scaffold results
+ */
+export declare function printResults(cwd: string, result: ScaffoldResult): void;

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

@@ -0,0 +1,196 @@
+/**
+ * File scaffolding logic
+ */
+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";
+/**
+ * Read file content or return empty string if not exists
+ */
+async function readFileOrEmpty(path) {
+    if (!existsSync(path)) {
+        return "";
+    }
+    return await Bun.file(path).text();
+}
+/**
+ * Write file and track in result
+ */
+async function writeFile(path, content, result, isUpdate) {
+    await Bun.write(path, content);
+    if (isUpdate) {
+        result.updated.push(path);
+    }
+    else {
+        result.created.push(path);
+    }
+}
+/**
+ * Scaffold all project files
+ */
+export async function scaffoldProject(cwd, info, answers, force) {
+    const result = {
+        created: [],
+        updated: [],
+        skipped: [],
+    };
+    // Create directories
+    const lambdasDir = join(cwd, "src/lambdas");
+    const terraformDir = join(cwd, "terraform");
+    if (!existsSync(lambdasDir)) {
+        mkdirSync(lambdasDir, { recursive: true });
+    }
+    if (!existsSync(terraformDir)) {
+        mkdirSync(terraformDir, { recursive: true });
+    }
+    // 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);
+        const gitignorePath = join(cwd, ".gitignore");
+        if (!existsSync(gitignorePath)) {
+            await writeFile(gitignorePath, gitignoreTemplate(), result, false);
+        }
+        const tsconfigPath = join(cwd, "tsconfig.json");
+        if (!existsSync(tsconfigPath)) {
+            await writeFile(tsconfigPath, tsconfigTemplate(), result, false);
+        }
+    }
+    // Create elysian.config.ts
+    const configPath = join(cwd, "elysian.config.ts");
+    if (!existsSync(configPath) || force) {
+        await writeFile(configPath, configTemplate(answers.apiName), result, existsSync(configPath));
+    }
+    else {
+        result.skipped.push(configPath);
+    }
+    // Create example lambda (only if no lambda files exist)
+    const exampleLambdaPath = join(lambdasDir, "hello.ts");
+    if (!info.hasLambdaFiles) {
+        await writeFile(exampleLambdaPath, exampleLambdaTemplate(), result, false);
+    }
+    // Handle Terraform files
+    await scaffoldTerraform(cwd, info, answers.apiName, result);
+    return result;
+}
+/**
+ * Scaffold Terraform files with smart appending
+ */
+async function scaffoldTerraform(cwd, info, apiName, result) {
+    const tfDir = join(cwd, "terraform");
+    // providers.tf
+    const providersPath = join(tfDir, "providers.tf");
+    if (info.terraformFiles.providers) {
+        const existing = await readFileOrEmpty(providersPath);
+        const updated = appendProviders(existing);
+        if (updated !== existing) {
+            await writeFile(providersPath, updated, result, true);
+        }
+        else {
+            result.skipped.push(providersPath);
+        }
+    }
+    else {
+        await writeFile(providersPath, tfTemplates.providers, result, false);
+    }
+    // variables.tf
+    const variablesPath = join(tfDir, "variables.tf");
+    if (info.terraformFiles.variables) {
+        const existing = await readFileOrEmpty(variablesPath);
+        const updated = getMissingVariables(existing, apiName);
+        if (updated !== existing) {
+            await writeFile(variablesPath, updated, result, true);
+        }
+        else {
+            result.skipped.push(variablesPath);
+        }
+    }
+    else {
+        await writeFile(variablesPath, tfTemplates.variables(apiName), result, false);
+    }
+    // main.tf
+    const mainPath = join(tfDir, "main.tf");
+    if (info.terraformFiles.main) {
+        const existing = await readFileOrEmpty(mainPath);
+        const updated = appendMain(existing);
+        if (updated !== existing) {
+            await writeFile(mainPath, updated, result, true);
+        }
+        else {
+            result.skipped.push(mainPath);
+        }
+    }
+    else {
+        await writeFile(mainPath, tfTemplates.main, result, false);
+    }
+    // outputs.tf
+    const outputsPath = join(tfDir, "outputs.tf");
+    if (info.terraformFiles.outputs) {
+        const existing = await readFileOrEmpty(outputsPath);
+        const updated = appendOutputs(existing);
+        if (updated !== existing) {
+            await writeFile(outputsPath, updated, result, true);
+        }
+        else {
+            result.skipped.push(outputsPath);
+        }
+    }
+    else {
+        await writeFile(outputsPath, tfTemplates.outputs, result, false);
+    }
+}
+/**
+ * Install dependencies using the specified package manager
+ */
+export async function installDependencies(cwd, packageManager) {
+    const deps = ["elysia", "@actuallyjamez/elysian"];
+    const devDeps = ["@types/bun", "typescript"];
+    const addCmd = packageManager === "npm" ? "install" : "add";
+    const devFlag = packageManager === "npm" ? "--save-dev" : "-D";
+    consola.start("Installing dependencies...");
+    // Install main dependencies
+    const addProc = spawn([packageManager, addCmd, ...deps], {
+        cwd,
+        stdout: "ignore",
+        stderr: "pipe",
+    });
+    await addProc.exited;
+    if (addProc.exitCode !== 0) {
+        const stderr = await new Response(addProc.stderr).text();
+        throw new Error(`Failed to install dependencies: ${stderr}`);
+    }
+    // Install dev dependencies
+    const devProc = spawn([packageManager, addCmd, devFlag, ...devDeps], {
+        cwd,
+        stdout: "ignore",
+        stderr: "pipe",
+    });
+    await devProc.exited;
+    if (devProc.exitCode !== 0) {
+        const stderr = await new Response(devProc.stderr).text();
+        throw new Error(`Failed to install dev dependencies: ${stderr}`);
+    }
+    consola.success("Dependencies installed");
+}
+/**
+ * Get relative path for display
+ */
+export function getRelativePath(cwd, fullPath) {
+    return fullPath.replace(cwd + "/", "");
+}
+/**
+ * Print scaffold results
+ */
+export function printResults(cwd, result) {
+    console.log("");
+    for (const path of result.created) {
+        consola.success(`Created ${getRelativePath(cwd, path)}`);
+    }
+    for (const path of result.updated) {
+        consola.success(`Updated ${getRelativePath(cwd, path)}`);
+    }
+    // Don't print skipped files - too noisy
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Template strings for generated files
+ */
+/**
+ * elysian.config.ts template
+ */
+export declare function configTemplate(apiName: string): string;
+/**
+ * Example lambda template
+ */
+export declare function exampleLambdaTemplate(): string;
+/**
+ * package.json template for fresh projects
+ */
+export declare function packageJsonTemplate(apiName: string): string;
+/**
+ * .gitignore template
+ */
+export declare function gitignoreTemplate(): string;
+/**
+ * tsconfig.json template
+ */
+export declare function tsconfigTemplate(): string;

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

@@ -0,0 +1,103 @@
+/**
+ * Template strings for generated files
+ */
+/**
+ * elysian.config.ts template
+ */
+export function configTemplate(apiName) {
+    return `import { defineConfig } from "@actuallyjamez/elysian";
+
+export default defineConfig({
+	apiName: "${apiName}",
+	openapi: {
+		title: "${apiName}",
+		version: "1.0.0",
+	},
+});
+`;
+}
+/**
+ * Example lambda template
+ */
+export function exampleLambdaTemplate() {
+    return `import { createLambda, t } from "@actuallyjamez/elysian";
+
+export default createLambda()
+	.get("/hello", ({ query }) => {
+		return \`Hello, \${query.name ?? "World"}!\`;
+	}, {
+		response: t.String(),
+		query: t.Object({
+			name: t.Optional(t.String()),
+		}),
+		detail: {
+			summary: "Say hello",
+			tags: ["Greeting"],
+		},
+	});
+`;
+}
+/**
+ * package.json template for fresh projects
+ */
+export function packageJsonTemplate(apiName) {
+    return JSON.stringify({
+        name: apiName,
+        version: "0.1.0",
+        type: "module",
+        scripts: {
+            build: "elysian build",
+            dev: "elysian dev",
+        },
+    }, null, 2);
+}
+/**
+ * .gitignore template
+ */
+export function gitignoreTemplate() {
+    return `# Dependencies
+node_modules/
+
+# Build output
+dist/
+
+# Environment
+.env
+.env.local
+
+# Terraform
+terraform/.terraform/
+terraform/*.tfstate
+terraform/*.tfstate.backup
+terraform/.terraform.lock.hcl
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+`;
+}
+/**
+ * tsconfig.json template
+ */
+export function tsconfigTemplate() {
+    return JSON.stringify({
+        compilerOptions: {
+            target: "ESNext",
+            module: "ESNext",
+            moduleResolution: "bundler",
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            noEmit: true,
+            types: ["bun-types"],
+        },
+        include: ["src/**/*", "elysian.config.ts"],
+        exclude: ["node_modules", "dist"],
+    }, null, 2);
+}

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

@@ -0,0 +1,44 @@
+/**
+ * Smart Terraform file handling - append missing blocks
+ */
+/**
+ * Check if content has AWS provider configured
+ */
+export declare function hasAwsProvider(content: string): boolean;
+/**
+ * Check if a variable exists in the content
+ */
+export declare function hasVariable(content: string, name: string): boolean;
+/**
+ * Check if a resource of a given type exists
+ */
+export declare function hasResource(content: string, type: string): boolean;
+/**
+ * Check if an output exists in the content
+ */
+export declare function hasOutput(content: string, name: string): boolean;
+/**
+ * Smart append to providers.tf - only add if AWS provider is missing
+ */
+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;
+/**
+ * Smart append to main.tf - only add if API Gateway resource is missing
+ */
+export declare function appendMain(existing: string): string;
+/**
+ * Smart append to outputs.tf - only add if api_endpoint output is missing
+ */
+export declare function appendOutputs(existing: string): string;
+/**
+ * Full templates for new files
+ */
+export declare const templates: {
+    providers: string;
+    variables: (apiName: string) => string;
+    main: string;
+    outputs: string;
+};