@vertz/create-vertz-app 0.1.0

package/bin/create-vertz-app.ts

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { resolveOptions, scaffold } from '../src/index.js';
+import type { Runtime } from '../src/types.js';
+
+const program = new Command();
+
+program
+  .name('create-vertz-app')
+  .description('Scaffold a new Vertz project')
+  .version('0.1.0')
+  .argument('[name]', 'Project name')
+  .option('-r, --runtime <runtime>', 'Runtime to use (bun, node, deno)', 'bun')
+  .option('-e, --example', 'Include example health module', undefined)
+  .option('--no-example', 'Exclude example health module')
+  .action(
+    async (
+      name: string | undefined,
+      options: {
+        runtime: string;
+        example?: boolean;
+      },
+    ) => {
+      try {
+        // Convert runtime string to Runtime type
+        const runtime = options.runtime.toLowerCase() as Runtime;
+
+        // Handle --example / --no-example
+        let includeExample: boolean | undefined;
+        if (options.example === true) {
+          includeExample = true;
+        } else if (options.example === false) {
+          includeExample = false;
+        }
+
+        const cliOptions = {
+          projectName: name,
+          runtime,
+          includeExample,
+        };
+
+        const resolved = await resolveOptions(cliOptions);
+
+        console.log(`Creating Vertz app: ${resolved.projectName}`);
+        console.log(`Runtime: ${resolved.runtime}`);
+        console.log(`Include example: ${resolved.includeExample ? 'Yes' : 'No'}`);
+
+        // Create project in current directory
+        const targetDir = process.cwd();
+        await scaffold(targetDir, resolved);
+
+        console.log(`\n✓ Created ${resolved.projectName}`);
+        console.log(`\nNext steps:`);
+        console.log(`  cd ${resolved.projectName}`);
+        console.log(`  bun install`);
+        console.log(`  bun run dev`);
+      } catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    },
+  );
+
+program.parse();

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './prompts.js';
+export * from './scaffold.js';
+export * from './templates/index.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './prompts.js';
+export * from './scaffold.js';
+export * from './templates/index.js';
+export * from './types.js';

package/dist/prompts.d.ts

@@ -0,0 +1,31 @@
+import type { CliOptions, Runtime, ScaffoldOptions } from './types.js';
+/**
+ * Error thrown in CI mode when project name is required but not provided
+ */
+export declare class ProjectNameRequiredError extends Error {
+    constructor();
+}
+/**
+ * Error thrown when an invalid runtime is provided
+ */
+export declare class InvalidRuntimeError extends Error {
+    constructor(runtime: string);
+}
+/**
+ * Prompts the user for project name
+ */
+export declare function promptForProjectName(): Promise<string>;
+/**
+ * Prompts the user for runtime selection
+ */
+export declare function promptForRuntime(): Promise<Runtime>;
+/**
+ * Prompts the user for example module inclusion
+ */
+export declare function promptForExample(): Promise<boolean>;
+/**
+ * Resolves CLI options into complete scaffold options
+ * Handles both interactive and CI modes
+ */
+export declare function resolveOptions(cliOptions: Partial<CliOptions>): Promise<ScaffoldOptions>;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../src/prompts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAIvE;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;;CAKlD;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC,CAY5D;AAED;;GAEG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,OAAO,CAAC,CAiBzD;AAED;;GAEG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,OAAO,CAAC,CAkBzD;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAAC,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,CA0C9F"}

package/dist/prompts.js

@@ -0,0 +1,122 @@
+import { createInterface } from 'node:readline';
+const VALID_RUNTIMES = ['bun', 'node', 'deno'];
+/**
+ * Error thrown in CI mode when project name is required but not provided
+ */
+export class ProjectNameRequiredError extends Error {
+    constructor() {
+        super('Project name is required in CI mode. Use --name or pass as argument.');
+        this.name = 'ProjectNameRequiredError';
+    }
+}
+/**
+ * Error thrown when an invalid runtime is provided
+ */
+export class InvalidRuntimeError extends Error {
+    constructor(runtime) {
+        super(`Invalid runtime: ${runtime}. Valid options are: ${VALID_RUNTIMES.join(', ')}`);
+        this.name = 'InvalidRuntimeError';
+    }
+}
+/**
+ * Prompts the user for project name
+ */
+export async function promptForProjectName() {
+    return new Promise((resolve) => {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question('Project name: ', (answer) => {
+            rl.close();
+            resolve(answer.trim() || 'my-vertz-app');
+        });
+    });
+}
+/**
+ * Prompts the user for runtime selection
+ */
+export async function promptForRuntime() {
+    return new Promise((resolve) => {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question('Runtime (bun/node/deno) [bun]: ', (answer) => {
+            rl.close();
+            const trimmed = answer.trim().toLowerCase();
+            if (VALID_RUNTIMES.includes(trimmed)) {
+                resolve(trimmed);
+            }
+            else {
+                resolve('bun');
+            }
+        });
+    });
+}
+/**
+ * Prompts the user for example module inclusion
+ */
+export async function promptForExample() {
+    return new Promise((resolve) => {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question('Include example health module? (Y/n): ', (answer) => {
+            rl.close();
+            const trimmed = answer.trim().toLowerCase();
+            // Default to yes
+            if (trimmed === 'n' || trimmed === 'no') {
+                resolve(false);
+            }
+            else {
+                resolve(true);
+            }
+        });
+    });
+}
+/**
+ * Resolves CLI options into complete scaffold options
+ * Handles both interactive and CI modes
+ */
+export async function resolveOptions(cliOptions) {
+    const isCI = process.env.CI === 'true';
+    // Validate runtime if provided
+    if (cliOptions.runtime !== undefined && !VALID_RUNTIMES.includes(cliOptions.runtime)) {
+        throw new InvalidRuntimeError(cliOptions.runtime);
+    }
+    // Handle project name
+    let projectName = cliOptions.projectName;
+    if (!projectName) {
+        if (isCI) {
+            throw new ProjectNameRequiredError();
+        }
+        projectName = await promptForProjectName();
+    }
+    // Handle runtime
+    let runtime = cliOptions.runtime;
+    if (!runtime) {
+        if (isCI) {
+            runtime = 'bun'; // Default in CI mode
+        }
+        else {
+            runtime = await promptForRuntime();
+        }
+    }
+    // Handle example inclusion
+    let includeExample = cliOptions.includeExample;
+    if (includeExample === undefined) {
+        if (isCI) {
+            includeExample = true; // Default in CI mode
+        }
+        else {
+            includeExample = await promptForExample();
+        }
+    }
+    return {
+        projectName,
+        runtime,
+        includeExample,
+    };
+}

package/dist/scaffold.d.ts

@@ -0,0 +1,14 @@
+import type { ScaffoldOptions } from './types.js';
+/**
+ * Error thrown when the project directory already exists
+ */
+export declare class DirectoryExistsError extends Error {
+    constructor(projectName: string);
+}
+/**
+ * Scaffolds a new Vertz project
+ * @param parentDir - Parent directory where the project will be created
+ * @param options - Scaffold options
+ */
+export declare function scaffold(parentDir: string, options: ScaffoldOptions): Promise<void>;
+//# sourceMappingURL=scaffold.d.ts.map

package/dist/scaffold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../src/scaffold.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,WAAW,EAAE,MAAM;CAIhC;AAED;;;;GAIG;AACH,wBAAsB,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CA6DzF"}

package/dist/scaffold.js

@@ -0,0 +1,74 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { appTemplate, denoConfigTemplate, envExampleTemplate, envSrcTemplate, envTemplate, gitignoreTemplate, healthCheckSchemaTemplate, healthModuleDefTemplate, healthModuleTemplate, healthRouterTemplate, healthServiceTemplate, mainTemplate, packageJsonTemplate, requestIdMiddlewareTemplate, tsconfigTemplate, vertzConfigTemplate, } from './templates/index.js';
+/**
+ * Error thrown when the project directory already exists
+ */
+export class DirectoryExistsError extends Error {
+    constructor(projectName) {
+        super(`Directory "${projectName}" already exists`);
+        this.name = 'DirectoryExistsError';
+    }
+}
+/**
+ * Scaffolds a new Vertz project
+ * @param parentDir - Parent directory where the project will be created
+ * @param options - Scaffold options
+ */
+export async function scaffold(parentDir, options) {
+    const { projectName, runtime, includeExample } = options;
+    const projectDir = path.join(parentDir, projectName);
+    // Check if directory already exists
+    try {
+        await fs.access(projectDir);
+        throw new DirectoryExistsError(projectName);
+    }
+    catch (err) {
+        if (err instanceof DirectoryExistsError) {
+            throw err;
+        }
+        // Directory doesn't exist, which is what we want
+    }
+    // Create project directory
+    await fs.mkdir(projectDir, { recursive: true });
+    // Create subdirectories
+    const srcDir = path.join(projectDir, 'src');
+    const modulesDir = path.join(srcDir, 'modules');
+    const middlewaresDir = path.join(srcDir, 'middlewares');
+    await fs.mkdir(srcDir, { recursive: true });
+    await fs.mkdir(modulesDir, { recursive: true });
+    await fs.mkdir(middlewaresDir, { recursive: true });
+    // Generate and write core config files
+    await writeFile(projectDir, 'package.json', packageJsonTemplate({ projectName, runtime, includeExample }));
+    await writeFile(projectDir, 'tsconfig.json', tsconfigTemplate(runtime));
+    await writeFile(projectDir, 'vertz.config.ts', vertzConfigTemplate());
+    await writeFile(projectDir, '.env', envTemplate());
+    await writeFile(projectDir, '.env.example', envExampleTemplate());
+    await writeFile(projectDir, '.gitignore', gitignoreTemplate());
+    // Generate Deno-specific config if needed
+    if (runtime === 'deno') {
+        await writeFile(projectDir, 'deno.json', denoConfigTemplate());
+    }
+    // Generate source files
+    await writeFile(srcDir, 'env.ts', envSrcTemplate());
+    await writeFile(srcDir, 'app.ts', appTemplate());
+    await writeFile(srcDir, 'main.ts', mainTemplate());
+    await writeFile(middlewaresDir, 'request-id.middleware.ts', requestIdMiddlewareTemplate());
+    // Generate example health module if requested
+    if (includeExample) {
+        const schemasDir = path.join(modulesDir, 'schemas');
+        await fs.mkdir(schemasDir, { recursive: true });
+        await writeFile(modulesDir, 'health.module-def.ts', healthModuleDefTemplate());
+        await writeFile(modulesDir, 'health.module.ts', healthModuleTemplate());
+        await writeFile(modulesDir, 'health.service.ts', healthServiceTemplate());
+        await writeFile(modulesDir, 'health.router.ts', healthRouterTemplate());
+        await writeFile(schemasDir, 'health-check.schema.ts', healthCheckSchemaTemplate());
+    }
+}
+/**
+ * Helper to write a file with consistent formatting
+ */
+async function writeFile(dir, filename, content) {
+    const filePath = path.join(dir, filename);
+    await fs.writeFile(filePath, content, 'utf-8');
+}

package/dist/templates/__tests__/templates.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=templates.test.d.ts.map

package/dist/templates/__tests__/templates.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.test.d.ts","sourceRoot":"","sources":["../../../src/templates/__tests__/templates.test.ts"],"names":[],"mappings":""}

package/dist/templates/__tests__/templates.test.js

@@ -0,0 +1,242 @@
+import { describe, expect, it } from 'vitest';
+import { appTemplate, denoConfigTemplate, envExampleTemplate, envSrcTemplate, envTemplate, gitignoreTemplate, healthCheckSchemaTemplate, healthModuleDefTemplate, healthModuleTemplate, healthRouterTemplate, healthServiceTemplate, mainTemplate, packageJsonTemplate, requestIdMiddlewareTemplate, tsconfigTemplate, vertzConfigTemplate, } from '../index.js';
+describe('templates', () => {
+    describe('packageJsonTemplate', () => {
+        it('returns valid JSON', () => {
+            const result = packageJsonTemplate({ projectName: 'test-app', runtime: 'bun' });
+            expect(() => JSON.parse(result)).not.toThrow();
+        });
+        it('includes project name', () => {
+            const result = packageJsonTemplate({ projectName: 'my-app', runtime: 'bun' });
+            const pkg = JSON.parse(result);
+            expect(pkg.name).toBe('my-app');
+        });
+        it('includes @vertz/server dependency', () => {
+            const result = packageJsonTemplate({ projectName: 'test-app', runtime: 'bun' });
+            const pkg = JSON.parse(result);
+            expect(pkg.dependencies['@vertz/server']).toBeDefined();
+        });
+        it('includes @vertz/cli as dev dependency', () => {
+            const result = packageJsonTemplate({ projectName: 'test-app', runtime: 'bun' });
+            const pkg = JSON.parse(result);
+            expect(pkg.devDependencies['@vertz/cli']).toBeDefined();
+        });
+        it('includes required scripts', () => {
+            const result = packageJsonTemplate({ projectName: 'test-app', runtime: 'bun' });
+            const pkg = JSON.parse(result);
+            expect(pkg.scripts.dev).toBeDefined();
+            expect(pkg.scripts.build).toBeDefined();
+            expect(pkg.scripts.check).toBeDefined();
+        });
+        it('uses bun scripts for bun runtime', () => {
+            const result = packageJsonTemplate({ projectName: 'test-app', runtime: 'bun' });
+            const pkg = JSON.parse(result);
+            expect(pkg.scripts.dev).toContain('bun');
+        });
+        it('uses tsx for node runtime', () => {
+            const result = packageJsonTemplate({ projectName: 'test-app', runtime: 'node' });
+            const pkg = JSON.parse(result);
+            expect(pkg.scripts.dev).toContain('tsx');
+            expect(pkg.dependencies.tsx).toBeDefined();
+        });
+        // Tests for runtime-specific type dependencies
+        describe('runtime-specific type dependencies', () => {
+            it('adds bun-types to devDependencies for bun runtime', () => {
+                const result = packageJsonTemplate({ projectName: 'test-app', runtime: 'bun' });
+                const pkg = JSON.parse(result);
+                expect(pkg.devDependencies['bun-types']).toBeDefined();
+                expect(pkg.devDependencies['bun-types']).toMatch(/^\^1\./);
+            });
+            it('adds @types/node to devDependencies for node runtime', () => {
+                const result = packageJsonTemplate({ projectName: 'test-app', runtime: 'node' });
+                const pkg = JSON.parse(result);
+                expect(pkg.devDependencies['@types/node']).toBeDefined();
+                expect(pkg.devDependencies['@types/node']).toMatch(/^\^20\./);
+            });
+            it('does not add type packages for deno runtime', () => {
+                const result = packageJsonTemplate({ projectName: 'test-app', runtime: 'deno' });
+                const pkg = JSON.parse(result);
+                expect(pkg.devDependencies['bun-types']).toBeUndefined();
+                expect(pkg.devDependencies['@types/node']).toBeUndefined();
+            });
+        });
+    });
+    describe('tsconfigTemplate', () => {
+        it('returns valid JSON', () => {
+            const result = tsconfigTemplate('bun');
+            expect(() => JSON.parse(result)).not.toThrow();
+        });
+        it('has strict mode enabled', () => {
+            const result = tsconfigTemplate('bun');
+            const tsconfig = JSON.parse(result);
+            expect(tsconfig.compilerOptions.strict).toBe(true);
+        });
+        // Tests for runtime-specific types in tsconfig
+        describe('runtime-specific types', () => {
+            it('includes bun-types in tsconfig for bun runtime', () => {
+                const result = tsconfigTemplate('bun');
+                const tsconfig = JSON.parse(result);
+                expect(tsconfig.compilerOptions.types).toContain('bun-types');
+            });
+            it('includes node types in tsconfig for node runtime', () => {
+                const result = tsconfigTemplate('node');
+                const tsconfig = JSON.parse(result);
+                expect(tsconfig.compilerOptions.types).toContain('node');
+                expect(tsconfig.compilerOptions.types).not.toContain('bun-types');
+            });
+            it('has empty types array for deno runtime', () => {
+                const result = tsconfigTemplate('deno');
+                const tsconfig = JSON.parse(result);
+                // Deno has built-in types, so types should be empty or undefined
+                expect(tsconfig.compilerOptions.types).toEqual([]);
+            });
+        });
+    });
+    describe('vertzConfigTemplate', () => {
+        it('returns non-empty string', () => {
+            const result = vertzConfigTemplate();
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('exports a default config', () => {
+            const result = vertzConfigTemplate();
+            expect(result).toContain('export default');
+        });
+    });
+    describe('envTemplate', () => {
+        it('returns non-empty string', () => {
+            const result = envTemplate();
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('includes DATABASE_URL placeholder', () => {
+            const result = envTemplate();
+            expect(result).toContain('DATABASE_URL=');
+        });
+    });
+    describe('envExampleTemplate', () => {
+        it('returns non-empty string', () => {
+            const result = envExampleTemplate();
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('matches env template structure', () => {
+            const result = envExampleTemplate();
+            expect(result).toContain('DATABASE_URL=');
+        });
+    });
+    describe('gitignoreTemplate', () => {
+        it('returns non-empty string', () => {
+            const result = gitignoreTemplate();
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('includes node_modules', () => {
+            const result = gitignoreTemplate();
+            expect(result).toContain('node_modules');
+        });
+        it('includes dist/', () => {
+            const result = gitignoreTemplate();
+            expect(result).toContain('dist/');
+        });
+    });
+    describe('envSrcTemplate', () => {
+        it('returns non-empty string', () => {
+            const result = envSrcTemplate();
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('uses envsafe for validation', () => {
+            const result = envSrcTemplate();
+            expect(result).toContain('envsafe');
+        });
+    });
+    describe('appTemplate', () => {
+        it('returns non-empty string', () => {
+            const result = appTemplate();
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('exports createServer', () => {
+            const result = appTemplate();
+            expect(result).toContain('createServer');
+        });
+    });
+    describe('mainTemplate', () => {
+        it('returns non-empty string', () => {
+            const result = mainTemplate();
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('starts the app', () => {
+            const result = mainTemplate();
+            expect(result).toContain('app.start');
+        });
+    });
+    describe('requestIdMiddlewareTemplate', () => {
+        it('returns non-empty string', () => {
+            const result = requestIdMiddlewareTemplate();
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('handles requestId', () => {
+            const result = requestIdMiddlewareTemplate();
+            expect(result).toContain('requestId');
+        });
+    });
+    describe('health module templates', () => {
+        it('healthModuleDefTemplate returns non-empty string', () => {
+            const result = healthModuleDefTemplate();
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('healthModuleTemplate returns non-empty string', () => {
+            const result = healthModuleTemplate();
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('healthServiceTemplate returns non-empty string', () => {
+            const result = healthServiceTemplate();
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('healthRouterTemplate returns non-empty string', () => {
+            const result = healthRouterTemplate();
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('healthCheckSchemaTemplate returns non-empty string', () => {
+            const result = healthCheckSchemaTemplate();
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('templates include helpful comments for new users', () => {
+            const serviceResult = healthServiceTemplate();
+            expect(serviceResult).toContain('In a real app');
+        });
+    });
+    describe('denoConfigTemplate', () => {
+        it('returns valid JSON', () => {
+            const result = denoConfigTemplate();
+            expect(() => JSON.parse(result)).not.toThrow();
+        });
+        it('includes imports', () => {
+            const result = denoConfigTemplate();
+            const config = JSON.parse(result);
+            expect(config.imports).toBeDefined();
+        });
+    });
+    describe('all templates return non-empty strings', () => {
+        it('every template function returns a non-empty string', () => {
+            const templates = [
+                () => packageJsonTemplate({ projectName: 'test', runtime: 'bun' }),
+                () => tsconfigTemplate('bun'),
+                vertzConfigTemplate,
+                envTemplate,
+                envExampleTemplate,
+                gitignoreTemplate,
+                envSrcTemplate,
+                appTemplate,
+                mainTemplate,
+                requestIdMiddlewareTemplate,
+                healthModuleDefTemplate,
+                healthModuleTemplate,
+                healthServiceTemplate,
+                healthRouterTemplate,
+                healthCheckSchemaTemplate,
+                denoConfigTemplate,
+            ];
+            for (const template of templates) {
+                const result = template();
+                expect(result.length).toBeGreaterThan(0);
+            }
+        });
+    });
+});

package/dist/templates/index.d.ts

@@ -0,0 +1,70 @@
+import type { Runtime } from '../types.js';
+/**
+ * Package.json template
+ */
+export declare function packageJsonTemplate({ projectName, runtime, }: {
+    projectName: string;
+    runtime: Runtime;
+    includeExample?: boolean;
+}): string;
+/**
+ * Tsconfig.json template - runtime-specific types
+ */
+export declare function tsconfigTemplate(runtime: Runtime): string;
+/**
+ * vertz.config.ts template
+ */
+export declare function vertzConfigTemplate(): string;
+/**
+ * .env template
+ */
+export declare function envTemplate(): string;
+/**
+ * .env.example template
+ */
+export declare function envExampleTemplate(): string;
+/**
+ * .gitignore template
+ */
+export declare function gitignoreTemplate(): string;
+/**
+ * src/env.ts template
+ */
+export declare function envSrcTemplate(): string;
+/**
+ * src/app.ts template
+ */
+export declare function appTemplate(): string;
+/**
+ * src/main.ts template
+ */
+export declare function mainTemplate(): string;
+/**
+ * src/middlewares/request-id.middleware.ts template
+ */
+export declare function requestIdMiddlewareTemplate(): string;
+/**
+ * src/modules/health.module-def.ts template
+ */
+export declare function healthModuleDefTemplate(): string;
+/**
+ * src/modules/health.module.ts template
+ */
+export declare function healthModuleTemplate(): string;
+/**
+ * src/modules/health.service.ts template
+ */
+export declare function healthServiceTemplate(): string;
+/**
+ * src/modules/health.router.ts template
+ */
+export declare function healthRouterTemplate(): string;
+/**
+ * src/modules/schemas/health-check.schema.ts template
+ */
+export declare function healthCheckSchemaTemplate(): string;
+/**
+ * deno.json template for Deno runtime
+ */
+export declare function denoConfigTemplate(): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/templates/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/templates/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,WAAW,EACX,OAAO,GACR,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,GAAG,MAAM,CA+CT;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CA+BzD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAQ5C;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAMpC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAM3C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAgC1C;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAavC;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAWpC;AAED;;GAEG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAarC;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,CAmBpD;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAQhD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAY7C;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAkB9C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAqB7C;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,CAQlD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAgB3C"}

package/dist/templates/index.js

@@ -0,0 +1,326 @@
+/**
+ * Package.json template
+ */
+export function packageJsonTemplate({ projectName, runtime, }) {
+    const deps = {
+        '@vertz/server': '^0.1.0',
+    };
+    const devDeps = {
+        '@vertz/cli': '^0.1.0',
+        typescript: '^5.9.3',
+    };
+    // Add runtime-specific type dependencies
+    if (runtime === 'bun') {
+        devDeps['bun-types'] = '^1.0.0';
+    }
+    else if (runtime === 'node') {
+        devDeps['@types/node'] = '^20.0.0';
+    }
+    // deno: no additional types needed (built-in)
+    const scripts = {};
+    if (runtime === 'bun') {
+        scripts.dev = 'bun run src/main.ts';
+        scripts.build = 'bun run vertz:build';
+        scripts.check = 'bun run vertz:check';
+    }
+    else if (runtime === 'node') {
+        deps.tsx = '^4.19.0';
+        scripts.dev = 'tsx watch src/main.ts';
+        scripts.build = 'tsc && vertz build';
+        scripts.check = 'tsc --noEmit';
+    }
+    else if (runtime === 'deno') {
+        scripts.dev = 'deno run src/main.ts';
+        scripts.check = 'deno check src/main.ts';
+    }
+    scripts.start = 'bun run src/main.ts';
+    const pkg = {
+        name: projectName,
+        version: '0.1.0',
+        type: 'module',
+        license: 'MIT',
+        scripts,
+        dependencies: deps,
+        devDependencies: devDeps,
+    };
+    return JSON.stringify(pkg, null, 2);
+}
+/**
+ * Tsconfig.json template - runtime-specific types
+ */
+export function tsconfigTemplate(runtime) {
+    let types = [];
+    if (runtime === 'bun') {
+        types = ['bun-types'];
+    }
+    else if (runtime === 'node') {
+        types = ['node'];
+    }
+    // deno: types = [] (deno has built-in types)
+    const tsconfig = {
+        compilerOptions: {
+            target: 'ES2022',
+            module: 'ESNext',
+            lib: ['ES2022'],
+            moduleResolution: 'bundler',
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+            resolveJsonModule: true,
+            allowJs: true,
+            outDir: './dist',
+            rootDir: './src',
+            types,
+        },
+        include: ['src/**/*'],
+        exclude: ['node_modules', 'dist'],
+    };
+    return JSON.stringify(tsconfig, null, 2);
+}
+/**
+ * vertz.config.ts template
+ */
+export function vertzConfigTemplate() {
+    return `import { defineConfig } from '@vertz/server';
+
+export default defineConfig({
+  modules: [],
+  middlewares: [],
+});
+`;
+}
+/**
+ * .env template
+ */
+export function envTemplate() {
+    return `# Database connection string
+DATABASE_URL=
+
+# Add more environment variables below
+`;
+}
+/**
+ * .env.example template
+ */
+export function envExampleTemplate() {
+    return `# Database connection string (leave blank in development)
+DATABASE_URL=
+
+# Add more environment variables below
+`;
+}
+/**
+ * .gitignore template
+ */
+export function gitignoreTemplate() {
+    return `# Dependencies
+node_modules/
+.pnp/
+.pnp.js
+
+# Build outputs
+dist/
+.vertz/
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Test coverage
+coverage/
+`;
+}
+/**
+ * src/env.ts template
+ */
+export function envSrcTemplate() {
+    return `import { envsafe, str, port } from 'envsafe';
+
+export const env = envsafe({
+  DATABASE_URL: str({
+    default: '',
+    allowEmpty: true,
+  }),
+  PORT: port({
+    default: 3000,
+  }),
+});
+`;
+}
+/**
+ * src/app.ts template
+ */
+export function appTemplate() {
+    return `import { createServer } from '@vertz/server';
+
+export const app = createServer({
+  name: 'vertz-app',
+  requestId: {
+    header: 'x-request-id',
+    attribute: 'requestId',
+  },
+});
+`;
+}
+/**
+ * src/main.ts template
+ */
+export function mainTemplate() {
+    return `import { app } from './app.js';
+import { env } from './env.js';
+
+async function main() {
+  const { PORT } = env;
+  
+  await app.start({ port: PORT });
+  console.log(\`Server running at http://localhost:\${PORT}\`);
+}
+
+main();
+`;
+}
+/**
+ * src/middlewares/request-id.middleware.ts template
+ */
+export function requestIdMiddlewareTemplate() {
+    return `import type { Middleware } from '@vertz/server';
+import { randomUUID } from 'crypto';
+
+export const requestIdMiddleware: Middleware = {
+  name: 'requestId',
+  handler: async (req, context, next) => {
+    const requestId = req.headers.get('x-request-id') || randomUUID();
+    
+    context.set('requestId', requestId);
+    
+    const response = await next();
+    
+    response.headers.set('x-request-id', requestId);
+    
+    return response;
+  },
+};
+`;
+}
+/**
+ * src/modules/health.module-def.ts template
+ */
+export function healthModuleDefTemplate() {
+    return `import type { ModuleDefinition } from '@vertz/server';
+
+export const healthModuleDef = {
+  name: 'health',
+  imports: [],
+} satisfies ModuleDefinition;
+`;
+}
+/**
+ * src/modules/health.module.ts template
+ */
+export function healthModuleTemplate() {
+    return `import type { Module } from '@vertz/server';
+import { healthModuleDef } from './health.module-def.js';
+import { healthRouter } from './health.router.js';
+import { HealthService } from './health.service.js';
+
+export const healthModule = {
+  definition: healthModuleDef,
+  routers: [healthRouter],
+  services: [HealthService],
+} satisfies Module;
+`;
+}
+/**
+ * src/modules/health.service.ts template
+ */
+export function healthServiceTemplate() {
+    return `import type { Service } from '@vertz/server';
+import { HealthCheckSchema } from './schemas/health-check.schema.js';
+
+export class HealthService implements Service {
+  readonly name = 'health';
+  
+  async check() {
+    // In a real app, check database, external services, etc.
+    return {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+    };
+  }
+}
+
+export const healthService = new HealthService();
+`;
+}
+/**
+ * src/modules/health.router.ts template
+ */
+export function healthRouterTemplate() {
+    return `import type { Router } from '@vertz/server';
+import { healthService } from './health.service.js';
+
+export const healthRouter: Router = {
+  routes: {
+    'GET /health': {
+      handler: async () => {
+        const health = await healthService.check();
+        return { data: health };
+      },
+    },
+    'GET /health/ready': {
+      handler: async () => {
+        // Additional readiness check
+        return { data: { ready: true } };
+      },
+    },
+  },
+};
+`;
+}
+/**
+ * src/modules/schemas/health-check.schema.ts template
+ */
+export function healthCheckSchemaTemplate() {
+    return `import { s } from '@vertz/schema';
+
+export const HealthCheckSchema = s.object({
+  status: s.string(),
+  timestamp: s.string(),
+});
+`;
+}
+/**
+ * deno.json template for Deno runtime
+ */
+export function denoConfigTemplate() {
+    const config = {
+        imports: {
+            '@vertz/server': 'jsr:@vertz/server@^0.1.0',
+            '@vertz/schema': 'jsr:@vertz/schema@^0.1.0',
+        },
+        tasks: {
+            dev: 'deno run --watch src/main.ts',
+            check: 'deno check src/main.ts',
+        },
+        compilerOptions: {
+            strict: true,
+        },
+    };
+    return JSON.stringify(config, null, 2);
+}

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Runtime options for the scaffolded project
+ */
+export type Runtime = 'bun' | 'node' | 'deno';
+/**
+ * Options for the scaffold function
+ */
+export interface ScaffoldOptions {
+    /** Name of the project to create */
+    projectName: string;
+    /** Target runtime (bun, node, or deno) */
+    runtime: Runtime;
+    /** Whether to include example health module */
+    includeExample: boolean;
+}
+/**
+ * CLI options parsed from command line flags
+ */
+export interface CliOptions {
+    /** Project name (positional argument or --name) */
+    projectName?: string;
+    /** Target runtime */
+    runtime?: Runtime;
+    /** Whether to include example module */
+    includeExample?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,oCAAoC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,0CAA0C;IAC1C,OAAO,EAAE,OAAO,CAAC;IACjB,+CAA+C;IAC/C,cAAc,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,mDAAmD;IACnD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qBAAqB;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,wCAAwC;IACxC,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@vertz/create-vertz-app",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "MIT",
+  "description": "Create a new Vertz application",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vertz-dev/vertz.git",
+    "directory": "packages/create-vertz-app"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "bin": {
+    "create-vertz-app": "./bin/create-vertz-app.ts"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "commander": "^14.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}