@kozojs/cli 0.1.4

package/lib/index.js

@@ -0,0 +1,1210 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander = require("commander");
+
+// src/commands/new.ts
+var p = __toESM(require("@clack/prompts"));
+var import_picocolors2 = __toESM(require("picocolors"));
+var import_execa = require("execa");
+
+// src/utils/scaffold.ts
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_node_path = __toESM(require("path"));
+async function scaffoldProject(options) {
+  const { projectName, database, packageSource, template } = options;
+  const projectDir = import_node_path.default.resolve(process.cwd(), projectName);
+  const kozoCoreDep = packageSource === "local" ? "workspace:*" : "^0.1.0";
+  if (template === "complete") {
+    await scaffoldCompleteTemplate(projectDir, projectName, kozoCoreDep);
+    return;
+  }
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "src", "routes"));
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "src", "db"));
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "src", "services"));
+  const packageJson = {
+    name: projectName,
+    version: "0.1.0",
+    type: "module",
+    scripts: {
+      dev: "tsx watch src/index.ts",
+      build: "tsc",
+      start: "node dist/index.js",
+      "db:generate": "drizzle-kit generate",
+      "db:push": "drizzle-kit push",
+      "db:studio": "drizzle-kit studio"
+    },
+    dependencies: {
+      "@kozojs/core": kozoCoreDep,
+      hono: "^4.6.0",
+      zod: "^3.23.0",
+      "drizzle-orm": "^0.36.0",
+      ...database === "postgresql" && { postgres: "^3.4.0" },
+      ...database === "mysql" && { mysql2: "^3.11.0" },
+      ...database === "sqlite" && { "better-sqlite3": "^11.0.0" }
+    },
+    devDependencies: {
+      "@types/node": "^22.0.0",
+      tsx: "^4.19.0",
+      typescript: "^5.6.0",
+      "drizzle-kit": "^0.28.0",
+      ...database === "sqlite" && { "@types/better-sqlite3": "^7.6.0" }
+    }
+  };
+  await import_fs_extra.default.writeJSON(import_node_path.default.join(projectDir, "package.json"), packageJson, { spaces: 2 });
+  const tsconfig = {
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      outDir: "dist",
+      rootDir: "src",
+      declaration: true
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  };
+  await import_fs_extra.default.writeJSON(import_node_path.default.join(projectDir, "tsconfig.json"), tsconfig, { spaces: 2 });
+  const drizzleConfig = `import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+  schema: './src/db/schema.ts',
+  out: './drizzle',
+  dialect: '${database === "postgresql" ? "postgresql" : database === "mysql" ? "mysql" : "sqlite"}',
+  dbCredentials: {
+    ${database === "sqlite" ? "url: './data.db'" : "url: process.env.DATABASE_URL!"}
+  }
+});
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "drizzle.config.ts"), drizzleConfig);
+  const envExample = `# Database
+${database === "sqlite" ? "# SQLite uses local file, no URL needed" : "DATABASE_URL="}
+
+# Server
+PORT=3000
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, ".env.example"), envExample);
+  const gitignore = `node_modules/
+dist/
+.env
+*.db
+.turbo/
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, ".gitignore"), gitignore);
+  const indexTs = `import { createKozo } from '@kozojs/core';
+import { services } from './services/index.js';
+
+const app = createKozo({
+  services,
+  port: Number(process.env.PORT) || 3000,
+  openapi: {
+    info: {
+      title: '${projectName} API',
+      version: '1.0.0',
+      description: 'API documentation for ${projectName}'
+    },
+    servers: [
+      {
+        url: 'http://localhost:3000',
+        description: 'Development server'
+      }
+    ]
+  }
+});
+
+app.listen();
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "index.ts"), indexTs);
+  const servicesTs = `import { db } from '../db/index.js';
+
+export const services = {
+  db
+};
+
+// Type augmentation for autocomplete
+declare module '@kozojs/core' {
+  interface Services {
+    db: typeof db;
+  }
+}
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "services", "index.ts"), servicesTs);
+  const schemaTs = getDatabaseSchema(database);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "db", "schema.ts"), schemaTs);
+  const dbIndexTs = getDatabaseIndex(database);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "db", "index.ts"), dbIndexTs);
+  if (database === "sqlite") {
+    const seedTs = getSQLiteSeed();
+    await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "db", "seed.ts"), seedTs);
+  }
+  await createExampleRoutes(projectDir);
+  const readme = `# ${projectName}
+
+Built with \u{1F525} **Kozo Framework**
+
+## Getting Started
+
+\`\`\`bash
+# Install dependencies
+pnpm install
+
+# Start development server
+pnpm dev
+\`\`\`
+
+The server will start at http://localhost:3000
+
+## Try the API
+
+\`\`\`bash
+# Get all users
+curl http://localhost:3000/users
+
+# Create a new user
+curl -X POST http://localhost:3000/users \\
+  -H "Content-Type: application/json" \\
+  -d '{"name":"Alice","email":"alice@example.com"}'
+
+# Health check
+curl http://localhost:3000
+
+# Open Swagger UI
+open http://localhost:3000/swagger
+\`\`\`
+
+## API Documentation
+
+Once the server is running, visit:
+- **Swagger UI**: http://localhost:3000/swagger
+- **OpenAPI JSON**: http://localhost:3000/doc
+
+## Project Structure
+
+\`\`\`
+src/
+\u251C\u2500\u2500 db/
+\u2502   \u251C\u2500\u2500 schema.ts    # Drizzle schema
+\u2502   \u251C\u2500\u2500 seed.ts      # Database initialization${database === "sqlite" ? " (SQLite)" : ""}
+\u2502   \u2514\u2500\u2500 index.ts     # Database client
+\u251C\u2500\u2500 routes/
+\u2502   \u251C\u2500\u2500 index.ts     # GET /
+\u2502   \u2514\u2500\u2500 users/
+\u2502       \u251C\u2500\u2500 get.ts   # GET /users
+\u2502       \u2514\u2500\u2500 post.ts  # POST /users
+\u251C\u2500\u2500 services/
+\u2502   \u2514\u2500\u2500 index.ts     # Service definitions
+\u2514\u2500\u2500 index.ts         # Entry point
+\`\`\`
+
+## Database Commands
+
+\`\`\`bash
+pnpm db:generate  # Generate migrations
+pnpm db:push      # Push schema to database
+pnpm db:studio    # Open Drizzle Studio
+\`\`\`
+
+${database === "sqlite" ? "## SQLite Notes\n\nThe database is automatically initialized with example data on first run.\nDatabase file: `./data.db`\n" : ""}
+## Documentation
+
+- [Kozo Docs](https://kozo.dev/docs)
+- [Drizzle ORM](https://orm.drizzle.team)
+- [Hono](https://hono.dev)
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "README.md"), readme);
+}
+function getDatabaseSchema(database) {
+  if (database === "postgresql") {
+    return `import { pgTable, uuid, varchar, timestamp } from 'drizzle-orm/pg-core';
+
+export const users = pgTable('users', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  name: varchar('name', { length: 255 }).notNull(),
+  email: varchar('email', { length: 255 }).unique().notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull()
+});
+`;
+  }
+  if (database === "mysql") {
+    return `import { mysqlTable, varchar, timestamp } from 'drizzle-orm/mysql-core';
+
+export const users = mysqlTable('users', {
+  id: varchar('id', { length: 36 }).primaryKey(),
+  name: varchar('name', { length: 255 }).notNull(),
+  email: varchar('email', { length: 255 }).unique().notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull()
+});
+`;
+  }
+  return `import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
+
+export const users = sqliteTable('users', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  name: text('name').notNull(),
+  email: text('email').unique().notNull(),
+  createdAt: integer('created_at', { mode: 'timestamp' }).$defaultFn(() => new Date())
+});
+`;
+}
+function getDatabaseIndex(database) {
+  if (database === "postgresql") {
+    return `import { drizzle } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
+import * as schema from './schema.js';
+
+const client = postgres(process.env.DATABASE_URL!);
+export const db = drizzle(client, { schema });
+`;
+  }
+  if (database === "mysql") {
+    return `import { drizzle } from 'drizzle-orm/mysql2';
+import mysql from 'mysql2/promise';
+import * as schema from './schema.js';
+
+const connection = await mysql.createConnection(process.env.DATABASE_URL!);
+export const db = drizzle(connection, { schema, mode: 'default' });
+`;
+  }
+  return `import { drizzle } from 'drizzle-orm/better-sqlite3';
+import Database from 'better-sqlite3';
+import * as schema from './schema.js';
+import { initDatabase } from './seed.js';
+
+const sqlite = new Database('./data.db');
+export const db = drizzle(sqlite, { schema });
+
+// Initialize database tables on first run
+initDatabase(db);
+`;
+}
+function getSQLiteSeed() {
+  return `import type { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
+import { users } from './schema.js';
+
+let initialized = false;
+
+export function initDatabase(db: BetterSQLite3Database<any>) {
+  if (initialized) return;
+  
+  try {
+    // Create tables if they don't exist
+    db.run(\`
+      CREATE TABLE IF NOT EXISTS users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        email TEXT UNIQUE NOT NULL,
+        created_at INTEGER
+      )
+    \`);
+
+    // Check if we need to seed
+    const count = db.get(\`SELECT COUNT(*) as count FROM users\`) as { count: number };
+    
+    if (count.count === 0) {
+      console.log('\u{1F331} Seeding database with example data...');
+      
+      // Insert example users
+      db.insert(users).values([
+        { name: 'John Doe', email: 'john@example.com', createdAt: new Date() },
+        { name: 'Jane Smith', email: 'jane@example.com', createdAt: new Date() }
+      ]).run();
+      
+      console.log('\u2705 Database seeded!');
+    }
+    
+    initialized = true;
+  } catch (err) {
+    console.error('Failed to initialize database:', err);
+  }
+}
+`;
+}
+async function createExampleRoutes(projectDir) {
+  const indexRoute = `export default async () => {
+  return {
+    status: 'ok',
+    framework: 'Kozo \u{1F525}',
+    timestamp: new Date().toISOString()
+  };
+};
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "routes", "index.ts"), indexRoute);
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "src", "routes", "users"));
+  const getUsersRoute = `import type { HandlerContext } from '@kozojs/core';
+import { users } from '../../db/schema.js';
+
+export const meta = {
+  summary: 'Get all users',
+  description: 'Returns a list of all users in the database'
+};
+
+export default async ({ services: { db } }: HandlerContext) => {
+  const allUsers = db.select().from(users).all();
+  return { users: allUsers };
+};
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "routes", "users", "get.ts"), getUsersRoute);
+  const postUsersRoute = `import { z } from 'zod';
+import type { HandlerContext } from '@kozojs/core';
+import { users } from '../../db/schema.js';
+
+export const schema = {
+  body: z.object({
+    name: z.string().min(2),
+    email: z.string().email()
+  })
+};
+
+export const meta = {
+  summary: 'Create a new user',
+  description: 'Creates a new user with name and email'
+};
+
+type Body = z.infer<typeof schema.body>;
+
+export default async ({ body, services: { db } }: HandlerContext<Body>) => {
+  const user = db.insert(users).values({
+    ...body,
+    createdAt: new Date()
+  }).returning().get();
+  
+  return { success: true, user };
+};
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "routes", "users", "post.ts"), postUsersRoute);
+}
+async function scaffoldCompleteTemplate(projectDir, projectName, kozoCoreDep) {
+  await import_fs_extra.default.ensureDir(projectDir);
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "src"));
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "src", "schemas"));
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "src", "routes"));
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "src", "routes", "auth"));
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "src", "routes", "users"));
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "src", "routes", "posts"));
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "src", "utils"));
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "src", "data"));
+  const packageJson = {
+    name: projectName,
+    version: "1.0.0",
+    type: "module",
+    scripts: {
+      dev: "tsx watch src/index.ts",
+      build: "tsc",
+      start: "node dist/index.js",
+      "type-check": "tsc --noEmit"
+    },
+    dependencies: {
+      "@kozojs/core": kozoCoreDep,
+      "@hono/node-server": "^1.13.0",
+      hono: "^4.6.0",
+      zod: "^3.23.0"
+    },
+    devDependencies: {
+      "@types/node": "^22.0.0",
+      tsx: "^4.19.0",
+      typescript: "^5.6.0"
+    }
+  };
+  await import_fs_extra.default.writeJSON(import_node_path.default.join(projectDir, "package.json"), packageJson, { spaces: 2 });
+  const tsconfig = {
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      outDir: "dist",
+      rootDir: "src",
+      declaration: true,
+      experimentalDecorators: true,
+      emitDecoratorMetadata: true
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  };
+  await import_fs_extra.default.writeJSON(import_node_path.default.join(projectDir, "tsconfig.json"), tsconfig, { spaces: 2 });
+  const gitignore = `node_modules/
+dist/
+.env
+.turbo/
+*.log
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, ".gitignore"), gitignore);
+  const envExample = `# Server
+PORT=3000
+NODE_ENV=development
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, ".env.example"), envExample);
+  const indexTs = `import { createKozo } from '@kozojs/core';
+import { registerAuthRoutes } from './routes/auth/index.js';
+import { registerUserRoutes } from './routes/users/index.js';
+import { registerPostRoutes } from './routes/posts/index.js';
+import { registerHealthRoute } from './routes/health.js';
+import { registerStatsRoute } from './routes/stats.js';
+
+const app = createKozo({
+  port: Number(process.env.PORT) || 3000,
+});
+
+// Register all routes
+registerHealthRoute(app);
+registerAuthRoutes(app);
+registerUserRoutes(app);
+registerPostRoutes(app);
+registerStatsRoute(app);
+
+console.log('\u{1F525} Kozo server running on http://localhost:3000');
+console.log('\u{1F4CA} Features: Auth, Users CRUD, Posts, Stats');
+console.log('\u26A1 Optimized with pre-compiled handlers and Zod schemas');
+console.log('');
+console.log('\u{1F4DA} Try these endpoints:');
+console.log('   GET  /health');
+console.log('   GET  /users');
+console.log('   POST /auth/login');
+console.log('   GET  /posts?published=true&page=1&limit=10');
+console.log('   GET  /stats');
+
+app.listen();
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "index.ts"), indexTs);
+  await createCompleteSchemas(projectDir);
+  await createCompleteUtils(projectDir);
+  await createCompleteDataStore(projectDir);
+  await createCompleteRoutes(projectDir);
+  const readme = `# ${projectName}
+
+Built with \u{1F525} **Kozo Framework** - Production-ready server template
+
+## Features
+
+\u2728 **Complete API Implementation**
+- \u2705 Authentication (login, me)
+- \u2705 User CRUD (Create, Read, Update, Delete)
+- \u2705 Posts with filtering and pagination
+- \u2705 Statistics endpoint
+- \u2705 Health check
+
+\u26A1 **Performance Optimized**
+- Pre-compiled Zod schemas (no runtime overhead)
+- Fast-path routes for health checks
+- Optimized handler closures
+- Zero runtime decisions
+
+\u{1F3AF} **Type-Safe**
+- Full TypeScript inference
+- Zod validation for all inputs
+- Auto-generated types from schemas
+
+## Quick Start
+
+\`\`\`bash
+# Install dependencies
+npm install
+
+# Start development server
+npm run dev
+\`\`\`
+
+The server will start at **http://localhost:3000**
+
+## API Endpoints
+
+### Authentication
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| POST | /auth/login | Login with email/password |
+| GET | /auth/me | Get current user |
+
+### Users
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | /users | List all users (paginated) |
+| GET | /users/:id | Get user by ID |
+| POST | /users | Create new user |
+| PUT | /users/:id | Update user |
+| DELETE | /users/:id | Delete user |
+
+### Posts
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | /posts | List posts (with filters) |
+| GET | /posts/:id | Get post with author |
+| POST | /posts | Create new post |
+
+### System
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | /health | Health check |
+| GET | /stats | System statistics |
+
+## Example Requests
+
+### Create User
+\`\`\`bash
+curl -X POST http://localhost:3000/users \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "name": "Alice Smith",
+    "email": "alice@example.com",
+    "role": "user"
+  }'
+\`\`\`
+
+### Login
+\`\`\`bash
+curl -X POST http://localhost:3000/auth/login \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "email": "admin@kozo.dev",
+    "password": "secret123"
+  }'
+\`\`\`
+
+### List Users (Paginated)
+\`\`\`bash
+curl "http://localhost:3000/users?page=1&limit=10"
+\`\`\`
+
+### Filter Posts
+\`\`\`bash
+curl "http://localhost:3000/posts?published=true&tag=framework"
+\`\`\`
+
+### Get Statistics
+\`\`\`bash
+curl http://localhost:3000/stats
+\`\`\`
+
+## Project Structure
+
+\`\`\`
+${projectName}/
+\u251C\u2500\u2500 src/
+\u2502   \u251C\u2500\u2500 data/
+\u2502   \u2502   \u2514\u2500\u2500 store.ts           # In-memory data store
+\u2502   \u251C\u2500\u2500 routes/
+\u2502   \u2502   \u251C\u2500\u2500 auth/
+\u2502   \u2502   \u2502   \u2514\u2500\u2500 index.ts       # Auth routes (login, me)
+\u2502   \u2502   \u251C\u2500\u2500 users/
+\u2502   \u2502   \u2502   \u2514\u2500\u2500 index.ts       # User CRUD routes
+\u2502   \u2502   \u251C\u2500\u2500 posts/
+\u2502   \u2502   \u2502   \u2514\u2500\u2500 index.ts       # Post routes
+\u2502   \u2502   \u251C\u2500\u2500 health.ts          # Health check
+\u2502   \u2502   \u2514\u2500\u2500 stats.ts           # Statistics
+\u2502   \u251C\u2500\u2500 schemas/
+\u2502   \u2502   \u251C\u2500\u2500 user.ts            # User schemas
+\u2502   \u2502   \u251C\u2500\u2500 post.ts            # Post schemas
+\u2502   \u2502   \u2514\u2500\u2500 common.ts          # Common schemas
+\u2502   \u251C\u2500\u2500 utils/
+\u2502   \u2502   \u2514\u2500\u2500 helpers.ts         # Helper functions
+\u2502   \u2514\u2500\u2500 index.ts               # Entry point
+\u251C\u2500\u2500 package.json
+\u251C\u2500\u2500 tsconfig.json
+\u2514\u2500\u2500 README.md
+\`\`\`
+
+## Development
+
+\`\`\`bash
+npm run dev        # Start with hot reload
+npm run build      # Build for production
+npm start          # Run production build
+npm run type-check # TypeScript validation
+\`\`\`
+
+## Performance Notes
+
+This template uses Kozo's optimized patterns:
+- **Pre-compiled schemas**: Zod schemas compiled to Ajv validators at boot
+- **Handler closures**: Routes capture dependencies at startup
+- **Fast paths**: Simple routes skip unnecessary middleware
+- **Minimal allocations**: Context objects only include what's needed
+
+These optimizations make Kozo competitive with Fastify while providing:
+- Better type safety with Zod
+- Simpler API than NestJS
+- More features than plain Hono
+
+## Next Steps
+
+1. **Add database**: Integrate Drizzle ORM for persistent storage
+2. **Add authentication**: Implement JWT with proper password hashing
+3. **Add validation**: Enhance error handling and input validation
+4. **Add tests**: Write unit and integration tests
+5. **Deploy**: Deploy to Vercel, Railway, or any Node.js host
+
+## Documentation
+
+- [Kozo Documentation](https://kozo.dev/docs)
+- [Zod Schema Validation](https://zod.dev)
+- [Hono Framework](https://hono.dev)
+
+---
+
+Built with \u2764\uFE0F using Kozo Framework
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "README.md"), readme);
+}
+async function createCompleteSchemas(projectDir) {
+  const userSchemas = `import { z } from 'zod';
+
+export const UserSchema = z.object({
+  id: z.string().uuid(),
+  email: z.string().email(),
+  name: z.string().min(2).max(50),
+  role: z.enum(['user', 'admin']).default('user'),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export const CreateUserSchema = z.object({
+  email: z.string().email(),
+  name: z.string().min(2).max(50),
+  role: z.enum(['user', 'admin']).optional(),
+});
+
+export const UpdateUserSchema = z.object({
+  name: z.string().min(2).max(50).optional(),
+  role: z.enum(['user', 'admin']).optional(),
+});
+
+export type User = z.infer<typeof UserSchema>;
+export type CreateUser = z.infer<typeof CreateUserSchema>;
+export type UpdateUser = z.infer<typeof UpdateUserSchema>;
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "schemas", "user.ts"), userSchemas);
+  const postSchemas = `import { z } from 'zod';
+import { UserSchema } from './user.js';
+
+export const PostSchema = z.object({
+  id: z.string().uuid(),
+  title: z.string().min(1).max(200),
+  content: z.string().min(1),
+  authorId: z.string().uuid(),
+  published: z.boolean().default(false),
+  tags: z.array(z.string()).default([]),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export const PostWithAuthorSchema = PostSchema.extend({
+  author: UserSchema,
+});
+
+export const CreatePostSchema = z.object({
+  title: z.string().min(1).max(200),
+  content: z.string().min(1),
+  published: z.boolean().optional(),
+  tags: z.array(z.string()).optional(),
+});
+
+export type Post = z.infer<typeof PostSchema>;
+export type PostWithAuthor = z.infer<typeof PostWithAuthorSchema>;
+export type CreatePost = z.infer<typeof CreatePostSchema>;
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "schemas", "post.ts"), postSchemas);
+  const commonSchemas = `import { z } from 'zod';
+
+export const PaginationSchema = z.object({
+  page: z.coerce.number().min(1).default(1),
+  limit: z.coerce.number().min(1).max(100).default(10),
+});
+
+export const PostFiltersSchema = z.object({
+  published: z.coerce.boolean().optional(),
+  authorId: z.string().uuid().optional(),
+  tag: z.string().optional(),
+});
+
+export type Pagination = z.infer<typeof PaginationSchema>;
+export type PostFilters = z.infer<typeof PostFiltersSchema>;
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "schemas", "common.ts"), commonSchemas);
+}
+async function createCompleteUtils(projectDir) {
+  const helpers = `export function generateUUID(): string {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c == 'x' ? r : (r & 0x3 | 0x8);
+    return v.toString(16);
+  });
+}
+
+export function paginate<T>(items: T[], page: number, limit: number) {
+  const start = (page - 1) * limit;
+  const end = start + limit;
+  return {
+    data: items.slice(start, end),
+    total: items.length,
+    page,
+    limit,
+    totalPages: Math.ceil(items.length / limit),
+  };
+}
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "utils", "helpers.ts"), helpers);
+}
+async function createCompleteDataStore(projectDir) {
+  const store = `import type { User } from '../schemas/user.js';
+import type { Post } from '../schemas/post.js';
+
+export const users: User[] = [
+  {
+    id: '550e8400-e29b-41d4-a716-446655440000',
+    email: 'admin@kozo.dev',
+    name: 'Admin User',
+    role: 'admin',
+    createdAt: new Date('2024-01-01'),
+    updatedAt: new Date('2024-01-01'),
+  },
+  {
+    id: '550e8400-e29b-41d4-a716-446655440001',
+    email: 'john@example.com',
+    name: 'John Doe',
+    role: 'user',
+    createdAt: new Date('2024-01-15'),
+    updatedAt: new Date('2024-01-15'),
+  },
+];
+
+export const posts: Post[] = [
+  {
+    id: '550e8400-e29b-41d4-a716-446655440010',
+    title: 'Welcome to Kozo Framework',
+    content: 'This is the first post in our amazing framework...',
+    authorId: '550e8400-e29b-41d4-a716-446655440000',
+    published: true,
+    tags: ['framework', 'typescript', 'backend'],
+    createdAt: new Date('2024-01-01'),
+    updatedAt: new Date('2024-01-01'),
+  },
+];
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "data", "store.ts"), store);
+}
+async function createCompleteRoutes(projectDir) {
+  const healthRoute = `import type { Kozo } from '@kozojs/core';
+
+export function registerHealthRoute(app: Kozo) {
+  app.get('/health', {}, (c) => {
+    return {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+      version: '1.0.0',
+      uptime: process.uptime(),
+    };
+  });
+}
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "routes", "health.ts"), healthRoute);
+  const statsRoute = `import { z } from 'zod';
+import type { Kozo } from '@kozojs/core';
+import { users } from '../data/store.js';
+import { posts } from '../data/store.js';
+
+export function registerStatsRoute(app: Kozo) {
+  app.get('/stats', {
+    response: z.object({
+      users: z.object({
+        total: z.number(),
+        admins: z.number(),
+        regular: z.number(),
+      }),
+      posts: z.object({
+        total: z.number(),
+        published: z.number(),
+        drafts: z.number(),
+        totalTags: z.number(),
+      }),
+      performance: z.object({
+        uptime: z.number(),
+        memoryUsage: z.object({
+          rss: z.number(),
+          heapTotal: z.number(),
+          heapUsed: z.number(),
+        }),
+      }),
+    }),
+  }, (c) => {
+    const memUsage = process.memoryUsage();
+    return {
+      users: {
+        total: users.length,
+        admins: users.filter(u => u.role === 'admin').length,
+        regular: users.filter(u => u.role === 'user').length,
+      },
+      posts: {
+        total: posts.length,
+        published: posts.filter(p => p.published).length,
+        drafts: posts.filter(p => !p.published).length,
+        totalTags: [...new Set(posts.flatMap(p => p.tags))].length,
+      },
+      performance: {
+        uptime: process.uptime(),
+        memoryUsage: {
+          rss: memUsage.rss,
+          heapTotal: memUsage.heapTotal,
+          heapUsed: memUsage.heapUsed,
+        },
+      },
+    };
+  });
+}
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "routes", "stats.ts"), statsRoute);
+  const authRoutes = `import { z } from 'zod';
+import type { Kozo } from '@kozojs/core';
+import { UserSchema } from '../../schemas/user.js';
+import { users } from '../../data/store.js';
+
+export function registerAuthRoutes(app: Kozo) {
+  // POST /auth/login
+  app.post('/auth/login', {
+    body: z.object({
+      email: z.string().email(),
+      password: z.string().min(6),
+    }),
+    response: z.object({
+      success: z.boolean(),
+      token: z.string(),
+      user: UserSchema,
+    }),
+  }, (c) => {
+    const user = users.find(u => u.email === c.body.email);
+    if (!user) {
+      return c.json({ error: 'Invalid credentials' }, 401);
+    }
+    const token = \`mock_jwt_\${user.id}_\${Date.now()}\`;
+    return { success: true, token, user };
+  });
+
+  // GET /auth/me
+  app.get('/auth/me', {
+    response: UserSchema,
+  }, (c) => users[0]);
+}
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "routes", "auth", "index.ts"), authRoutes);
+  const userRoutes = `import { z } from 'zod';
+import type { Kozo } from '@kozojs/core';
+import { UserSchema, CreateUserSchema, UpdateUserSchema } from '../../schemas/user.js';
+import { PaginationSchema } from '../../schemas/common.js';
+import { users } from '../../data/store.js';
+import { generateUUID, paginate } from '../../utils/helpers.js';
+
+export function registerUserRoutes(app: Kozo) {
+  // GET /users
+  app.get('/users', {
+    query: PaginationSchema,
+    response: z.object({
+      data: z.array(UserSchema),
+      total: z.number(),
+      page: z.number(),
+      limit: z.number(),
+      totalPages: z.number(),
+    }),
+  }, (c) => {
+    const { page, limit } = c.query;
+    return paginate(users, page, limit);
+  });
+
+  // GET /users/:id
+  app.get('/users/:id', {
+    params: z.object({ id: z.string().uuid() }),
+    response: UserSchema,
+  }, (c) => {
+    const user = users.find(u => u.id === c.params.id);
+    if (!user) return c.json({ error: 'User not found' }, 404);
+    return user;
+  });
+
+  // POST /users
+  app.post('/users', {
+    body: CreateUserSchema,
+    response: UserSchema,
+  }, (c) => {
+    const existing = users.find(u => u.email === c.body.email);
+    if (existing) return c.json({ error: 'Email already exists' }, 409);
+
+    const newUser = {
+      id: generateUUID(),
+      email: c.body.email,
+      name: c.body.name,
+      role: c.body.role || 'user' as const,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+    users.push(newUser);
+    return newUser;
+  });
+
+  // PUT /users/:id
+  app.put('/users/:id', {
+    params: z.object({ id: z.string().uuid() }),
+    body: UpdateUserSchema,
+    response: UserSchema,
+  }, (c) => {
+    const user = users.find(u => u.id === c.params.id);
+    if (!user) return c.json({ error: 'User not found' }, 404);
+
+    if (c.body.name) user.name = c.body.name;
+    if (c.body.role) user.role = c.body.role;
+    user.updatedAt = new Date();
+    return user;
+  });
+
+  // DELETE /users/:id
+  app.delete('/users/:id', {
+    params: z.object({ id: z.string().uuid() }),
+    response: z.object({
+      success: z.boolean(),
+      deletedId: z.string(),
+    }),
+  }, (c) => {
+    const index = users.findIndex(u => u.id === c.params.id);
+    if (index === -1) return c.json({ error: 'User not found' }, 404);
+
+    users.splice(index, 1);
+    return { success: true, deletedId: c.params.id };
+  });
+}
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "routes", "users", "index.ts"), userRoutes);
+  const postRoutes = `import { z } from 'zod';
+import type { Kozo } from '@kozojs/core';
+import { PostSchema, PostWithAuthorSchema, CreatePostSchema } from '../../schemas/post.js';
+import { PaginationSchema, PostFiltersSchema } from '../../schemas/common.js';
+import { posts, users } from '../../data/store.js';
+import { generateUUID, paginate } from '../../utils/helpers.js';
+
+export function registerPostRoutes(app: Kozo) {
+  // GET /posts
+  app.get('/posts', {
+    query: PaginationSchema.merge(PostFiltersSchema),
+    response: z.object({
+      data: z.array(PostWithAuthorSchema),
+      total: z.number(),
+      page: z.number(),
+      limit: z.number(),
+      totalPages: z.number(),
+    }),
+  }, (c) => {
+    const { page, limit, published, authorId, tag } = c.query;
+
+    let filteredPosts = posts;
+    if (published !== undefined) {
+      filteredPosts = filteredPosts.filter(p => p.published === published);
+    }
+    if (authorId) {
+      filteredPosts = filteredPosts.filter(p => p.authorId === authorId);
+    }
+    if (tag) {
+      filteredPosts = filteredPosts.filter(p => p.tags.includes(tag));
+    }
+
+    const postsWithAuthors = filteredPosts.map(post => ({
+      ...post,
+      author: users.find(u => u.id === post.authorId)!,
+    }));
+
+    return paginate(postsWithAuthors, page, limit);
+  });
+
+  // GET /posts/:id
+  app.get('/posts/:id', {
+    params: z.object({ id: z.string().uuid() }),
+    response: PostWithAuthorSchema,
+  }, (c) => {
+    const post = posts.find(p => p.id === c.params.id);
+    if (!post) return c.json({ error: 'Post not found' }, 404);
+
+    const author = users.find(u => u.id === post.authorId);
+    if (!author) return c.json({ error: 'Post author not found' }, 500);
+
+    return { ...post, author };
+  });
+
+  // POST /posts
+  app.post('/posts', {
+    body: CreatePostSchema,
+    response: PostSchema,
+  }, (c) => {
+    const authorId = users[0].id;
+    const newPost = {
+      id: generateUUID(),
+      title: c.body.title,
+      content: c.body.content,
+      authorId,
+      published: c.body.published || false,
+      tags: c.body.tags || [],
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+    posts.push(newPost);
+    return newPost;
+  });
+}
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "routes", "posts", "index.ts"), postRoutes);
+}
+
+// src/utils/ascii-art.ts
+var import_picocolors = __toESM(require("picocolors"));
+var KOZO_LOGO = `
+${import_picocolors.default.red(" _  __")}${import_picocolors.default.yellow("___ ")}${import_picocolors.default.red("______")}${import_picocolors.default.yellow("___ ")}
+${import_picocolors.default.red("| |/ /")}${import_picocolors.default.yellow(" _ \\\\")}${import_picocolors.default.red("|_  /")}${import_picocolors.default.yellow(" _ \\\\")}
+${import_picocolors.default.red("| ' /")}${import_picocolors.default.yellow(" (_) |")}${import_picocolors.default.red("/ /")}${import_picocolors.default.yellow(" (_) |")}
+${import_picocolors.default.red("|_|\\_\\\\")}${import_picocolors.default.yellow("___/")}${import_picocolors.default.red("___|\\\\")}${import_picocolors.default.yellow("___/")}
+`;
+var KOZO_BANNER = `
+${import_picocolors.default.bold(import_picocolors.default.red("\u{1F525} KOZO"))} ${import_picocolors.default.dim("- The Structure for the Edge")}
+`;
+function printLogo() {
+  console.log(KOZO_LOGO);
+}
+
+// src/commands/new.ts
+async function newCommand(projectName) {
+  printLogo();
+  p.intro(import_picocolors2.default.bold(import_picocolors2.default.red("\u{1F525} Create a new Kozo project")));
+  const project = await p.group(
+    {
+      name: () => {
+        if (projectName) {
+          if (!/^[a-z0-9-]+$/.test(projectName)) {
+            p.log.error("Project name must use lowercase letters, numbers, and hyphens only");
+            process.exit(1);
+          }
+          return Promise.resolve(projectName);
+        }
+        return p.text({
+          message: "Project name",
+          placeholder: "my-kozo-app",
+          validate: (value) => {
+            if (!value) return "Project name is required";
+            if (!/^[a-z0-9-]+$/.test(value)) return "Use lowercase letters, numbers, and hyphens only";
+          }
+        });
+      },
+      template: () => p.select({
+        message: "Template",
+        options: [
+          { value: "complete", label: "Complete Server", hint: "Full production-ready app (Auth, CRUD, Stats)" },
+          { value: "starter", label: "Starter", hint: "Minimal setup with database" },
+          { value: "saas", label: "SaaS", hint: "Auth + Stripe + Email (coming soon)" },
+          { value: "ecommerce", label: "E-commerce", hint: "Products + Orders (coming soon)" }
+        ]
+      }),
+      database: ({ results }) => {
+        if (results.template === "complete") {
+          return Promise.resolve("none");
+        }
+        return p.select({
+          message: "Database provider",
+          options: [
+            { value: "postgresql", label: "PostgreSQL", hint: "Neon, Supabase, Railway" },
+            { value: "mysql", label: "MySQL", hint: "PlanetScale" },
+            { value: "sqlite", label: "SQLite", hint: "Turso, local dev" }
+          ]
+        });
+      },
+      packageSource: () => p.select({
+        message: "Package source for @kozojs/core",
+        options: [
+          { value: "npm", label: "npm registry", hint: "Use published version (recommended)" },
+          { value: "local", label: "Local workspace", hint: "Link to local monorepo (for development)" }
+        ],
+        initialValue: "npm"
+      }),
+      install: () => {
+        return Promise.resolve(true);
+      }
+    },
+    {
+      onCancel: () => {
+        p.cancel("Operation cancelled");
+        process.exit(0);
+      }
+    }
+  );
+  const s = p.spinner();
+  s.start("Creating project structure...");
+  try {
+    await scaffoldProject({
+      projectName: project.name,
+      database: project.database,
+      template: project.template,
+      packageSource: project.packageSource
+    });
+    s.stop("Project structure created!");
+  } catch (err) {
+    s.stop("Failed to create project");
+    p.log.error(String(err));
+    process.exit(1);
+  }
+  if (project.install) {
+    s.start("Installing dependencies...");
+    try {
+      await (0, import_execa.execa)("pnpm", ["install"], {
+        cwd: project.name,
+        stdio: "pipe"
+      });
+      s.stop("Dependencies installed!");
+    } catch {
+      try {
+        await (0, import_execa.execa)("npm", ["install"], {
+          cwd: project.name,
+          stdio: "pipe"
+        });
+        s.stop("Dependencies installed!");
+      } catch (err) {
+        s.stop("Failed to install dependencies");
+        p.log.warn("Run `pnpm install` or `npm install` manually");
+      }
+    }
+  }
+  p.outro(import_picocolors2.default.green("\u2728 Project ready!"));
+  console.log(`
+${import_picocolors2.default.bold("Next steps:")}
+
+  ${import_picocolors2.default.cyan(`cd ${project.name}`)}
+  ${!project.install ? import_picocolors2.default.cyan("pnpm install") + "\n  " : ""}${import_picocolors2.default.cyan("pnpm dev")}
+
+${import_picocolors2.default.dim("Documentation:")} ${import_picocolors2.default.underline("https://kozo.dev/docs")}
+`);
+}
+
+// src/index.ts
+var program = new import_commander.Command();
+program.name("kozo").description("CLI to scaffold new Kozo Framework projects").version("0.2.6");
+program.argument("[project-name]", "Name of the project").action(async (projectName) => {
+  await newCommand(projectName);
+});
+program.parse();