@coherent.js/cli 1.0.0-beta.5 → 1.0.0-beta.6

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.js
 import { Command as Command6 } from "commander";
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { dirname as dirname3, join as join8 } from "path";
 import picocolors6 from "picocolors";
@@ -12,9 +12,10 @@ import ora from "ora";
 import picocolors from "picocolors";
 import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
 import { resolve as resolve2 } from "path";
+import { spawn } from "child_process";
 
 // src/generators/project-scaffold.js
-import { writeFileSync, mkdirSync } from "node:fs";
+import { writeFileSync, mkdirSync, copyFileSync, constants, readFileSync as readFileSync2, appendFileSync } from "node:fs";
 import { join as join2, dirname as dirname2 } from "node:path";
 import { execSync } from "node:child_process";
 
@@ -22,6 +23,7 @@ import { execSync } from "node:child_process";
 import { readFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
+import { env } from "node:process";
 var cachedVersion = null;
 function getCLIVersion() {
   if (cachedVersion) {
@@ -35,7 +37,7 @@ function getCLIVersion() {
     cachedVersion = packageJson.version;
     return cachedVersion;
   } catch {
-    cachedVersion = process.env.COHERENT_CLI_VERSION || "1.0.0-beta.3";
+    cachedVersion = env.COHERENT_CLI_VERSION || "1.0.0-beta.5";
     return cachedVersion;
   }
 }
@@ -45,7 +47,9 @@ var cliVersion = getCLIVersion();
 function generateBuiltInServer(options = {}) {
   const { port = 3e3, hasApi = false, hasDatabase = false, hasAuth = false } = options;
   const imports = [
-    `import http from 'http';`,
+    `import http from 'node:http';`,
+    `import fs from 'node:fs';`,
+    `import path from 'node:path';`,
     `import { render } from '@coherent.js/core';`
   ];
   if (hasApi) imports.push(`import { setupRoutes } from './api/routes.js';`);
@@ -79,11 +83,42 @@ ${hasApi || hasAuth ? `  // Handle API routes
     }
   }
 
-` : ""}  // Serve static files
+` : ""}  // Serve components for hydration
+  if (url.pathname.startsWith('/components/')) {
+    const filePath = path.join(process.cwd(), 'src', url.pathname);
+    try {
+      const content = await fs.promises.readFile(filePath);
+      res.writeHead(200, { 'Content-Type': 'text/javascript' });
+      return res.end(content);
+    } catch (err) {
+      res.writeHead(404);
+      return res.end('Not Found');
+    }
+  }
+
+  // Serve static files
   if (url.pathname.startsWith('/public')) {
-    // Add your static file serving logic here
-    res.writeHead(404);
-    return res.end('Not Found');
+    const filePath = path.join(process.cwd(), url.pathname);
+    try {
+      const content = await fs.promises.readFile(filePath);
+      const ext = path.extname(filePath).toLowerCase();
+      const contentTypes = {
+        '.html': 'text/html',
+        '.js': 'text/javascript',
+        '.css': 'text/css',
+        '.json': 'application/json',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.svg': 'image/svg+xml',
+        '.ico': 'image/x-icon'
+      };
+      res.writeHead(200, { 'Content-Type': contentTypes[ext] || 'application/octet-stream' });
+      return res.end(content);
+    } catch (err) {
+      res.writeHead(404);
+      return res.end('Not Found');
+    }
   }
 
   // Render page
@@ -114,23 +149,23 @@ function matchRoute(routePattern, urlPath, requestMethod, routeMethod) {
   if (requestMethod !== routeMethod) {
     return null;
   }
-  
+
   // Split paths into segments
   const routeSegments = routePattern.split('/').filter(Boolean);
   const urlSegments = urlPath.split('/').filter(Boolean);
-  
+
   // Check if lengths match
   if (routeSegments.length !== urlSegments.length) {
     return null;
   }
-  
+
   const params = {};
-  
+
   // Match each segment
   for (let i = 0; i < routeSegments.length; i++) {
     const routeSegment = routeSegments[i];
     const urlSegment = urlSegments[i];
-    
+
     // Check for parameter (e.g., :id)
     if (routeSegment.startsWith(':')) {
       const paramName = routeSegment.substring(1);
@@ -140,7 +175,7 @@ function matchRoute(routePattern, urlPath, requestMethod, routeMethod) {
       return null;
     }
   }
-  
+
   return { params };
 }
 
@@ -154,7 +189,7 @@ function generateExpressServer(options = {}) {
   const { port = 3e3, hasApi = false, hasDatabase = false, hasAuth = false } = options;
   const imports = [
     `import express from 'express';`,
-    `import { setupCoherent } from '@coherent.js/express';`
+    `import { render } from '@coherent.js/core';`
   ];
   if (hasApi) imports.push(`import apiRoutes from './api/routes.js';`);
   if (hasDatabase) imports.push(`import { initDatabase } from './db/index.js';`);
@@ -175,15 +210,25 @@ ${hasDatabase ? `// Initialize database
 await initDatabase();
 ` : ""}${hasAuth ? `// Setup authentication
 app.use(authMiddleware);
-` : ""}// Setup Coherent.js
-setupCoherent(app);
-
-${hasApi ? `// API routes
-app.use('/api', apiRoutes);
 ` : ""}
-// Main route
+${hasApi ? `// API routes - convert Coherent.js router to Express middleware
+app.use('/api', apiRoutes.toExpressRouter(express));
+` : ""}
+// Main route - render Coherent.js component to HTML
 app.get('/', (req, res) => {
-  res.render(HomePage({}));
+  const content = render(HomePage({}));
+  const html = \`<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Coherent.js App</title>
+</head>
+<body>
+  \${content}
+</body>
+</html>\`;
+  res.type('html').send(html);
 });
 
 // Error handling
@@ -232,9 +277,9 @@ await fastify.register(import('@fastify/static'), {
 ${hasApi ? `// API routes
 await fastify.register(apiRoutes, { prefix: '/api' });
 ` : ""}
-// Main route
+// Main route - return Coherent.js component (auto-rendered by plugin)
 fastify.get('/', async (request, reply) => {
-  return reply.render(HomePage({}));
+  return HomePage({});
 });
 
 // Start server
@@ -282,9 +327,9 @@ setupCoherent(app);
 ${hasApi ? `// API routes
 apiRoutes(router);
 ` : ""}
-// Main route
+// Main route - set body to Coherent.js component (auto-rendered by middleware)
 router.get('/', async (ctx) => {
-  ctx.render(HomePage({}));
+  ctx.body = HomePage({});
 });
 
 app.use(router.routes());
@@ -350,9 +395,12 @@ export const dbConfig = {
   user: process.env.DB_USER || 'postgres',
   password: process.env.DB_PASSWORD || 'postgres',
   // Connection pool settings
-  max: 20,
-  idleTimeoutMillis: 30000,
-  connectionTimeoutMillis: 2000,
+  pool: {
+    min: 2,
+    max: 20,
+    idleTimeoutMillis: 30000,
+    connectionTimeoutMillis: 2000,
+  }
 };
 `,
     mysql: `
@@ -363,9 +411,12 @@ export const dbConfig = {
   user: process.env.DB_USER || 'root',
   password: process.env.DB_PASSWORD || 'password',
   // Connection pool settings
-  connectionLimit: 10,
-  waitForConnections: true,
-  queueLimit: 0
+  pool: {
+    max: 10,
+    min: 0,
+    waitForConnections: true,
+    queueLimit: 0
+  }
 };
 `,
     sqlite: `
@@ -389,22 +440,33 @@ export const dbConfig = {
   };
   return configs[dbType] || "";
 }
-function generateDatabaseInit(dbType) {
+function generateDatabaseInit(dbType, language = "javascript") {
+  const isTypeScript = language === "typescript";
+  const typeAnnotation = isTypeScript ? ": any" : "";
+  const returnType = isTypeScript ? ": Promise<any>" : "";
   const inits = {
     postgres: `
 import { setupDatabase } from '@coherent.js/database';
 import { dbConfig } from './config.js';
 
-let db;
+let db${typeAnnotation};
 
-export async function initDatabase() {
+export async function initDatabase()${returnType} {
   try {
     // Setup database with Coherent.js
     db = setupDatabase({
-      type: 'postgres',
-      ...dbConfig
+      type: 'postgresql',
+      host: dbConfig.host,
+      port: dbConfig.port,
+      database: dbConfig.database,
+      username: dbConfig.user,
+      password: dbConfig.password,
+      pool: dbConfig.pool
     });
 
+    // Wait for connection
+    await db.connect();
+
     console.log('\u2713 Connected to PostgreSQL database');
 
     return db;
@@ -414,7 +476,7 @@ export async function initDatabase() {
   }
 }
 
-export function getDatabase() {
+export function getDatabase()${typeAnnotation} {
   if (!db) {
     throw new Error('Database not initialized. Call initDatabase() first.');
   }
@@ -434,16 +496,24 @@ process.on('SIGINT', async () => {
 import { setupDatabase } from '@coherent.js/database';
 import { dbConfig } from './config.js';
 
-let db;
+let db${typeAnnotation};
 
-export async function initDatabase() {
+export async function initDatabase()${returnType} {
   try {
     // Setup database with Coherent.js
     db = setupDatabase({
       type: 'mysql',
-      ...dbConfig
+      host: dbConfig.host,
+      port: dbConfig.port,
+      database: dbConfig.database,
+      username: dbConfig.user,
+      password: dbConfig.password,
+      pool: dbConfig.pool
     });
 
+    // Wait for connection
+    await db.connect();
+
     console.log('\u2713 Connected to MySQL database');
 
     return db;
@@ -453,7 +523,7 @@ export async function initDatabase() {
   }
 }
 
-export function getDatabase() {
+export function getDatabase()${typeAnnotation} {
   if (!db) {
     throw new Error('Database not initialized. Call initDatabase() first.');
   }
@@ -475,21 +545,24 @@ import { dbConfig } from './config.js';
 import { mkdirSync } from 'fs';
 import { dirname } from 'path';
 
-let db;
+let db${typeAnnotation};
 
-export async function initDatabase() {
+export async function initDatabase()${returnType} {
   try {
-    // Ensure directory exists
-    if (dbConfig.filename) {
+    // Ensure directory exists for SQLite file
+    if (dbConfig.filename && dbConfig.filename !== ':memory:') {
       mkdirSync(dirname(dbConfig.filename), { recursive: true });
     }
 
     // Setup database with Coherent.js
     db = setupDatabase({
       type: 'sqlite',
-      ...dbConfig
+      database: dbConfig.filename || ':memory:'
     });
 
+    // Wait for connection
+    await db.connect();
+
     console.log('\u2713 Connected to SQLite database');
 
     return db;
@@ -499,7 +572,7 @@ export async function initDatabase() {
   }
 }
 
-export function getDatabase() {
+export function getDatabase()${typeAnnotation} {
   if (!db) {
     throw new Error('Database not initialized. Call initDatabase() first.');
   }
@@ -507,9 +580,9 @@ export function getDatabase() {
 }
 
 // Graceful shutdown
-process.on('SIGINT', () => {
+process.on('SIGINT', async () => {
   if (db) {
-    db.close();
+    await db.disconnect();
     console.log('Database closed');
   }
   process.exit(0);
@@ -519,16 +592,20 @@ process.on('SIGINT', () => {
 import { setupDatabase } from '@coherent.js/database';
 import { dbConfig } from './config.js';
 
-let db;
+let db${typeAnnotation};
 
-export async function initDatabase() {
+export async function initDatabase()${returnType} {
   try {
     // Setup database with Coherent.js
     db = setupDatabase({
       type: 'mongodb',
-      ...dbConfig
+      database: dbConfig.uri,
+      ...dbConfig.options
     });
 
+    // Wait for connection
+    await db.connect();
+
     console.log('\u2713 Connected to MongoDB database');
 
     return db;
@@ -538,7 +615,7 @@ export async function initDatabase() {
   }
 }
 
-export function getDatabase() {
+export function getDatabase()${typeAnnotation} {
   if (!db) {
     throw new Error('Database not initialized. Call initDatabase() first.');
   }
@@ -557,47 +634,57 @@ process.on('SIGINT', async () => {
   };
   return inits[dbType] || "";
 }
-function generateExampleModel(dbType) {
+function generateExampleModel(dbType, language = "javascript") {
+  const isTypeScript = language === "typescript";
+  const typeAnnotation = isTypeScript ? ": Promise<any>" : "";
+  const interfaceDef = isTypeScript ? `
+interface UserData {
+  email: string;
+  name: string;
+}` : "";
   const models = {
     postgres: `
 import { getDatabase } from '../index.js';
 
+${interfaceDef}
+
 export class UserModel {
-  static async createTable() {
+  static async createTable()${typeAnnotation} {
     const db = getDatabase();
     await db.query(\`
       CREATE TABLE IF NOT EXISTS users (
         id SERIAL PRIMARY KEY,
         email VARCHAR(255) UNIQUE NOT NULL,
         name VARCHAR(255) NOT NULL,
+        password_hash VARCHAR(255),
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
         updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
       )
     \`);
   }
 
-  static async create(data) {
+  static async create(userData)${typeAnnotation} {
     const db = getDatabase();
     const result = await db.query(
       'INSERT INTO users (email, name) VALUES ($1, $2) RETURNING *',
-      [data.email, data.name]
+      [userData.email, userData.name]
     );
     return result.rows[0];
   }
 
-  static async findById(id) {
+  static async findById(id)${typeAnnotation} {
     const db = getDatabase();
     const result = await db.query('SELECT * FROM users WHERE id = $1', [id]);
     return result.rows[0];
   }
 
-  static async findByEmail(email) {
+  static async findByEmail(email)${typeAnnotation} {
     const db = getDatabase();
     const result = await db.query('SELECT * FROM users WHERE email = $1', [email]);
     return result.rows[0];
   }
 
-  static async update(id, data) {
+  static async update(id, data)${typeAnnotation} {
     const db = getDatabase();
     const result = await db.query(
       'UPDATE users SET email = $1, name = $2, updated_at = CURRENT_TIMESTAMP WHERE id = $3 RETURNING *',
@@ -606,7 +693,7 @@ export class UserModel {
     return result.rows[0];
   }
 
-  static async delete(id) {
+  static async delete(id)${typeAnnotation} {
     const db = getDatabase();
     await db.query('DELETE FROM users WHERE id = $1', [id]);
   }
@@ -615,61 +702,66 @@ export class UserModel {
     mysql: `
 import { getDatabase } from '../index.js';
 
+${interfaceDef}
+
 export class UserModel {
-  static async createTable() {
+  static async createTable()${typeAnnotation} {
     const db = getDatabase();
-    await db.execute(\`
+    await db.query(\`
       CREATE TABLE IF NOT EXISTS users (
         id INT AUTO_INCREMENT PRIMARY KEY,
         email VARCHAR(255) UNIQUE NOT NULL,
         name VARCHAR(255) NOT NULL,
+        password_hash VARCHAR(255),
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
         updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
       )
     \`);
   }
 
-  static async create(data) {
+  static async create(userData)${typeAnnotation} {
     const db = getDatabase();
-    const [result] = await db.execute(
+    const result = await db.query(
       'INSERT INTO users (email, name) VALUES (?, ?)',
-      [data.email, data.name]
+      [userData.email, userData.name]
     );
-    return { id: result.insertId, ...data };
+    return result[0];
   }
 
-  static async findById(id) {
+  static async findById(id)${typeAnnotation} {
     const db = getDatabase();
-    const [rows] = await db.execute('SELECT * FROM users WHERE id = ?', [id]);
-    return rows[0];
+    const result = await db.query('SELECT * FROM users WHERE id = ?', [id]);
+    return result[0];
   }
 
-  static async findByEmail(email) {
+  static async findByEmail(email)${typeAnnotation} {
     const db = getDatabase();
-    const [rows] = await db.execute('SELECT * FROM users WHERE email = ?', [email]);
-    return rows[0];
+    const result = await db.query('SELECT * FROM users WHERE email = ?', [email]);
+    return result[0];
   }
 
-  static async update(id, data) {
+  static async update(id, data)${typeAnnotation} {
     const db = getDatabase();
-    await db.execute(
-      'UPDATE users SET email = ?, name = ? WHERE id = ?',
+    const result = await db.query(
+      'UPDATE users SET email = ?, name = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
       [data.email, data.name, id]
     );
-    return { id, ...data };
+    return result[0];
   }
 
-  static async delete(id) {
+  static async delete(id)${typeAnnotation} {
     const db = getDatabase();
-    await db.execute('DELETE FROM users WHERE id = ?', [id]);
+    await db.query('DELETE FROM users WHERE id = ?', [id]);
   }
 }
 `,
     sqlite: `
 import { getDatabase } from '../index.js';
 
+${interfaceDef}
+
 export class UserModel {
-  static createTable() {
+  static createTable()${typeAnnotation} {
     const db = getDatabase();
     db.exec(\`
       CREATE TABLE IF NOT EXISTS users (
@@ -682,94 +774,82 @@ export class UserModel {
     \`);
   }
 
-  static create(data) {
+  static create(data)${typeAnnotation} {
     const db = getDatabase();
     const stmt = db.prepare('INSERT INTO users (email, name) VALUES (?, ?)');
     const result = stmt.run(data.email, data.name);
     return { id: result.lastInsertRowid, ...data };
   }
 
-  static findById(id) {
+  static findById(id)${typeAnnotation} {
     const db = getDatabase();
     const stmt = db.prepare('SELECT * FROM users WHERE id = ?');
     return stmt.get(id);
   }
 
-  static findByEmail(email) {
+  static findByEmail(email)${typeAnnotation} {
     const db = getDatabase();
     const stmt = db.prepare('SELECT * FROM users WHERE email = ?');
     return stmt.get(email);
   }
 
-  static update(id, data) {
+  static update(id, data)${typeAnnotation} {
     const db = getDatabase();
     const stmt = db.prepare('UPDATE users SET email = ?, name = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?');
     stmt.run(data.email, data.name, id);
-    return { id, ...data };
+    return this.findById(id);
   }
 
-  static delete(id) {
+  static delete(id)${typeAnnotation} {
     const db = getDatabase();
     const stmt = db.prepare('DELETE FROM users WHERE id = ?');
-    stmt.run(id);
+    return stmt.run(id);
   }
 }
 `,
     mongodb: `
 import { getDatabase } from '../index.js';
 
-export class UserModel {
-  static collectionName = 'users';
+${interfaceDef}
 
-  static getCollection() {
+export class UserModel {
+  static async createCollection()${typeAnnotation} {
     const db = getDatabase();
-    return db.collection(this.collectionName);
+    await db.createCollection('users');
+
+    // Create index for email uniqueness
+    await db.collection('users').createIndex({ email: 1 }, { unique: true });
   }
 
-  static async create(data) {
-    const collection = this.getCollection();
-    const result = await collection.insertOne({
-      email: data.email,
-      name: data.name,
-      createdAt: new Date(),
-      updatedAt: new Date()
-    });
-    return { _id: result.insertedId, ...data };
+  static async create(userData)${typeAnnotation} {
+    const db = getDatabase();
+    const result = await db.collection('users').insertOne(userData);
+    return { _id: result.insertedId, ...userData };
   }
 
-  static async findById(id) {
-    const collection = this.getCollection();
-    return await collection.findOne({ _id: id });
+  static async findById(id)${typeAnnotation} {
+    const db = getDatabase();
+    return await db.collection('users').findOne({ _id: id });
   }
 
-  static async findByEmail(email) {
-    const collection = this.getCollection();
-    return await collection.findOne({ email });
+  static async findByEmail(email)${typeAnnotation} {
+    const db = getDatabase();
+    return await db.collection('users').findOne({ email });
   }
 
-  static async update(id, data) {
-    const collection = this.getCollection();
-    await collection.updateOne(
+  static async update(id, data)${typeAnnotation} {
+    const db = getDatabase();
+    const result = await db.collection('users').updateOne(
       { _id: id },
-      {
-        $set: {
-          email: data.email,
-          name: data.name,
-          updatedAt: new Date()
-        }
-      }
+      { $set: { ...data, updatedAt: new Date() } }
     );
-    return { _id: id, ...data };
-  }
-
-  static async delete(id) {
-    const collection = this.getCollection();
-    await collection.deleteOne({ _id: id });
+    return result.modifiedCount > 0 ? this.findById(id) : null;
   }
 
-  static async createIndexes() {
-    const collection = this.getCollection();
-    await collection.createIndex({ email: 1 }, { unique: true });
+  static async delete(id)${typeAnnotation} {
+    const db = getDatabase();
+    const result = await db.collection('users').deleteOne({ _id: id });
+    return result.deletedCount > 0;
   }
 }
 `
@@ -822,11 +902,11 @@ function getDatabaseDependencies(dbType) {
   };
   return deps[dbType] || {};
 }
-function generateDatabaseScaffolding(dbType) {
+function generateDatabaseScaffolding(dbType, language = "javascript") {
   return {
     config: generateDatabaseConfig(dbType),
-    init: generateDatabaseInit(dbType),
-    model: generateExampleModel(dbType),
+    init: generateDatabaseInit(dbType, language),
+    model: generateExampleModel(dbType, language),
     env: generateEnvExample(dbType),
     dependencies: getDatabaseDependencies(dbType)
   };
@@ -1122,7 +1202,7 @@ function generateAuthRoutes(runtime, authType) {
   const jwtRoutes = {
     express: `
 import express from 'express';
-import { generateToken } from '../middleware/auth.js';
+import { generateToken, authMiddleware } from '../middleware/auth.js';
 import { UserModel } from '../db/models/User.js';
 
 const router = express.Router();
@@ -1522,11 +1602,7 @@ router.get('/me', authMiddleware, async (ctx) => {
   }
 });
 
-export default function registerAuthRoutes(router) {
-  router.post('/auth/register', registerHandler);
-  router.post('/auth/login', loginHandler);
-  router.get('/auth/me', authMiddleware, meHandler);
-}
+export default router;
 `
   };
   const sessionRoutes = {
@@ -1666,6 +1742,312 @@ function generateAuthScaffolding(authType, runtime) {
   };
 }
 
+// src/generators/docker-scaffold.js
+var _cliVersion = getCLIVersion();
+function generateDockerScaffolding(dbType, dockerConfig) {
+  const { port, name, user, password } = dockerConfig;
+  const dockerCompose = generateDockerCompose(dbType, port, name, user, password);
+  const dockerfile = generateDockerfile();
+  const dockerignore = generateDockerignore();
+  const envConfig = generateDockerEnvConfig(dbType, port, name, user, password);
+  return {
+    "docker-compose.yml": dockerCompose,
+    "Dockerfile": dockerfile,
+    ".dockerignore": dockerignore,
+    envConfig
+  };
+}
+function generateDockerCompose(dbType, port, dbName, dbUser, dbPassword) {
+  const configs = {
+    postgres: `version: '3.8'
+
+services:
+  postgres:
+    image: postgres:16-alpine
+    container_name: coherent-postgres
+    restart: unless-stopped
+    environment:
+      POSTGRES_DB: ${dbName}
+      POSTGRES_USER: ${dbUser}
+      POSTGRES_PASSWORD: ${dbPassword}
+    ports:
+      - "${port}:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    networks:
+      - coherent-network
+
+volumes:
+  postgres_data:
+
+networks:
+  coherent-network:
+    driver: bridge`,
+    mysql: `version: '3.8'
+
+services:
+  mysql:
+    image: mysql:8
+    container_name: coherent-mysql
+    restart: unless-stopped
+    environment:
+      MYSQL_DATABASE: ${dbName}
+      MYSQL_USER: ${dbUser}
+      MYSQL_PASSWORD: ${dbPassword}
+      MYSQL_ROOT_PASSWORD: ${dbPassword}_root
+    ports:
+      - "${port}:3306"
+    volumes:
+      - mysql_data:/var/lib/mysql
+    networks:
+      - coherent-network
+
+volumes:
+  mysql_data:
+
+networks:
+  coherent-network:
+    driver: bridge`,
+    mongodb: `version: '3.8'
+
+services:
+  mongodb:
+    image: mongo:7
+    container_name: coherent-mongodb
+    restart: unless-stopped
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: ${dbUser}
+      MONGO_INITDB_ROOT_PASSWORD: ${dbPassword}
+      MONGO_INITDB_DATABASE: ${dbName}
+    ports:
+      - "${port}:27017"
+    volumes:
+      - mongodb_data:/data/db
+    networks:
+      - coherent-network
+
+volumes:
+  mongodb_data:
+
+networks:
+  coherent-network:
+    driver: bridge`
+  };
+  return configs[dbType] || configs.postgres;
+}
+function generateDockerfile() {
+  return `# Use Node.js 18 Alpine as base image
+FROM node:18-alpine
+
+# Set working directory
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci --only=production
+
+# Copy application code
+COPY . .
+
+# Create non-root user
+RUN addgroup -g 1001 -S nodejs
+RUN adduser -S nodejs -u 1001
+
+# Change ownership of the app directory
+RUN chown -R nodejs:nodejs /app
+USER nodejs
+
+# Expose port
+EXPOSE 3000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \\
+  CMD node healthcheck.js || exit 1
+
+# Start the application
+CMD ["npm", "start"]`;
+}
+function generateDockerignore() {
+  return `# Dependencies
+node_modules
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage
+.grunt
+
+# Bower dependency directory
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons
+build/Release
+
+# Dependency directories
+jspm_packages/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+.env.test
+.env.local
+.env.production
+
+# parcel-bundler cache
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+public
+
+# Storybook build outputs
+.out
+.storybook-out
+
+# Temporary folders
+tmp/
+temp/
+
+# Logs
+logs
+*.log
+
+# Runtime data
+pids
+*.pid
+*.seed
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# Grunt intermediate storage
+.grunt
+
+# Compiled binary addons
+build/Release
+
+# Users Environment Variables
+.lock-wscript
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db`;
+}
+function generateDockerEnvConfig(dbType, port, dbName, dbUser, dbPassword) {
+  const configs = {
+    postgres: {
+      DB_HOST: "postgres",
+      DB_PORT: port,
+      DB_NAME: dbName,
+      DB_USER: dbUser,
+      DB_PASSWORD: dbPassword,
+      DATABASE_URL: `postgresql://${dbUser}:${dbPassword}@postgres:${port}/${dbName}`
+    },
+    mysql: {
+      DB_HOST: "mysql",
+      DB_PORT: port,
+      DB_NAME: dbName,
+      DB_USER: dbUser,
+      DB_PASSWORD: dbPassword,
+      DATABASE_URL: `mysql://${dbUser}:${dbPassword}@mysql:${port}/${dbName}`
+    },
+    mongodb: {
+      DB_HOST: "mongodb",
+      DB_PORT: port,
+      DB_NAME: dbName,
+      DB_USER: dbUser,
+      DB_PASSWORD: dbPassword,
+      DATABASE_URL: `mongodb://${dbUser}:${dbPassword}@mongodb:${port}/${dbName}`
+    }
+  };
+  return configs[dbType] || configs.postgres;
+}
+function generateHealthCheck() {
+  return `import http from 'http';
+
+const options = {
+  host: 'localhost',
+  port: process.env.PORT || 3000,
+  path: '/health',
+  timeout: 2000
+};
+
+const request = http.request(options, (res) => {
+  console.log(\`Health check status: \${res.statusCode}\`);
+  if (res.statusCode === 200) {
+    process.exit(0);
+  } else {
+    process.exit(1);
+  }
+});
+
+request.on('error', (err) => {
+  console.log('Health check failed:', err.message);
+  process.exit(1);
+});
+
+request.end();`;
+}
+
 // src/generators/package-scaffold.js
 var cliVersion3 = getCLIVersion();
 function generateApiScaffolding() {
@@ -1674,41 +2056,42 @@ import { createRouter } from '@coherent.js/api';
 
 const router = createRouter();
 
-// Example route with validation
+// Business Logic
+async function getUserById(id) {
+  return { id, name: 'Example User', email: 'user@example.com' };
+}
+
+async function createUser(data) {
+  return { id: 1, ...data };
+}
+
+// Router Definitions (for Express/Fastify/Koa usage)
 router.get('/users/:id', {
   params: {
     id: { type: 'number', required: true }
   },
   handler: async (req, res) => {
     const { id } = req.params;
-    // Fetch user logic here
-    return { id, name: 'Example User', email: 'user@example.com' };
+    return getUserById(id);
   }
 });
 
-// Example POST route with body validation
 router.post('/users', {
   body: {
     name: { type: 'string', required: true, minLength: 2 },
     email: { type: 'string', required: true, pattern: /^[^@]+@[^@]+\\.[^@]+$/ }
   },
   handler: async (req, res) => {
-    const { name, email } = req.body;
-    // Create user logic here
-    return { id: 1, name, email };
+    return createUser(req.body);
   }
 });
 
-// Handler for GET /api/users/:id
+// Handler for GET /api/users/:id (Built-in Server)
 export async function getUsersByIdHandler(req, res) {
   try {
-    // Extract ID from URL parameters
     const { id } = req.params;
-    
-    // Call the original handler
-    const result = await router.handle('GET', '/users/:id', { params: { id } }, {});
-    
-    // Send JSON response
+    const result = await getUserById(id);
+
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(result));
   } catch (error) {
@@ -1718,23 +2101,19 @@ export async function getUsersByIdHandler(req, res) {
   }
 }
 
-// Handler for POST /api/users
+// Handler for POST /api/users (Built-in Server)
 export async function postUsersHandler(req, res) {
   try {
-    // Parse JSON body
     let body = '';
     req.on('data', chunk => {
       body += chunk.toString();
     });
-    
+
     req.on('end', async () => {
       try {
         const parsedBody = JSON.parse(body);
-        
-        // Call the original handler
-        const result = await router.handle('POST', '/users', { body: parsedBody }, {});
-        
-        // Send JSON response
+        const result = await createUser(parsedBody);
+
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify(result));
       } catch (error) {
@@ -1789,7 +2168,7 @@ document.addEventListener('DOMContentLoaded', () => {
 
     try {
       // Dynamically import component
-      const module = await import(\`../components/\${componentName}.js\`);
+      const module = await import(\`/components/\${componentName}.js\`);
       const Component = module.default || module[componentName];
 
       // Hydrate component
@@ -2271,7 +2650,9 @@ async function scaffoldProject(projectPath, options) {
     auth = null,
     packages = [],
     language = "javascript",
-    packageManager = "npm"
+    packageManager = "npm",
+    onProgress = () => {
+    }
   } = options;
   const isTypeScript = language === "typescript";
   const fileExtension = isTypeScript ? ".ts" : ".js";
@@ -2302,8 +2683,10 @@ async function scaffoldProject(projectPath, options) {
   dirs.forEach((dir) => {
     mkdirSync(join2(projectPath, dir), { recursive: true });
   });
+  onProgress("Created project structure");
   const packageJson = generatePackageJson(name, { template, runtime, database, auth, packages, language, packageManager });
   writeFileSync(join2(projectPath, "package.json"), JSON.stringify(packageJson, null, 2));
+  onProgress("Generated package.json");
   if (isTypeScript) {
     const tsConfig = generateTsConfig();
     writeFileSync(join2(projectPath, "tsconfig.json"), JSON.stringify(tsConfig, null, 2));
@@ -2311,6 +2694,7 @@ async function scaffoldProject(projectPath, options) {
     const jsConfig = generateJsConfig();
     writeFileSync(join2(projectPath, "jsconfig.json"), JSON.stringify(jsConfig, null, 2));
   }
+  onProgress("Created configuration files");
   const serverContent = generateServerFile(runtime, {
     port: 3e3,
     hasApi: packages.includes("api") || auth,
@@ -2318,23 +2702,54 @@ async function scaffoldProject(projectPath, options) {
     hasAuth: !!auth
   });
   writeFileSync(join2(projectPath, `src/index${fileExtension}`), serverContent);
+  onProgress("Set up server");
   await generateHomePageComponent(projectPath, name, isTypeScript, fileExtension);
+  onProgress("Created components");
   if (database) {
-    const dbScaffolding = generateDatabaseScaffolding(database);
-    writeFileSync(join2(projectPath, "src/db/config.js"), dbScaffolding.config);
-    writeFileSync(join2(projectPath, "src/db/index.js"), dbScaffolding.init);
-    writeFileSync(join2(projectPath, "src/db/models/User.js"), dbScaffolding.model);
-    const existingEnv = "";
-    writeFileSync(join2(projectPath, ".env.example"), existingEnv + dbScaffolding.env);
+    const dbScaffolding = generateDatabaseScaffolding(database, language);
+    writeFileSync(join2(projectPath, `src/db/config${fileExtension}`), dbScaffolding.config);
+    writeFileSync(join2(projectPath, `src/db/index${fileExtension}`), dbScaffolding.init);
+    writeFileSync(join2(projectPath, `src/db/models/User${fileExtension}`), dbScaffolding.model);
+    if (options.dockerConfig && database !== "sqlite") {
+      const dockerScaffolding = generateDockerScaffolding(database, options.dockerConfig);
+      writeFileSync(join2(projectPath, "docker-compose.yml"), dockerScaffolding["docker-compose.yml"]);
+      writeFileSync(join2(projectPath, "Dockerfile"), dockerScaffolding["Dockerfile"]);
+      writeFileSync(join2(projectPath, ".dockerignore"), dockerScaffolding[".dockerignore"]);
+      writeFileSync(join2(projectPath, `healthcheck${fileExtension}`), generateHealthCheck());
+      let envContent = "";
+      for (const [key, value] of Object.entries(dockerScaffolding.envConfig)) {
+        envContent += `${key}=${value}
+`;
+      }
+      writeFileSync(join2(projectPath, ".env.example"), envContent);
+      onProgress("Created Docker configuration");
+    } else {
+      const existingEnv = "";
+      writeFileSync(join2(projectPath, ".env.example"), existingEnv + dbScaffolding.env);
+    }
+    try {
+      copyFileSync(join2(projectPath, ".env.example"), join2(projectPath, ".env"), constants.COPYFILE_EXCL);
+    } catch {
+    }
+    onProgress("Configured database");
   }
   if (auth) {
     const authScaffolding = generateAuthScaffolding(auth, runtime);
     const authDir = runtime === "fastify" ? "plugins" : "middleware";
-    writeFileSync(join2(projectPath, `src/${authDir}/auth.js`), authScaffolding.middleware);
-    writeFileSync(join2(projectPath, "src/api/auth.js"), authScaffolding.routes);
+    writeFileSync(join2(projectPath, `src/${authDir}/auth${fileExtension}`), authScaffolding.middleware);
+    writeFileSync(join2(projectPath, `src/api/auth${fileExtension}`), authScaffolding.routes);
     const envPath = join2(projectPath, ".env.example");
     const existingEnv = "";
     writeFileSync(envPath, existingEnv + authScaffolding.env);
+    try {
+      const envContent = readFileSync2(join2(projectPath, ".env"), "utf8");
+      if (!envContent.includes("JWT_SECRET") && !envContent.includes("SESSION_SECRET")) {
+        appendFileSync(join2(projectPath, ".env"), authScaffolding.env);
+      }
+    } catch {
+      writeFileSync(join2(projectPath, ".env"), authScaffolding.env);
+    }
+    onProgress("Set up authentication");
   }
   if (packages.length > 0) {
     const { files } = generatePackageScaffolding(packages);
@@ -2405,6 +2820,9 @@ function generatePackageJson(name, options) {
     const tsDeps = getTypeScriptDependencies();
     Object.assign(base.devDependencies, tsDeps);
     base.devDependencies.tsx = "^4.19.2";
+    if (auth) {
+      base.devDependencies["@types/jsonwebtoken"] = "^9.0.7";
+    }
   }
   if (packageManager === "pnpm") {
     base.packageManager = "pnpm@9.0.0";
@@ -2414,7 +2832,7 @@ function generatePackageJson(name, options) {
   const runtimeDeps = getRuntimeDependencies(runtime);
   Object.assign(base.dependencies, runtimeDeps);
   if (database) {
-    const { dependencies: dbDeps } = generateDatabaseScaffolding(database);
+    const { dependencies: dbDeps } = generateDatabaseScaffolding(database, language);
     Object.assign(base.dependencies, dbDeps);
   }
   if (auth) {
@@ -2744,7 +3162,15 @@ function validateComponentName(name) {
 }
 
 // src/commands/create.js
-var createCommand = new Command("create").description("Create a new Coherent.js project").argument("[name]", "project name").option("-t, --template <template>", "project template", "basic").option("--skip-install", "skip npm install").option("--skip-git", "skip git initialization").action(async (name, options) => {
+function getDefaultDockerPort(database) {
+  const ports = {
+    postgres: 5432,
+    mysql: 3306,
+    mongodb: 27017
+  };
+  return ports[database] || 5432;
+}
+var createCommand = new Command("create").description("Create a new Coherent.js project").argument("[name]", "project name").option("-t, --template <template>", "project template", "basic").option("--runtime <runtime>", "runtime framework", "koa").option("--database <database>", "database type").option("--auth <auth>", "authentication type").option("--language <language>", "language", "javascript").option("--skip-install", "skip npm install").option("--skip-git", "skip git initialization").option("--skip-prompts", "skip interactive prompts").option("--use-docker", "include Docker configuration for database").option("--docker-db-port <port>", "Docker database port").option("--docker-db-name <name>", "Docker database name").option("--docker-db-user <user>", "Docker database user").option("--docker-db-password <password>", "Docker database password").action(async (name, options) => {
   let projectName = name;
   if (!projectName) {
     const response = await prompts({
@@ -2776,48 +3202,48 @@ var createCommand = new Command("create").description("Create a new Coherent.js
   console.log(picocolors.gray("\u{1F4CD} Location:"), projectPath);
   console.log();
   let template = options.template;
-  if (!template || template === "basic") {
-    const response = await prompts({
+  if (!template || template === "basic" && !options.skipPrompts) {
+    if (!options.skipPrompts) {
+      const response = await prompts({
+        type: "select",
+        name: "template",
+        message: "Which template would you like to use?",
+        choices: [
+          { title: "\u{1F3C3}\u200D\u2642\uFE0F Basic App", value: "basic", description: "Simple SSR app with routing" },
+          { title: "\u{1F310} Full Stack", value: "fullstack", description: "API + SSR with database and auth options" }
+        ],
+        initial: 0
+      });
+      if (!response.template) {
+        console.log(picocolors.yellow("\u{1F44B} Project creation cancelled"));
+        process.exit(0);
+      }
+      template = response.template;
+    }
+  }
+  let runtime = options.runtime || "built-in";
+  let database = options.database || null;
+  let auth = options.auth || null;
+  let packages = [];
+  let language = options.language || "javascript";
+  if (!options.skipPrompts) {
+    const languageResponse = await prompts({
       type: "select",
-      name: "template",
-      message: "Which template would you like to use?",
+      name: "language",
+      message: "Would you like to use TypeScript or JavaScript?",
       choices: [
-        { title: "\u{1F3C3}\u200D\u2642\uFE0F Basic App", value: "basic", description: "Simple Coherent.js app with routing" },
-        { title: "\u{1F310} Full Stack", value: "fullstack", description: "API + SSR with database integration" },
-        { title: "\u26A1 Express Integration", value: "express", description: "Coherent.js with Express.js" },
-        { title: "\u{1F680} Fastify Integration", value: "fastify", description: "Coherent.js with Fastify" },
-        { title: "\u{1F4F1} Component Library", value: "components", description: "Reusable component library" },
-        { title: "\u{1F3A8} Custom Setup", value: "custom", description: "Choose your own runtime and packages" }
+        { title: "\u{1F4D8} JavaScript", value: "javascript", description: "JavaScript with JSDoc type hints (recommended)" },
+        { title: "\u{1F4D5} TypeScript", value: "typescript", description: "Full TypeScript with static type checking" }
       ],
       initial: 0
     });
-    if (!response.template) {
+    if (!languageResponse.language) {
       console.log(picocolors.yellow("\u{1F44B} Project creation cancelled"));
       process.exit(0);
     }
-    template = response.template;
-  }
-  let runtime = "built-in";
-  let database = null;
-  let auth = null;
-  let packages = [];
-  let language = "javascript";
-  const languageResponse = await prompts({
-    type: "select",
-    name: "language",
-    message: "Would you like to use TypeScript or JavaScript?",
-    choices: [
-      { title: "\u{1F4D8} JavaScript", value: "javascript", description: "JavaScript with JSDoc type hints (recommended)" },
-      { title: "\u{1F4D5} TypeScript", value: "typescript", description: "Full TypeScript with static type checking" }
-    ],
-    initial: 0
-  });
-  if (!languageResponse.language) {
-    console.log(picocolors.yellow("\u{1F44B} Project creation cancelled"));
-    process.exit(0);
+    language = languageResponse.language;
   }
-  language = languageResponse.language;
-  if (template === "custom" || template === "basic" || template === "fullstack" || template === "components") {
+  if ((template === "basic" || template === "fullstack") && !options.skipPrompts) {
     const runtimeResponse = await prompts({
       type: "select",
       name: "runtime",
@@ -2835,46 +3261,50 @@ var createCommand = new Command("create").description("Create a new Coherent.js
       process.exit(0);
     }
     runtime = runtimeResponse.runtime;
-  } else if (template === "express") {
-    runtime = "express";
-  } else if (template === "fastify") {
-    runtime = "fastify";
   }
-  if (template === "fullstack" || template === "custom") {
-    const dbResponse = await prompts({
-      type: "select",
-      name: "database",
-      message: "Which database would you like to use?",
-      choices: [
-        { title: "\u{1F418} PostgreSQL", value: "postgres", description: "Powerful, open source relational database" },
-        { title: "\u{1F42C} MySQL", value: "mysql", description: "Popular open source relational database" },
-        { title: "\u{1F4E6} SQLite", value: "sqlite", description: "Lightweight, file-based database" },
-        { title: "\u{1F343} MongoDB", value: "mongodb", description: "NoSQL document database" },
-        { title: "\u274C None", value: "none", description: "Skip database setup" }
-      ],
-      initial: 0
-    });
-    if (!dbResponse.database) {
-      console.log(picocolors.yellow("\u{1F44B} Project creation cancelled"));
-      process.exit(0);
+  if (template === "fullstack") {
+    if (!options.skipPrompts) {
+      const dbResponse = await prompts({
+        type: "select",
+        name: "database",
+        message: "Which database would you like to use?",
+        choices: [
+          { title: "\u{1F418} PostgreSQL", value: "postgres", description: "Powerful, open source relational database" },
+          { title: "\u{1F42C} MySQL", value: "mysql", description: "Popular open source relational database" },
+          { title: "\u{1F4E6} SQLite", value: "sqlite", description: "Lightweight, file-based database" },
+          { title: "\u{1F343} MongoDB", value: "mongodb", description: "NoSQL document database" },
+          { title: "\u274C None", value: "none", description: "Skip database setup" }
+        ],
+        initial: 0
+      });
+      if (!dbResponse.database) {
+        console.log(picocolors.yellow("\u{1F44B} Project creation cancelled"));
+        process.exit(0);
+      }
+      database = dbResponse.database === "none" ? null : dbResponse.database;
+    } else {
+      database = options.database || null;
     }
-    database = dbResponse.database === "none" ? null : dbResponse.database;
-    const pkgResponse = await prompts({
-      type: "multiselect",
-      name: "packages",
-      message: "Select optional packages (space to select, enter to confirm):",
-      choices: [
-        { title: "@coherent.js/api", value: "api", description: "API framework with validation & OpenAPI", selected: template === "fullstack" },
-        { title: "@coherent.js/client", value: "client", description: "Client-side hydration & progressive enhancement" },
-        { title: "@coherent.js/i18n", value: "i18n", description: "Internationalization utilities" },
-        { title: "@coherent.js/forms", value: "forms", description: "Form handling utilities" },
-        { title: "@coherent.js/devtools", value: "devtools", description: "Development tools & debugging" },
-        { title: "@coherent.js/seo", value: "seo", description: "SEO optimization utilities" },
-        { title: "@coherent.js/testing", value: "testing", description: "Testing utilities & helpers" }
-      ]
-    });
-    packages = pkgResponse.packages || [];
-    if (packages.includes("api") || database) {
+    if (!options.skipPrompts) {
+      const pkgResponse = await prompts({
+        type: "multiselect",
+        name: "packages",
+        message: "Select optional packages (space to select, enter to confirm):",
+        choices: [
+          { title: "@coherent.js/api", value: "api", description: "API framework with validation & OpenAPI", selected: template === "fullstack" },
+          { title: "@coherent.js/client", value: "client", description: "Client-side hydration & progressive enhancement" },
+          { title: "@coherent.js/i18n", value: "i18n", description: "Internationalization utilities" },
+          { title: "@coherent.js/forms", value: "forms", description: "Form handling utilities" },
+          { title: "@coherent.js/devtools", value: "devtools", description: "Development tools & debugging" },
+          { title: "@coherent.js/seo", value: "seo", description: "SEO optimization utilities" },
+          { title: "@coherent.js/testing", value: "testing", description: "Testing utilities & helpers" }
+        ]
+      });
+      packages = pkgResponse.packages || [];
+    } else {
+      packages = template === "fullstack" ? ["api"] : [];
+    }
+    if (!options.skipPrompts && (packages.includes("api") || database)) {
       const authResponse = await prompts({
         type: "select",
         name: "auth",
@@ -2888,7 +3318,7 @@ var createCommand = new Command("create").description("Create a new Coherent.js
       });
       auth = authResponse.auth === "none" ? null : authResponse.auth;
     }
-  } else if (template === "basic" || template === "components") {
+  } else if (template === "basic" && !options.skipPrompts) {
     const pkgResponse = await prompts({
       type: "multiselect",
       name: "packages",
@@ -2903,7 +3333,7 @@ var createCommand = new Command("create").description("Create a new Coherent.js
     packages = pkgResponse.packages || [];
   }
   let packageManager = "npm";
-  if (!options.skipInstall) {
+  if (!options.skipInstall && !options.skipPrompts) {
     const pmResponse = await prompts({
       type: "select",
       name: "packageManager",
@@ -2921,6 +3351,56 @@ var createCommand = new Command("create").description("Create a new Coherent.js
     }
     packageManager = pmResponse.packageManager;
   }
+  let dockerConfig = null;
+  if (database && database !== "sqlite" && !options.skipPrompts) {
+    const dockerResponse = await prompts({
+      type: "confirm",
+      name: "useDocker",
+      message: "Would you like to include Docker configuration for the database?",
+      initial: true
+    });
+    if (dockerResponse.useDocker) {
+      const dockerDetailsResponse = await prompts([
+        {
+          type: "number",
+          name: "dbPort",
+          message: "What port should the database use?",
+          initial: getDefaultDockerPort(database)
+        },
+        {
+          type: "text",
+          name: "dbName",
+          message: "What should the database be named?",
+          initial: "coherent_db"
+        },
+        {
+          type: "text",
+          name: "dbUser",
+          message: "What should the database user be?",
+          initial: "coherent_user"
+        },
+        {
+          type: "text",
+          name: "dbPassword",
+          message: "What should the database password be?",
+          initial: "coherent_pass"
+        }
+      ]);
+      dockerConfig = {
+        port: dockerDetailsResponse.dbPort || getDefaultDockerPort(database),
+        name: dockerDetailsResponse.dbName,
+        user: dockerDetailsResponse.dbUser,
+        password: dockerDetailsResponse.dbPassword
+      };
+    }
+  } else if (database && database !== "sqlite" && options.useDocker) {
+    dockerConfig = {
+      port: options.dockerDbPort || getDefaultDockerPort(database),
+      name: options.dockerDbName || "coherent_db",
+      user: options.dockerDbUser || "coherent_user",
+      password: options.dockerDbPassword || "coherent_pass"
+    };
+  }
   const spinner = ora("Scaffolding project...").start();
   try {
     mkdirSync2(projectPath, { recursive: true });
@@ -2933,30 +3413,77 @@ var createCommand = new Command("create").description("Create a new Coherent.js
       packages,
       language,
       packageManager,
+      dockerConfig,
       skipInstall: options.skipInstall,
-      skipGit: options.skipGit
+      skipGit: options.skipGit,
+      onProgress: (msg) => {
+        spinner.text = msg;
+      }
     });
     spinner.succeed("Project created successfully!");
     console.log();
-    console.log(picocolors.green("\u2705 Project created successfully!"));
+    console.log(picocolors.green("Project created successfully!"));
     console.log();
-    console.log(picocolors.cyan("\u{1F4CB} Project Configuration:"));
-    console.log(picocolors.gray("  Language:"), picocolors.bold(language === "typescript" ? "TypeScript" : "JavaScript"));
-    console.log(picocolors.gray("  Runtime:"), picocolors.bold(runtime));
+    console.log(picocolors.cyan("Configuration:"));
+    console.log(picocolors.gray("  Template:"), picocolors.white(template === "fullstack" ? "Full Stack" : "Basic"));
+    console.log(picocolors.gray("  Language:"), picocolors.white(language === "typescript" ? "TypeScript" : "JavaScript"));
+    console.log(picocolors.gray("  Runtime:"), picocolors.white(runtime));
     if (database) {
-      console.log(picocolors.gray("  Database:"), picocolors.bold(database));
+      console.log(picocolors.gray("  Database:"), picocolors.white(database));
     }
     if (auth) {
-      console.log(picocolors.gray("  Authentication:"), picocolors.bold(auth.toUpperCase()));
+      console.log(picocolors.gray("  Auth:"), picocolors.white(auth.toUpperCase()));
     }
     if (packages.length > 0) {
-      console.log(picocolors.gray("  Packages:"), picocolors.bold(packages.join(", ")));
+      const formattedPackages = packages.map((p) => `@coherent.js/${p}`).join(", ");
+      console.log(picocolors.gray("  Packages:"), picocolors.white(formattedPackages));
     }
     console.log();
-    console.log(picocolors.cyan("Next steps:"));
-    console.log(picocolors.gray("  cd"), picocolors.bold(projectName));
+    const fileExt = language === "typescript" ? ".ts" : ".js";
+    console.log(picocolors.cyan("Project structure:"));
+    console.log(picocolors.white(`  ${projectName}/`));
+    console.log(picocolors.gray(`    src/`));
+    console.log(picocolors.gray(`      index${fileExt}`));
+    console.log(picocolors.gray(`      components/`));
+    if (database) {
+      console.log(picocolors.gray(`      db/`));
+    }
+    if (auth || packages.includes("api")) {
+      console.log(picocolors.gray(`      api/`));
+    }
+    console.log(picocolors.gray(`    public/`));
+    console.log(picocolors.gray(`    package.json`));
     if (database) {
-      console.log(picocolors.gray("  # Configure database in .env.example"));
+      console.log(picocolors.gray(`    .env.example`), picocolors.yellow("<-- Configure this!"));
+    }
+    console.log();
+    const needsEnvConfig = database && database !== "sqlite";
+    const envVars = [];
+    if (needsEnvConfig) {
+      if (database === "mongodb") {
+        envVars.push("MONGODB_URI");
+      } else {
+        envVars.push("DB_HOST", "DB_PORT", "DB_NAME", "DB_USER", "DB_PASSWORD");
+      }
+    }
+    if (auth === "jwt") {
+      envVars.push("JWT_SECRET");
+    }
+    if (auth === "session") {
+      envVars.push("SESSION_SECRET");
+    }
+    if (envVars.length > 0) {
+      console.log(picocolors.yellow("Environment variables to configure:"));
+      envVars.forEach((v) => console.log(picocolors.gray(`  ${v}`)));
+      console.log();
+    }
+    console.log(picocolors.cyan("Next steps:"));
+    let stepNum = 1;
+    console.log(picocolors.white(`  ${stepNum}.`), picocolors.gray(`cd ${projectName}`));
+    stepNum++;
+    if (needsEnvConfig) {
+      console.log(picocolors.white(`  ${stepNum}.`), picocolors.gray("Edit .env with your database credentials"));
+      stepNum++;
     }
     const pmCommands = {
       npm: { install: "npm install", dev: "npm run dev" },
@@ -2964,14 +3491,41 @@ var createCommand = new Command("create").description("Create a new Coherent.js
       pnpm: { install: "pnpm install", dev: "pnpm dev" }
     };
     const commands = pmCommands[packageManager] || pmCommands.npm;
-    if (!options.skipInstall) {
-      console.log(picocolors.gray(`  ${commands.dev}`));
-    } else {
-      console.log(picocolors.gray(`  ${commands.install}`));
-      console.log(picocolors.gray(`  ${commands.dev}`));
+    if (options.skipInstall) {
+      console.log(picocolors.white(`  ${stepNum}.`), picocolors.gray(commands.install));
+      stepNum++;
     }
+    console.log(picocolors.white(`  ${stepNum}.`), picocolors.gray(commands.dev));
     console.log();
-    console.log(picocolors.gray("Happy coding! \u{1F389}"));
+    if (!options.skipPrompts && !options.skipInstall) {
+      const startResponse = await prompts({
+        type: "confirm",
+        name: "startDev",
+        message: "Start development server now?",
+        initial: true
+      });
+      if (startResponse.startDev) {
+        console.log();
+        console.log(picocolors.cyan("Starting development server..."));
+        console.log(picocolors.gray(`  ${commands.dev}`));
+        console.log();
+        try {
+          const devProcess = spawn(commands.dev, [], {
+            cwd: projectPath,
+            stdio: "inherit",
+            shell: true,
+            detached: true
+          });
+          devProcess.unref();
+          return;
+        } catch {
+          console.log(picocolors.yellow("Could not start development server automatically."));
+          console.log(picocolors.gray(`  Run manually: cd ${projectName} && ${commands.dev}`));
+          console.log();
+        }
+      }
+    }
+    console.log(picocolors.gray("Happy coding!"));
   } catch (_error) {
     spinner.fail("Failed to create project");
     console.error(picocolors.red("\u274C Error:"), _error.message);
@@ -4579,7 +5133,7 @@ import { Command as Command3 } from "commander";
 import ora3 from "ora";
 import picocolors3 from "picocolors";
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
 import { join as join6 } from "path";
 var buildCommand = new Command3("build").description("Build the project for production").option("-w, --watch", "watch for changes").option("--analyze", "analyze bundle size").option("--no-minify", "disable minification").option("--no-optimize", "disable optimizations").action(async (options) => {
   console.log(picocolors3.cyan("\u{1F3D7}\uFE0F  Building Coherent.js project..."));
@@ -4591,7 +5145,7 @@ var buildCommand = new Command3("build").description("Build the project for prod
   }
   let packageJson;
   try {
-    packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
   } catch {
     console.error(picocolors3.red("\u274C Failed to read package.json"));
     process.exit(1);
@@ -4685,8 +5239,8 @@ var buildCommand = new Command3("build").description("Build the project for prod
 import { Command as Command4 } from "commander";
 import ora4 from "ora";
 import picocolors4 from "picocolors";
-import { spawn } from "child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync3 } from "fs";
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
 import { join as join7 } from "path";
 var devCommand = new Command4("dev").description("Start development server with hot reload").option("-p, --port <port>", "port number", "3000").option("-h, --host <host>", "host address", "localhost").option("--open", "open browser automatically").option("--no-hmr", "disable hot module replacement").action(async (options) => {
   console.log(picocolors4.cyan("\u{1F680} Starting Coherent.js development server..."));
@@ -4698,7 +5252,7 @@ var devCommand = new Command4("dev").description("Start development server with
   }
   let packageJson;
   try {
-    packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+    packageJson = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
   } catch {
     console.error(picocolors4.red("\u274C Failed to read package.json"));
     process.exit(1);
@@ -4708,7 +5262,7 @@ var devCommand = new Command4("dev").description("Start development server with
     let devProcess;
     if (packageJson.scripts && packageJson.scripts.dev) {
       spinner.text = "Running dev script...";
-      devProcess = spawn("npm", ["run", "dev"], {
+      devProcess = spawn2("npm", ["run", "dev"], {
         stdio: "inherit",
         cwd: process.cwd(),
         shell: true,
@@ -4721,19 +5275,19 @@ var devCommand = new Command4("dev").description("Start development server with
     } else {
       spinner.text = "Starting default dev server...";
       if (existsSync7("vite.config.js") || existsSync7("vite.config.ts")) {
-        devProcess = spawn("npx", ["vite", "--port", options.port, "--host", options.host], {
+        devProcess = spawn2("npx", ["vite", "--port", options.port, "--host", options.host], {
           stdio: "inherit",
           cwd: process.cwd(),
           shell: true
         });
       } else if (existsSync7("webpack.config.js")) {
-        devProcess = spawn("npx", ["webpack", "serve", "--port", options.port, "--host", options.host], {
+        devProcess = spawn2("npx", ["webpack", "serve", "--port", options.port, "--host", options.host], {
           stdio: "inherit",
           cwd: process.cwd(),
           shell: true
         });
       } else if (packageJson.type === "module" || existsSync7("src/index.js")) {
-        devProcess = spawn("npx", ["nodemon", "src/index.js"], {
+        devProcess = spawn2("npx", ["nodemon", "src/index.js"], {
           stdio: "inherit",
           cwd: process.cwd(),
           shell: true,
@@ -4798,11 +5352,12 @@ import { Command as Command5 } from "commander";
 import prompts3 from "prompts";
 import ora5 from "ora";
 import picocolors5 from "picocolors";
-import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
+import process2, { env as env2 } from "node:process";
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
 import { resolve as resolve5 } from "path";
 
 // src/analyzers/component-analyzer.js
-import { readFileSync as readFileSync4, existsSync as existsSync8 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync8 } from "fs";
 import { resolve as resolve3 } from "path";
 
 // ../../node_modules/.pnpm/@isaacs+balanced-match@4.0.1/node_modules/@isaacs/balanced-match/dist/esm/index.js
@@ -5693,7 +6248,7 @@ var path = {
 };
 var sep = defaultPlatform === "win32" ? path.win32.sep : path.posix.sep;
 minimatch.sep = sep;
-var GLOBSTAR = Symbol("globstar **");
+var GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
 var qmark2 = "[^/]";
 var star2 = qmark2 + "*?";
@@ -6404,7 +6959,6 @@ if (typeof AC === "undefined") {
   };
 }
 var shouldWarn = (code) => !warned.has(code);
-var TYPE = Symbol("type");
 var isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
 var getUintArray = (max) => !isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
 var ZeroArray = class extends Array {
@@ -7780,37 +8334,37 @@ var isStream = (s) => !!s && typeof s === "object" && (s instanceof Minipass ||
 var isReadable = (s) => !!s && typeof s === "object" && s instanceof EventEmitter && typeof s.pipe === "function" && // node core Writable streams have a pipe() method, but it throws
 s.pipe !== Stream.Writable.prototype.pipe;
 var isWritable = (s) => !!s && typeof s === "object" && s instanceof EventEmitter && typeof s.write === "function" && typeof s.end === "function";
-var EOF = Symbol("EOF");
-var MAYBE_EMIT_END = Symbol("maybeEmitEnd");
-var EMITTED_END = Symbol("emittedEnd");
-var EMITTING_END = Symbol("emittingEnd");
-var EMITTED_ERROR = Symbol("emittedError");
-var CLOSED = Symbol("closed");
-var READ = Symbol("read");
-var FLUSH = Symbol("flush");
-var FLUSHCHUNK = Symbol("flushChunk");
-var ENCODING = Symbol("encoding");
-var DECODER = Symbol("decoder");
-var FLOWING = Symbol("flowing");
-var PAUSED = Symbol("paused");
-var RESUME = Symbol("resume");
-var BUFFER = Symbol("buffer");
-var PIPES = Symbol("pipes");
-var BUFFERLENGTH = Symbol("bufferLength");
-var BUFFERPUSH = Symbol("bufferPush");
-var BUFFERSHIFT = Symbol("bufferShift");
-var OBJECTMODE = Symbol("objectMode");
-var DESTROYED = Symbol("destroyed");
-var ERROR = Symbol("error");
-var EMITDATA = Symbol("emitData");
-var EMITEND = Symbol("emitEnd");
-var EMITEND2 = Symbol("emitEnd2");
-var ASYNC = Symbol("async");
-var ABORT = Symbol("abort");
-var ABORTED = Symbol("aborted");
-var SIGNAL = Symbol("signal");
-var DATALISTENERS = Symbol("dataListeners");
-var DISCARDED = Symbol("discarded");
+var EOF = /* @__PURE__ */ Symbol("EOF");
+var MAYBE_EMIT_END = /* @__PURE__ */ Symbol("maybeEmitEnd");
+var EMITTED_END = /* @__PURE__ */ Symbol("emittedEnd");
+var EMITTING_END = /* @__PURE__ */ Symbol("emittingEnd");
+var EMITTED_ERROR = /* @__PURE__ */ Symbol("emittedError");
+var CLOSED = /* @__PURE__ */ Symbol("closed");
+var READ = /* @__PURE__ */ Symbol("read");
+var FLUSH = /* @__PURE__ */ Symbol("flush");
+var FLUSHCHUNK = /* @__PURE__ */ Symbol("flushChunk");
+var ENCODING = /* @__PURE__ */ Symbol("encoding");
+var DECODER = /* @__PURE__ */ Symbol("decoder");
+var FLOWING = /* @__PURE__ */ Symbol("flowing");
+var PAUSED = /* @__PURE__ */ Symbol("paused");
+var RESUME = /* @__PURE__ */ Symbol("resume");
+var BUFFER = /* @__PURE__ */ Symbol("buffer");
+var PIPES = /* @__PURE__ */ Symbol("pipes");
+var BUFFERLENGTH = /* @__PURE__ */ Symbol("bufferLength");
+var BUFFERPUSH = /* @__PURE__ */ Symbol("bufferPush");
+var BUFFERSHIFT = /* @__PURE__ */ Symbol("bufferShift");
+var OBJECTMODE = /* @__PURE__ */ Symbol("objectMode");
+var DESTROYED = /* @__PURE__ */ Symbol("destroyed");
+var ERROR = /* @__PURE__ */ Symbol("error");
+var EMITDATA = /* @__PURE__ */ Symbol("emitData");
+var EMITEND = /* @__PURE__ */ Symbol("emitEnd");
+var EMITEND2 = /* @__PURE__ */ Symbol("emitEnd2");
+var ASYNC = /* @__PURE__ */ Symbol("async");
+var ABORT = /* @__PURE__ */ Symbol("abort");
+var ABORTED = /* @__PURE__ */ Symbol("aborted");
+var SIGNAL = /* @__PURE__ */ Symbol("signal");
+var DATALISTENERS = /* @__PURE__ */ Symbol("dataListeners");
+var DISCARDED = /* @__PURE__ */ Symbol("discarded");
 var defer = (fn) => Promise.resolve().then(fn);
 var nodefer = (fn) => fn();
 var isEndish = (ev) => ev === "end" || ev === "finish" || ev === "prefinish";
@@ -8723,7 +9277,7 @@ var ChildrenCache = class extends LRUCache {
     });
   }
 };
-var setAsCwd = Symbol("PathScurry setAsCwd");
+var setAsCwd = /* @__PURE__ */ Symbol("PathScurry setAsCwd");
 var PathBase = class {
   /**
    * the basename of this path
@@ -10190,7 +10744,7 @@ var PathScurryBase = class {
     const dirs = /* @__PURE__ */ new Set();
     const queue = [entry];
     let processing = 0;
-    const process2 = () => {
+    const process3 = () => {
       let paused = false;
       while (!paused) {
         const dir = queue.shift();
@@ -10231,9 +10785,9 @@ var PathScurryBase = class {
             }
           }
           if (paused && !results.flowing) {
-            results.once("drain", process2);
+            results.once("drain", process3);
           } else if (!sync2) {
-            process2();
+            process3();
           }
         };
         let sync2 = true;
@@ -10241,7 +10795,7 @@ var PathScurryBase = class {
         sync2 = false;
       }
     };
-    process2();
+    process3();
     return results;
   }
   streamSync(entry = this.cwd, opts = {}) {
@@ -10259,7 +10813,7 @@ var PathScurryBase = class {
     }
     const queue = [entry];
     let processing = 0;
-    const process2 = () => {
+    const process3 = () => {
       let paused = false;
       while (!paused) {
         const dir = queue.shift();
@@ -10293,9 +10847,9 @@ var PathScurryBase = class {
         }
       }
       if (paused && !results.flowing)
-        results.once("drain", process2);
+        results.once("drain", process3);
     };
-    process2();
+    process3();
     return results;
   }
   chdir(path2 = this.cwd) {
@@ -11548,7 +12102,7 @@ async function analyzeComponentFile(filePath, _options = {}) {
       });
       return analysis;
     }
-    const content = readFileSync4(resolve3(filePath), "utf-8");
+    const content = readFileSync5(resolve3(filePath), "utf-8");
     analysis.size = Buffer.byteLength(content, "utf8");
     analysis.lines = content.split("\n").length;
     const syntaxAnalysis = analyzeSyntax(content, filePath);
@@ -11909,7 +12463,7 @@ async function analyzeHydration(options = {}) {
 }
 
 // src/validators/project-validator.js
-import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
 import { resolve as resolve4 } from "path";
 async function validateProject(_options = {}) {
   const validation = {
@@ -11976,7 +12530,7 @@ function validatePackageJson() {
   const issues = [];
   const recommendations = [];
   try {
-    const packageJson = JSON.parse(readFileSync5("package.json", "utf-8"));
+    const packageJson = JSON.parse(readFileSync6("package.json", "utf-8"));
     const requiredFields = ["name", "version", "description"];
     requiredFields.forEach((field) => {
       const hasField = packageJson[field];
@@ -12132,7 +12686,7 @@ var debugCommand = new Command5("debug").description("Debug and analyze Coherent
     });
     if (!response.target) {
       console.log(picocolors5.yellow("\u{1F44B} Debug cancelled"));
-      process.exit(0);
+      process2.exit(0);
     }
     debugTarget = response.target;
   }
@@ -12174,14 +12728,14 @@ var debugCommand = new Command5("debug").description("Debug and analyze Coherent
     console.log();
     console.log(picocolors5.red("\u274C Debug Error:"));
     console.log(picocolors5.gray(`  ${error.message}`));
-    if (process.env.DEBUG) {
+    if (env2.DEBUG) {
       console.log();
       console.log(picocolors5.gray("Stack trace:"));
       console.log(picocolors5.gray(error.stack));
     } else {
       console.log(picocolors5.gray("  Run with DEBUG=1 for detailed error information"));
     }
-    process.exit(1);
+    process2.exit(1);
   }
 });
 debugCommand.command("component [name]").description("Analyze component structure and performance").option("-f, --file <file>", "component file path").option("--props <props>", "test component with specific props (JSON)").option("--deep", "perform deep structural analysis").action(async (name, options) => {
@@ -12260,7 +12814,7 @@ async function analyzeConfiguration(_options = {}) {
   };
   if (existsSync10("package.json")) {
     try {
-      const packageJson = JSON.parse(readFileSync6("package.json", "utf-8"));
+      const packageJson = JSON.parse(readFileSync7("package.json", "utf-8"));
       const hasCoherentDeps = Object.keys(packageJson.dependencies || {}).some((dep) => dep.startsWith("@coherent.js/"));
       if (!hasCoherentDeps) {
         analysis.summary.issues.push("No Coherent.js dependencies found");
@@ -12369,12 +12923,12 @@ async function generateHTMLReport(result) {
         <h1>\u{1F50D} Coherent.js Debug Report</h1>
         <p>Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}</p>
       </div>
-      
+
       <div class="section">
         <h2>Summary</h2>
         <pre>${JSON.stringify(result.summary, null, 2)}</pre>
       </div>
-      
+
       ${result.issues ? `
       <div class="section">
         <h2>Issues</h2>
@@ -12383,7 +12937,7 @@ async function generateHTMLReport(result) {
         `).join("")}
       </div>
       ` : ""}
-      
+
       ${result.recommendations ? `
       <div class="section">
         <h2>Recommendations</h2>
@@ -12409,7 +12963,7 @@ var __dirname = dirname3(__filename);
 var version = "1.0.1";
 try {
   const packagePath = join8(__dirname, "..", "package.json");
-  const packageJson = JSON.parse(readFileSync7(packagePath, "utf-8"));
+  const packageJson = JSON.parse(readFileSync8(packagePath, "utf-8"));
   version = packageJson.version;
 } catch {
 }