npm - @kozojs/cli - Versions diffs - 0.1.5 → 0.1.7 - Mend

@kozojs/cli 0.1.5 → 0.1.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/lib/index.js +1632 -137
package/package.json +3 -2

package/lib/index.js CHANGED Viewed

@@ -35,11 +35,23 @@ var import_execa = require("execa");
 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 { projectName, runtime, database, packageSource, template, frontend, extras } = options;
   const projectDir = import_node_path.default.resolve(process.cwd(), projectName);
-  const kozoCoreDep = packageSource === "local" ? "workspace:*" : "^0.1.0";
+  const kozoCoreDep = packageSource === "local" ? "workspace:*" : "^0.2.0";
+  if (frontend !== "none") {
+    await scaffoldFullstackProject(projectDir, projectName, kozoCoreDep, runtime, database, frontend, extras, template);
+    return;
+  }
   if (template === "complete") {
-    await scaffoldCompleteTemplate(projectDir, projectName, kozoCoreDep);
+    await scaffoldCompleteTemplate(projectDir, projectName, kozoCoreDep, runtime);
+    if (extras.includes("docker")) await createDockerfile(projectDir, runtime);
+    if (extras.includes("github-actions")) await createGitHubActions(projectDir);
+    return;
+  }
+  if (template === "api-only") {
+    await scaffoldApiOnlyTemplate(projectDir, projectName, kozoCoreDep, runtime);
+    if (extras.includes("docker")) await createDockerfile(projectDir, runtime);
+    if (extras.includes("github-actions")) await createGitHubActions(projectDir);
     return;
   }
   await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "src", "routes"));
@@ -399,7 +411,7 @@ export default async ({ body, services: { db } }: HandlerContext<Body>) => {
 `;
   await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "routes", "users", "post.ts"), postUsersRoute);
 }
-async function scaffoldCompleteTemplate(projectDir, projectName, kozoCoreDep) {
+async function scaffoldCompleteTemplate(projectDir, projectName, kozoCoreDep, runtime) {
   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"));
@@ -407,6 +419,7 @@ async function scaffoldCompleteTemplate(projectDir, projectName, kozoCoreDep) {
   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", "middleware"));
   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 = {
@@ -421,6 +434,7 @@ async function scaffoldCompleteTemplate(projectDir, projectName, kozoCoreDep) {
     },
     dependencies: {
       "@kozojs/core": kozoCoreDep,
+      "@kozojs/auth": kozoCoreDep,
       "@hono/node-server": "^1.13.0",
       hono: "^4.6.0",
       zod: "^3.23.0"
@@ -460,38 +474,83 @@ dist/
   const envExample = `# Server
 PORT=3000
 NODE_ENV=development
+# JWT Authentication
+JWT_SECRET=change-me-to-a-random-secret-at-least-32-chars
+# CORS
+CORS_ORIGIN=http://localhost:5173
+# Rate Limiting (requests per window)
+RATE_LIMIT_MAX=100
+RATE_LIMIT_WINDOW=60000
 `;
   await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, ".env.example"), envExample);
-  const indexTs = `import { createKozo } from '@kozojs/core';
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, ".env"), envExample);
+  const indexTs = `import { createKozo, cors, logger, rateLimit } from '@kozojs/core';
+import { authenticateJWT } from '@kozojs/auth';
 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
+// \u2500\u2500\u2500 Config \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+const PORT = Number(process.env.PORT) || 3000;
+const JWT_SECRET = process.env.JWT_SECRET || 'change-me-to-a-random-secret';
+const CORS_ORIGIN = process.env.CORS_ORIGIN || '*';
+const RATE_LIMIT_MAX = Number(process.env.RATE_LIMIT_MAX) || 100;
+const RATE_LIMIT_WINDOW = Number(process.env.RATE_LIMIT_WINDOW) || 60_000;
+// \u2500\u2500\u2500 App \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+const app = createKozo({ port: PORT });
+// \u2500\u2500\u2500 Middleware (Hono layer) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+app.getApp().use('*', logger());
+app.getApp().use('*', cors({ origin: CORS_ORIGIN }));
+app.getApp().use('/api/*', rateLimit({ max: RATE_LIMIT_MAX, windowMs: RATE_LIMIT_WINDOW }));
+app.getApp().use('/api/*', authenticateJWT(JWT_SECRET, {
+  prefix: '/api',
+}));
+// \u2500\u2500\u2500 Routes (native compiled \u2014 zero overhead) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
 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');
+// \u2500\u2500\u2500 Graceful Shutdown \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+const shutdown = app.getShutdownManager();
+process.on('SIGTERM', () => shutdown.shutdown());
+process.on('SIGINT', () => shutdown.shutdown());
+// \u2500\u2500\u2500 Start \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+console.log('');
+console.log('\u{1F525} Kozo server starting\u2026');
+console.log('\u26A1 Powered by uWebSockets.js (native per-route C++ matching)');
 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();
+const { port } = await app.nativeListen(PORT);
+console.log(\`\u{1F680} Listening on http://localhost:\${port}\`);
+console.log('');
+console.log('\u{1F4DA} Endpoints:');
+console.log('   GET  /health               Health check');
+console.log('   POST /auth/login           Login (returns JWT)');
+console.log('   GET  /auth/me              Current user (requires JWT)');
+console.log('   GET  /users                List users (paginated)');
+console.log('   POST /users                Create user');
+console.log('   GET  /users/:id            Get user');
+console.log('   PUT  /users/:id            Update user');
+console.log('   DEL  /users/:id            Delete user');
+console.log('   GET  /posts                List posts (filterable)');
+console.log('   POST /posts                Create post');
+console.log('   GET  /stats                Server stats');
+console.log('');
+console.log('\u{1F512} Middleware: CORS \xB7 Rate limit \xB7 JWT \xB7 Logger');
+console.log('\u{1F6E1}\uFE0F  Graceful shutdown enabled (SIGTERM / SIGINT)');
 `;
   await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "index.ts"), indexTs);
   await createCompleteSchemas(projectDir);
@@ -500,22 +559,29 @@ app.listen();
   await createCompleteRoutes(projectDir);
   const readme = `# ${projectName}
-Built with \u{1F525} **Kozo Framework** - Production-ready server template
+Built with \u{1F525} **Kozo Framework** \u2014 Production-ready server template
 ## Features
 \u2728 **Complete API Implementation**
-- \u2705 Authentication (login, me)
+- \u2705 JWT Authentication (login, token-protected routes)
 - \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
+\u26A1 **Maximum Performance**
+- uWebSockets.js transport with native per-route C++ matching (zero JS routing overhead)
+- Compiled handlers write directly to uWS response via cork() \u2014 zero shim objects
+- Pre-compiled Zod schemas (Ajv fast-path)
+- fast-json-stringify serialization
+\u{1F512} **Production Middleware**
+- CORS with configurable origins
+- Rate limiting (per-IP, configurable window)
+- JWT verification on \\\`/api/*\\\` routes
+- Request logger with timing
+- Graceful shutdown (SIGTERM / SIGINT)
 \u{1F3AF} **Type-Safe**
 - Full TypeScript inference
@@ -524,91 +590,82 @@ Built with \u{1F525} **Kozo Framework** - Production-ready server template
 ## Quick Start
-\`\`\`bash
+\\\`\\\`\\\`bash
 # Install dependencies
-npm install
+pnpm install   # or npm install
 # Start development server
-npm run dev
-\`\`\`
+pnpm dev
+\\\`\\\`\\\`
 The server will start at **http://localhost:3000**
 ## API Endpoints
-### Authentication
+### Public
 | Method | Endpoint | Description |
 |--------|----------|-------------|
-| POST | /auth/login | Login with email/password |
-| GET | /auth/me | Get current user |
+| GET | /health | Health check |
+| POST | /auth/login | Login \u2192 JWT token |
-### Users
+### Protected (requires \\\`Authorization: Bearer <token>\\\`)
 | Method | Endpoint | Description |
 |--------|----------|-------------|
-| GET | /users | List all users (paginated) |
+| GET | /auth/me | Current user |
+| GET | /users | List 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 | List posts (filterable) |
 | GET | /posts/:id | Get post with author |
 | POST | /posts | Create new post |
-### System
-| Method | Endpoint | Description |
-|--------|----------|-------------|
-| GET | /health | Health check |
-| GET | /stats | System statistics |
+| GET | /stats | Server statistics |
 ## Example Requests
-### Create User
-\`\`\`bash
-curl -X POST http://localhost:3000/users \\
+\\\`\\\`\\\`bash
+# 1. Login to get a JWT
+TOKEN=$(curl -s -X POST http://localhost:3000/auth/login \\
   -H "Content-Type: application/json" \\
-  -d '{
-    "name": "Alice Smith",
-    "email": "alice@example.com",
-    "role": "user"
-  }'
-\`\`\`
+  -d '{"email":"admin@kozo.dev","password":"secret123"}' \\
+  | jq -r '.token')
-### Login
-\`\`\`bash
-curl -X POST http://localhost:3000/auth/login \\
+# 2. Use the token for protected routes
+curl -H "Authorization: Bearer $TOKEN" http://localhost:3000/users
+# 3. Create a user
+curl -X POST http://localhost:3000/users \\
+  -H "Authorization: Bearer $TOKEN" \\
   -H "Content-Type: application/json" \\
-  -d '{
-    "email": "admin@kozo.dev",
-    "password": "secret123"
-  }'
-\`\`\`
+  -d '{"name":"Alice","email":"alice@example.com","role":"user"}'
-### List Users (Paginated)
-\`\`\`bash
-curl "http://localhost:3000/users?page=1&limit=10"
-\`\`\`
+# 4. Filter posts
+curl -H "Authorization: Bearer $TOKEN" \\
+  "http://localhost:3000/posts?published=true&tag=framework"
-### Filter Posts
-\`\`\`bash
-curl "http://localhost:3000/posts?published=true&tag=framework"
-\`\`\`
+# 5. Health check (no auth needed)
+curl http://localhost:3000/health
+\\\`\\\`\\\`
-### Get Statistics
-\`\`\`bash
-curl http://localhost:3000/stats
-\`\`\`
+## Environment Variables
+| Variable | Default | Description |
+|----------|---------|-------------|
+| PORT | 3000 | Server port |
+| JWT_SECRET | change-me\u2026 | HMAC secret for JWT signing |
+| CORS_ORIGIN | * | Allowed CORS origin |
+| RATE_LIMIT_MAX | 100 | Max requests per window |
+| RATE_LIMIT_WINDOW | 60000 | Window duration (ms) |
 ## 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 middleware/             # (extensible)
 \u2502   \u251C\u2500\u2500 routes/
 \u2502   \u2502   \u251C\u2500\u2500 auth/
 \u2502   \u2502   \u2502   \u2514\u2500\u2500 index.ts       # Auth routes (login, me)
@@ -619,51 +676,42 @@ ${projectName}/
 \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   \u2502   \u251C\u2500\u2500 user.ts            # User Zod schemas
+\u2502   \u2502   \u251C\u2500\u2500 post.ts            # Post Zod schemas
+\u2502   \u2502   \u2514\u2500\u2500 common.ts          # Pagination, filters
 \u2502   \u251C\u2500\u2500 utils/
-\u2502   \u2502   \u2514\u2500\u2500 helpers.ts         # Helper functions
-\u2502   \u2514\u2500\u2500 index.ts               # Entry point
+\u2502   \u2502   \u2514\u2500\u2500 helpers.ts         # UUID, pagination
+\u2502   \u2514\u2500\u2500 index.ts               # Entry point (middleware + routes)
+\u251C\u2500\u2500 .env                       # Environment config
+\u251C\u2500\u2500 .env.example               # Example config
 \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
-- [Zod Schema Validation](https://zod.dev)
-- [Hono Framework](https://hono.dev)
+\\\`\\\`\\\`
+## Architecture
+\\\`\\\`\\\`
+            \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+Request \u2500\u2500\u25BA \u2502 uWebSockets \u2502  C++ HTTP parser + epoll/kqueue
+            \u2502    .js       \u2502
+            \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+                   \u2502
+            \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u25BC\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+            \u2502  C++ Radix  \u2502  Native per-route matching (zero JS)
+            \u2502   Router    \u2502  app.get(), app.post(), \u2026
+            \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+                   \u2502
+            \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u25BC\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+            \u2502  Compiled   \u2502  Handler writes directly to uWS
+            \u2502  Handler    \u2502  via cork() \u2014 one syscall per response
+            \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+                   \u2502
+            \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u25BC\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+            \u2502  Zod \u2192 Ajv  \u2502  Pre-compiled JSON serializer
+            \u2502  Serializer \u2502
+            \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+\\\`\\\`\\\`
 ---
@@ -880,11 +928,14 @@ export function registerStatsRoute(app: Kozo) {
   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 { createJWT } from '@kozojs/auth';
 import { UserSchema } from '../../schemas/user.js';
 import { users } from '../../data/store.js';
+const JWT_SECRET = process.env.JWT_SECRET || 'change-me-to-a-random-secret';
 export function registerAuthRoutes(app: Kozo) {
-  // POST /auth/login
+  // POST /auth/login \u2014 public (no JWT required)
   app.post('/auth/login', {
     body: z.object({
       email: z.string().email(),
@@ -895,19 +946,29 @@ export function registerAuthRoutes(app: Kozo) {
       token: z.string(),
       user: UserSchema,
     }),
-  }, (c) => {
+  }, async (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()}\`;
+    // Generate a real JWT with 24h expiry
+    const token = await createJWT(
+      { sub: user.id, email: user.email, role: user.role },
+      JWT_SECRET,
+      { expiresIn: '24h' }
+    );
     return { success: true, token, user };
   });
-  // GET /auth/me
+  // GET /auth/me \u2014 requires valid JWT (middleware handles verification)
   app.get('/auth/me', {
     response: UserSchema,
-  }, (c) => users[0]);
+  }, (c) => {
+    // user payload set by authenticateJWT middleware
+    return users[0];
+  });
 }
 `;
   await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "routes", "auth", "index.ts"), authRoutes);
@@ -1073,6 +1134,1127 @@ export function registerPostRoutes(app: Kozo) {
 `;
   await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "routes", "posts", "index.ts"), postRoutes);
 }
+async function scaffoldApiOnlyTemplate(projectDir, projectName, kozoCoreDep, runtime) {
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "src"));
+  const packageJson = {
+    name: projectName,
+    version: "1.0.0",
+    type: "module",
+    scripts: {
+      dev: runtime === "bun" ? "bun --watch src/index.ts" : "tsx watch src/index.ts",
+      build: "tsc",
+      start: runtime === "bun" ? "bun src/index.ts" : "node dist/index.js"
+    },
+    dependencies: {
+      "@kozojs/core": kozoCoreDep,
+      hono: "^4.6.0",
+      zod: "^3.23.0",
+      ...runtime === "node" && { "@hono/node-server": "^1.13.0" }
+    },
+    devDependencies: {
+      "@types/node": "^22.0.0",
+      ...runtime !== "bun" && { 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"
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  };
+  await import_fs_extra.default.writeJSON(import_node_path.default.join(projectDir, "tsconfig.json"), tsconfig, { spaces: 2 });
+  const indexTs = `import { createKozo } from '@kozojs/core';
+import { z } from 'zod';
+const app = createKozo({ port: 3000 });
+// Health check
+app.get('/health', {}, () => ({
+  status: 'ok',
+  timestamp: new Date().toISOString(),
+}));
+// Example endpoint with validation
+app.get('/hello/:name', {
+  params: z.object({ name: z.string() }),
+  response: z.object({ message: z.string() }),
+}, (c) => ({
+  message: \`Hello, \${c.params.name}!\`,
+}));
+console.log('\u{1F525} Kozo running on http://localhost:3000');
+await app.nativeListen();
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "src", "index.ts"), indexTs);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, ".gitignore"), "node_modules/\ndist/\n.env\n");
+}
+async function createDockerfile(projectDir, runtime) {
+  const dockerfile = runtime === "bun" ? `FROM oven/bun:1 as builder
+WORKDIR /app
+COPY package.json bun.lockb* ./
+RUN bun install --frozen-lockfile
+COPY . .
+RUN bun run build
+FROM oven/bun:1-slim
+WORKDIR /app
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/package.json ./
+EXPOSE 3000
+CMD ["bun", "dist/index.js"]
+` : `FROM node:20-alpine as builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+FROM node:20-alpine
+WORKDIR /app
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/package*.json ./
+RUN npm ci --omit=dev
+EXPOSE 3000
+CMD ["node", "dist/index.js"]
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "Dockerfile"), dockerfile);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, ".dockerignore"), "node_modules\ndist\n.git\n");
+}
+async function createGitHubActions(projectDir) {
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, ".github", "workflows"));
+  const workflow = `name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+      - run: npm ci
+      - run: npm run build
+      - run: npm test --if-present
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, ".github", "workflows", "ci.yml"), workflow);
+}
+async function scaffoldFullstackProject(projectDir, projectName, kozoCoreDep, runtime, database, frontend, extras, template) {
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "apps", "api", "src", "routes"));
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "apps", "api", "src", "data"));
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, "apps", "web", "src", "lib"));
+  await import_fs_extra.default.ensureDir(import_node_path.default.join(projectDir, ".vscode"));
+  const rootPackageJson = {
+    name: projectName,
+    private: true,
+    scripts: {
+      dev: "pnpm run --parallel dev",
+      build: "pnpm run --recursive build"
+    }
+  };
+  await import_fs_extra.default.writeJSON(import_node_path.default.join(projectDir, "package.json"), rootPackageJson, { spaces: 2 });
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "pnpm-workspace.yaml"), `packages:
+  - 'apps/*'
+`);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, ".gitignore"), "node_modules/\ndist/\n.env\n*.log\n");
+  await scaffoldFullstackApi(projectDir, projectName, kozoCoreDep, runtime);
+  await scaffoldFullstackWeb(projectDir, projectName, frontend);
+  await scaffoldFullstackReadme(projectDir, projectName);
+  if (extras.includes("docker")) await createDockerfile(import_node_path.default.join(projectDir, "apps", "api"), runtime);
+  if (extras.includes("github-actions")) await createGitHubActions(projectDir);
+}
+async function scaffoldFullstackApi(projectDir, projectName, kozoCoreDep, runtime) {
+  const apiDir = import_node_path.default.join(projectDir, "apps", "api");
+  const apiPackageJson = {
+    name: `@${projectName}/api`,
+    version: "1.0.0",
+    type: "module",
+    scripts: {
+      dev: runtime === "bun" ? "bun --watch src/index.ts" : "tsx watch src/index.ts",
+      build: "tsc"
+    },
+    dependencies: {
+      "@kozojs/core": kozoCoreDep,
+      hono: "^4.6.0",
+      zod: "^3.23.0",
+      ...runtime === "node" && { "@hono/node-server": "^1.13.0" }
+    },
+    devDependencies: {
+      "@types/node": "^22.0.0",
+      ...runtime !== "bun" && { tsx: "^4.19.0" },
+      typescript: "^5.6.0"
+    }
+  };
+  await import_fs_extra.default.writeJSON(import_node_path.default.join(apiDir, "package.json"), apiPackageJson, { spaces: 2 });
+  const tsconfig = {
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      outDir: "dist",
+      rootDir: "src"
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  };
+  await import_fs_extra.default.writeJSON(import_node_path.default.join(apiDir, "tsconfig.json"), tsconfig, { spaces: 2 });
+  await import_fs_extra.default.writeFile(import_node_path.default.join(apiDir, "src", "index.ts"), `import { createKozo } from '@kozojs/core';
+import { registerRoutes } from './routes';
+const app = createKozo({ port: 3000 });
+registerRoutes(app);
+export type AppType = typeof app;
+console.log('\u{1F525} ${projectName} API starting on http://localhost:3000');
+console.log('\u{1F4DA} Endpoints: /api/health, /api/users, /api/posts, /api/tasks, /api/stats');
+await app.nativeListen();
+`);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(apiDir, "src", "data", "index.ts"), `import { z } from 'zod';
+export const UserSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string().email(),
+  role: z.enum(['admin', 'user']),
+  createdAt: z.string().optional(),
+});
+export const PostSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  content: z.string(),
+  authorId: z.string(),
+  published: z.boolean(),
+  createdAt: z.string().optional(),
+});
+export const TaskSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  completed: z.boolean(),
+  priority: z.enum(['low', 'medium', 'high']),
+  createdAt: z.string(),
+});
+export const users: z.infer<typeof UserSchema>[] = [
+  { id: '1', name: 'Alice', email: 'alice@example.com', role: 'admin', createdAt: new Date().toISOString() },
+  { id: '2', name: 'Bob', email: 'bob@example.com', role: 'user', createdAt: new Date().toISOString() },
+];
+export const posts: z.infer<typeof PostSchema>[] = [
+  { id: '1', title: 'Hello World', content: 'First post!', authorId: '1', published: true, createdAt: new Date().toISOString() },
+  { id: '2', title: 'Draft', content: 'Work in progress', authorId: '2', published: false, createdAt: new Date().toISOString() },
+];
+export const tasks: z.infer<typeof TaskSchema>[] = [
+  { id: '1', title: 'Setup project', completed: true, priority: 'high', createdAt: new Date().toISOString() },
+  { id: '2', title: 'Write tests', completed: false, priority: 'medium', createdAt: new Date().toISOString() },
+  { id: '3', title: 'Deploy', completed: false, priority: 'low', createdAt: new Date().toISOString() },
+];
+`);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(apiDir, "src", "routes", "index.ts"), `import type { Kozo } from '@kozojs/core';
+import { registerHealthRoutes } from './health';
+import { registerUserRoutes } from './users';
+import { registerPostRoutes } from './posts';
+import { registerTaskRoutes } from './tasks';
+import { registerToolRoutes } from './tools';
+export function registerRoutes(app: Kozo) {
+  registerHealthRoutes(app);
+  registerUserRoutes(app);
+  registerPostRoutes(app);
+  registerTaskRoutes(app);
+  registerToolRoutes(app);
+}
+`);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(apiDir, "src", "routes", "health.ts"), `import type { Kozo } from '@kozojs/core';
+import { users, posts, tasks } from '../data';
+export function registerHealthRoutes(app: Kozo) {
+  app.get('/api/health', {}, () => ({
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+    version: '1.0.0',
+    uptime: process.uptime(),
+  }));
+  app.get('/api/stats', {}, () => ({
+    users: users.length,
+    posts: posts.length,
+    tasks: tasks.length,
+    publishedPosts: posts.filter(p => p.published).length,
+    completedTasks: tasks.filter(t => t.completed).length,
+  }));
+}
+`);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(apiDir, "src", "routes", "users.ts"), `import type { Kozo } from '@kozojs/core';
+import { z } from 'zod';
+import { users, UserSchema } from '../data';
+export function registerUserRoutes(app: Kozo) {
+  app.get('/api/users', {
+    response: z.array(UserSchema),
+  }, () => users);
+  app.get('/api/users/:id', {
+    params: z.object({ id: z.string() }),
+    response: UserSchema,
+  }, (c) => {
+    const user = users.find(u => u.id === c.params.id);
+    if (!user) throw new Error('User not found');
+    return user;
+  });
+  app.post('/api/users', {
+    body: z.object({
+      name: z.string().min(1),
+      email: z.string().email(),
+      role: z.enum(['admin', 'user']).optional(),
+    }),
+    response: UserSchema,
+  }, (c) => {
+    const newUser = {
+      id: String(Date.now()),
+      name: c.body.name,
+      email: c.body.email,
+      role: c.body.role || 'user' as const,
+      createdAt: new Date().toISOString(),
+    };
+    users.push(newUser);
+    return newUser;
+  });
+  app.put('/api/users/:id', {
+    params: z.object({ id: z.string() }),
+    body: z.object({
+      name: z.string().min(1).optional(),
+      email: z.string().email().optional(),
+      role: z.enum(['admin', 'user']).optional(),
+    }),
+    response: UserSchema,
+  }, (c) => {
+    const idx = users.findIndex(u => u.id === c.params.id);
+    if (idx === -1) throw new Error('User not found');
+    users[idx] = { ...users[idx], ...c.body };
+    return users[idx];
+  });
+  app.delete('/api/users/:id', {
+    params: z.object({ id: z.string() }),
+  }, (c) => {
+    const idx = users.findIndex(u => u.id === c.params.id);
+    if (idx === -1) throw new Error('User not found');
+    users.splice(idx, 1);
+    return { success: true, message: 'User deleted' };
+  });
+}
+`);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(apiDir, "src", "routes", "posts.ts"), `import type { Kozo } from '@kozojs/core';
+import { z } from 'zod';
+import { posts, PostSchema } from '../data';
+export function registerPostRoutes(app: Kozo) {
+  app.get('/api/posts', {
+    query: z.object({ published: z.coerce.boolean().optional() }),
+    response: z.array(PostSchema),
+  }, (c) => {
+    if (c.query.published !== undefined) {
+      return posts.filter(p => p.published === c.query.published);
+    }
+    return posts;
+  });
+  app.get('/api/posts/:id', {
+    params: z.object({ id: z.string() }),
+    response: PostSchema,
+  }, (c) => {
+    const post = posts.find(p => p.id === c.params.id);
+    if (!post) throw new Error('Post not found');
+    return post;
+  });
+  app.post('/api/posts', {
+    body: z.object({
+      title: z.string().min(1),
+      content: z.string(),
+      authorId: z.string(),
+      published: z.boolean().optional(),
+    }),
+    response: PostSchema,
+  }, (c) => {
+    const newPost = {
+      id: String(Date.now()),
+      title: c.body.title,
+      content: c.body.content,
+      authorId: c.body.authorId,
+      published: c.body.published ?? false,
+      createdAt: new Date().toISOString(),
+    };
+    posts.push(newPost);
+    return newPost;
+  });
+  app.put('/api/posts/:id', {
+    params: z.object({ id: z.string() }),
+    body: z.object({
+      title: z.string().min(1).optional(),
+      content: z.string().optional(),
+      published: z.boolean().optional(),
+    }),
+    response: PostSchema,
+  }, (c) => {
+    const idx = posts.findIndex(p => p.id === c.params.id);
+    if (idx === -1) throw new Error('Post not found');
+    posts[idx] = { ...posts[idx], ...c.body };
+    return posts[idx];
+  });
+  app.delete('/api/posts/:id', {
+    params: z.object({ id: z.string() }),
+  }, (c) => {
+    const idx = posts.findIndex(p => p.id === c.params.id);
+    if (idx === -1) throw new Error('Post not found');
+    posts.splice(idx, 1);
+    return { success: true, message: 'Post deleted' };
+  });
+}
+`);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(apiDir, "src", "routes", "tasks.ts"), `import type { Kozo } from '@kozojs/core';
+import { z } from 'zod';
+import { tasks, TaskSchema } from '../data';
+export function registerTaskRoutes(app: Kozo) {
+  app.get('/api/tasks', {
+    query: z.object({
+      completed: z.coerce.boolean().optional(),
+      priority: z.enum(['low', 'medium', 'high']).optional(),
+    }),
+    response: z.array(TaskSchema),
+  }, (c) => {
+    let result = [...tasks];
+    if (c.query.completed !== undefined) {
+      result = result.filter(t => t.completed === c.query.completed);
+    }
+    if (c.query.priority) {
+      result = result.filter(t => t.priority === c.query.priority);
+    }
+    return result;
+  });
+  app.get('/api/tasks/:id', {
+    params: z.object({ id: z.string() }),
+    response: TaskSchema,
+  }, (c) => {
+    const task = tasks.find(t => t.id === c.params.id);
+    if (!task) throw new Error('Task not found');
+    return task;
+  });
+  app.post('/api/tasks', {
+    body: z.object({
+      title: z.string().min(1),
+      priority: z.enum(['low', 'medium', 'high']).optional(),
+    }),
+    response: TaskSchema,
+  }, (c) => {
+    const newTask = {
+      id: String(Date.now()),
+      title: c.body.title,
+      completed: false,
+      priority: c.body.priority || 'medium' as const,
+      createdAt: new Date().toISOString(),
+    };
+    tasks.push(newTask);
+    return newTask;
+  });
+  app.put('/api/tasks/:id', {
+    params: z.object({ id: z.string() }),
+    body: z.object({
+      title: z.string().min(1).optional(),
+      completed: z.boolean().optional(),
+      priority: z.enum(['low', 'medium', 'high']).optional(),
+    }),
+    response: TaskSchema,
+  }, (c) => {
+    const idx = tasks.findIndex(t => t.id === c.params.id);
+    if (idx === -1) throw new Error('Task not found');
+    tasks[idx] = { ...tasks[idx], ...c.body };
+    return tasks[idx];
+  });
+  app.patch('/api/tasks/:id/toggle', {
+    params: z.object({ id: z.string() }),
+    response: TaskSchema,
+  }, (c) => {
+    const idx = tasks.findIndex(t => t.id === c.params.id);
+    if (idx === -1) throw new Error('Task not found');
+    tasks[idx].completed = !tasks[idx].completed;
+    return tasks[idx];
+  });
+  app.delete('/api/tasks/:id', {
+    params: z.object({ id: z.string() }),
+  }, (c) => {
+    const idx = tasks.findIndex(t => t.id === c.params.id);
+    if (idx === -1) throw new Error('Task not found');
+    tasks.splice(idx, 1);
+    return { success: true, message: 'Task deleted' };
+  });
+}
+`);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(apiDir, "src", "routes", "tools.ts"), `import type { Kozo } from '@kozojs/core';
+import { z } from 'zod';
+export function registerToolRoutes(app: Kozo) {
+  app.get('/api/echo', {
+    query: z.object({ message: z.string() }),
+  }, (c) => ({
+    echo: c.query.message,
+    timestamp: new Date().toISOString(),
+  }));
+  app.post('/api/validate', {
+    body: z.object({
+      email: z.string().email(),
+      age: z.number().min(0).max(150),
+    }),
+  }, (c) => ({
+    valid: true,
+    data: c.body,
+  }));
+}
+`);
+}
+async function scaffoldFullstackWeb(projectDir, projectName, frontend) {
+  const webDir = import_node_path.default.join(projectDir, "apps", "web");
+  const packageJson = {
+    name: `@${projectName}/web`,
+    version: "1.0.0",
+    type: "module",
+    scripts: {
+      dev: "vite",
+      build: "vite build",
+      preview: "vite preview"
+    },
+    dependencies: {
+      react: "^18.2.0",
+      "react-dom": "^18.2.0",
+      "@tanstack/react-query": "^5.0.0",
+      hono: "^4.6.0",
+      "lucide-react": "^0.460.0"
+    },
+    devDependencies: {
+      "@types/react": "^18.2.0",
+      "@types/react-dom": "^18.2.0",
+      "@vitejs/plugin-react": "^4.2.0",
+      typescript: "^5.6.0",
+      vite: "^5.0.0",
+      "@tailwindcss/vite": "^4.0.0",
+      tailwindcss: "^4.0.0"
+    }
+  };
+  await import_fs_extra.default.writeJSON(import_node_path.default.join(webDir, "package.json"), packageJson, { spaces: 2 });
+  await import_fs_extra.default.writeFile(import_node_path.default.join(webDir, "vite.config.ts"), `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import tailwindcss from '@tailwindcss/vite';
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  server: {
+    proxy: {
+      '/api': 'http://localhost:3000',
+    },
+  },
+});
+`);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(webDir, "index.html"), `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>${projectName}</title>
+</head>
+<body>
+  <div id="root"></div>
+  <script type="module" src="/src/main.tsx"></script>
+</body>
+</html>
+`);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(webDir, "src", "index.css"), `@import "tailwindcss";
+body {
+  background-color: rgb(15 23 42);
+  color: rgb(241 245 249);
+}
+`);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(webDir, "src", "lib", "client.ts"), `import { hc } from 'hono/client';
+import type { AppType } from '@${projectName}/api';
+// Type-safe RPC client - changes in API break frontend at compile time!
+export const client = hc<AppType>('/');
+/* Usage:
+const res = await client.api.users.$get();
+const users = await res.json(); // Fully typed!
+*/
+`);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(webDir, "src", "main.tsx"), `import React from 'react';
+import ReactDOM from 'react-dom/client';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import App from './App';
+import './index.css';
+const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      refetchOnWindowFocus: false,
+      retry: 1,
+    },
+  },
+});
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <QueryClientProvider client={queryClient}>
+      <App />
+    </QueryClientProvider>
+  </React.StrictMode>
+);
+`);
+  await import_fs_extra.default.writeFile(import_node_path.default.join(webDir, "src", "App.tsx"), generateFullReactApp(projectName));
+}
+function generateFullReactApp(projectName) {
+  return `import { useState } from 'react';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import {
+  Activity, Users, FileText, CheckSquare, Send, Trash2, Edit2,
+  Plus, Server, Zap, Heart
+} from 'lucide-react';
+const API_BASE = '/api';
+type Tab = 'health' | 'users' | 'posts' | 'tasks' | 'tools';
+interface ApiResponse {
+  status: number;
+  data: unknown;
+  time: number;
+}
+async function fetchApi(endpoint: string, options?: RequestInit): Promise<ApiResponse> {
+  const start = performance.now();
+  const res = await fetch(\`\${API_BASE}\${endpoint}\`, {
+    headers: { 'Content-Type': 'application/json' },
+    ...options,
+  });
+  const time = Math.round(performance.now() - start);
+  const data = await res.json();
+  return { status: res.status, data, time };
+}
+function Badge({ children, variant = 'default' }: { children: React.ReactNode; variant?: 'default' | 'success' | 'warning' | 'error' }) {
+  const colors = {
+    default: 'bg-slate-700 text-slate-200',
+    success: 'bg-emerald-900 text-emerald-300',
+    warning: 'bg-amber-900 text-amber-300',
+    error: 'bg-red-900 text-red-300',
+  };
+  return <span className={\`px-2 py-0.5 rounded text-xs font-medium \${colors[variant]}\`}>{children}</span>;
+}
+function Card({ title, icon: Icon, children }: { title: string; icon: React.ElementType; children: React.ReactNode }) {
+  return (
+    <div className="bg-slate-800 rounded-lg border border-slate-700 overflow-hidden">
+      <div className="px-4 py-3 border-b border-slate-700 flex items-center gap-2">
+        <Icon className="w-4 h-4 text-blue-400" />
+        <h3 className="font-medium text-slate-200">{title}</h3>
+      </div>
+      <div className="p-4">{children}</div>
+    </div>
+  );
+}
+function ResponseDisplay({ response, loading }: { response: ApiResponse | null; loading: boolean }) {
+  if (loading) return <div className="text-slate-400 text-sm">Loading...</div>;
+  if (!response) return null;
+  const isSuccess = response.status >= 200 && response.status < 300;
+  return (
+    <div className="mt-3 p-3 bg-slate-900 rounded border border-slate-700">
+      <div className="flex items-center gap-2 mb-2">
+        <Badge variant={isSuccess ? 'success' : 'error'}>{response.status}</Badge>
+        <span className="text-xs text-slate-500">{response.time}ms</span>
+      </div>
+      <pre className="text-xs text-slate-300 overflow-auto max-h-48">
+        {JSON.stringify(response.data, null, 2)}
+      </pre>
+    </div>
+  );
+}
+function HealthPanel() {
+  const [response, setResponse] = useState<ApiResponse | null>(null);
+  const [loading, setLoading] = useState(false);
+  const checkHealth = async () => {
+    setLoading(true);
+    const res = await fetchApi('/health');
+    setResponse(res);
+    setLoading(false);
+  };
+  const checkStats = async () => {
+    setLoading(true);
+    const res = await fetchApi('/stats');
+    setResponse(res);
+    setLoading(false);
+  };
+  return (
+    <Card title="Health & Stats" icon={Heart}>
+      <div className="flex gap-2 mb-3">
+        <button onClick={checkHealth} className="px-3 py-1.5 bg-emerald-600 hover:bg-emerald-700 rounded text-sm font-medium transition">
+          Check Health
+        </button>
+        <button onClick={checkStats} className="px-3 py-1.5 bg-blue-600 hover:bg-blue-700 rounded text-sm font-medium transition">
+          Get Stats
+        </button>
+      </div>
+      <ResponseDisplay response={response} loading={loading} />
+    </Card>
+  );
+}
+function UsersPanel() {
+  const queryClient = useQueryClient();
+  const [response, setResponse] = useState<ApiResponse | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [newUser, setNewUser] = useState({ name: '', email: '', role: 'user' as const });
+  const { data: users, isLoading } = useQuery({
+    queryKey: ['users'],
+    queryFn: async () => {
+      const res = await fetchApi('/users');
+      return res.data as Array<{ id: string; name: string; email: string; role: string }>;
+    },
+  });
+  const createUser = async () => {
+    if (!newUser.name || !newUser.email) return;
+    setLoading(true);
+    const res = await fetchApi('/users', {
+      method: 'POST',
+      body: JSON.stringify(newUser),
+    });
+    setResponse(res);
+    setLoading(false);
+    setNewUser({ name: '', email: '', role: 'user' });
+    queryClient.invalidateQueries({ queryKey: ['users'] });
+  };
+  const deleteUser = async (id: string) => {
+    setLoading(true);
+    const res = await fetchApi(\`/users/\${id}\`, { method: 'DELETE' });
+    setResponse(res);
+    setLoading(false);
+    queryClient.invalidateQueries({ queryKey: ['users'] });
+  };
+  return (
+    <Card title="Users" icon={Users}>
+      <div className="space-y-4">
+        <div className="grid grid-cols-3 gap-2">
+          <input
+            placeholder="Name"
+            value={newUser.name}
+            onChange={(e) => setNewUser({ ...newUser, name: e.target.value })}
+            className="px-3 py-1.5 bg-slate-900 border border-slate-600 rounded text-sm focus:border-blue-500 outline-none"
+          />
+          <input
+            placeholder="Email"
+            value={newUser.email}
+            onChange={(e) => setNewUser({ ...newUser, email: e.target.value })}
+            className="px-3 py-1.5 bg-slate-900 border border-slate-600 rounded text-sm focus:border-blue-500 outline-none"
+          />
+          <button onClick={createUser} disabled={loading} className="px-3 py-1.5 bg-emerald-600 hover:bg-emerald-700 rounded text-sm font-medium transition flex items-center justify-center gap-1">
+            <Plus className="w-4 h-4" /> Add User
+          </button>
+        </div>
+        <div className="space-y-2">
+          {isLoading ? (
+            <div className="text-slate-400 text-sm">Loading users...</div>
+          ) : (
+            users?.map((user) => (
+              <div key={user.id} className="flex items-center justify-between p-2 bg-slate-900 rounded border border-slate-700">
+                <div>
+                  <span className="font-medium">{user.name}</span>
+                  <span className="text-slate-400 text-sm ml-2">{user.email}</span>
+                  <Badge variant={user.role === 'admin' ? 'warning' : 'default'}>{user.role}</Badge>
+                </div>
+                <button onClick={() => deleteUser(user.id)} className="p-1 text-red-400 hover:text-red-300 transition">
+                  <Trash2 className="w-4 h-4" />
+                </button>
+              </div>
+            ))
+          )}
+        </div>
+        <ResponseDisplay response={response} loading={loading} />
+      </div>
+    </Card>
+  );
+}
+function TasksPanel() {
+  const queryClient = useQueryClient();
+  const [response, setResponse] = useState<ApiResponse | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [newTask, setNewTask] = useState({ title: '', priority: 'medium' as const });
+  const { data: tasks, isLoading } = useQuery({
+    queryKey: ['tasks'],
+    queryFn: async () => {
+      const res = await fetchApi('/tasks');
+      return res.data as Array<{ id: string; title: string; completed: boolean; priority: string }>;
+    },
+  });
+  const createTask = async () => {
+    if (!newTask.title) return;
+    setLoading(true);
+    const res = await fetchApi('/tasks', {
+      method: 'POST',
+      body: JSON.stringify(newTask),
+    });
+    setResponse(res);
+    setLoading(false);
+    setNewTask({ title: '', priority: 'medium' });
+    queryClient.invalidateQueries({ queryKey: ['tasks'] });
+  };
+  const toggleTask = async (id: string) => {
+    setLoading(true);
+    const res = await fetchApi(\`/tasks/\${id}/toggle\`, { method: 'PATCH' });
+    setResponse(res);
+    setLoading(false);
+    queryClient.invalidateQueries({ queryKey: ['tasks'] });
+  };
+  const deleteTask = async (id: string) => {
+    setLoading(true);
+    const res = await fetchApi(\`/tasks/\${id}\`, { method: 'DELETE' });
+    setResponse(res);
+    setLoading(false);
+    queryClient.invalidateQueries({ queryKey: ['tasks'] });
+  };
+  const priorityColor = (p: string) => {
+    switch (p) {
+      case 'high': return 'error';
+      case 'medium': return 'warning';
+      default: return 'default';
+    }
+  };
+  return (
+    <Card title="Tasks" icon={CheckSquare}>
+      <div className="space-y-4">
+        <div className="grid grid-cols-3 gap-2">
+          <input
+            placeholder="Task title"
+            value={newTask.title}
+            onChange={(e) => setNewTask({ ...newTask, title: e.target.value })}
+            className="px-3 py-1.5 bg-slate-900 border border-slate-600 rounded text-sm focus:border-blue-500 outline-none"
+          />
+          <select
+            value={newTask.priority}
+            onChange={(e) => setNewTask({ ...newTask, priority: e.target.value as 'low' | 'medium' | 'high' })}
+            className="px-3 py-1.5 bg-slate-900 border border-slate-600 rounded text-sm focus:border-blue-500 outline-none"
+          >
+            <option value="low">Low</option>
+            <option value="medium">Medium</option>
+            <option value="high">High</option>
+          </select>
+          <button onClick={createTask} disabled={loading} className="px-3 py-1.5 bg-emerald-600 hover:bg-emerald-700 rounded text-sm font-medium transition flex items-center justify-center gap-1">
+            <Plus className="w-4 h-4" /> Add Task
+          </button>
+        </div>
+        <div className="space-y-2">
+          {isLoading ? (
+            <div className="text-slate-400 text-sm">Loading tasks...</div>
+          ) : (
+            tasks?.map((task) => (
+              <div key={task.id} className="flex items-center justify-between p-2 bg-slate-900 rounded border border-slate-700">
+                <div className="flex items-center gap-2">
+                  <input
+                    type="checkbox"
+                    checked={task.completed}
+                    onChange={() => toggleTask(task.id)}
+                    className="rounded"
+                  />
+                  <span className={task.completed ? 'line-through text-slate-500' : ''}>{task.title}</span>
+                  <Badge variant={priorityColor(task.priority) as 'default' | 'success' | 'warning' | 'error'}>{task.priority}</Badge>
+                </div>
+                <button onClick={() => deleteTask(task.id)} className="p-1 text-red-400 hover:text-red-300 transition">
+                  <Trash2 className="w-4 h-4" />
+                </button>
+              </div>
+            ))
+          )}
+        </div>
+        <ResponseDisplay response={response} loading={loading} />
+      </div>
+    </Card>
+  );
+}
+function ToolsPanel() {
+  const [echoMessage, setEchoMessage] = useState('');
+  const [validateData, setValidateData] = useState({ email: '', age: '' });
+  const [response, setResponse] = useState<ApiResponse | null>(null);
+  const [loading, setLoading] = useState(false);
+  const testEcho = async () => {
+    if (!echoMessage) return;
+    setLoading(true);
+    const res = await fetchApi(\`/echo?message=\${encodeURIComponent(echoMessage)}\`);
+    setResponse(res);
+    setLoading(false);
+  };
+  const testValidate = async () => {
+    setLoading(true);
+    const res = await fetchApi('/validate', {
+      method: 'POST',
+      body: JSON.stringify({
+        email: validateData.email,
+        age: parseInt(validateData.age) || 0,
+      }),
+    });
+    setResponse(res);
+    setLoading(false);
+  };
+  return (
+    <Card title="Test Tools" icon={Zap}>
+      <div className="space-y-6">
+        <div>
+          <h4 className="text-sm font-medium text-slate-300 mb-2">Echo Endpoint</h4>
+          <div className="flex gap-2">
+            <input
+              placeholder="Message to echo"
+              value={echoMessage}
+              onChange={(e) => setEchoMessage(e.target.value)}
+              className="flex-1 px-3 py-1.5 bg-slate-900 border border-slate-600 rounded text-sm focus:border-blue-500 outline-none"
+            />
+            <button onClick={testEcho} className="px-3 py-1.5 bg-blue-600 hover:bg-blue-700 rounded text-sm font-medium transition flex items-center gap-1">
+              <Send className="w-4 h-4" /> Echo
+            </button>
+          </div>
+        </div>
+        <div>
+          <h4 className="text-sm font-medium text-slate-300 mb-2">Validation Endpoint</h4>
+          <div className="flex gap-2">
+            <input
+              placeholder="Email"
+              value={validateData.email}
+              onChange={(e) => setValidateData({ ...validateData, email: e.target.value })}
+              className="flex-1 px-3 py-1.5 bg-slate-900 border border-slate-600 rounded text-sm focus:border-blue-500 outline-none"
+            />
+            <input
+              placeholder="Age"
+              type="number"
+              value={validateData.age}
+              onChange={(e) => setValidateData({ ...validateData, age: e.target.value })}
+              className="w-24 px-3 py-1.5 bg-slate-900 border border-slate-600 rounded text-sm focus:border-blue-500 outline-none"
+            />
+            <button onClick={testValidate} className="px-3 py-1.5 bg-purple-600 hover:bg-purple-700 rounded text-sm font-medium transition flex items-center gap-1">
+              <CheckSquare className="w-4 h-4" /> Validate
+            </button>
+          </div>
+        </div>
+        <ResponseDisplay response={response} loading={loading} />
+      </div>
+    </Card>
+  );
+}
+export default function App() {
+  const [activeTab, setActiveTab] = useState<Tab>('health');
+  const tabs: { id: Tab; label: string; icon: React.ElementType }[] = [
+    { id: 'health', label: 'Health', icon: Activity },
+    { id: 'users', label: 'Users', icon: Users },
+    { id: 'tasks', label: 'Tasks', icon: CheckSquare },
+    { id: 'tools', label: 'Tools', icon: Zap },
+  ];
+  return (
+    <div className="min-h-screen p-6">
+      <div className="max-w-4xl mx-auto">
+        <header className="mb-8">
+          <div className="flex items-center gap-3 mb-2">
+            <Server className="w-8 h-8 text-blue-400" />
+            <h1 className="text-3xl font-bold">Kozo API Tester</h1>
+          </div>
+          <p className="text-slate-400">Test the ${projectName} API endpoints with this interactive UI</p>
+        </header>
+        <nav className="flex gap-1 mb-6 bg-slate-800 p-1 rounded-lg">
+          {tabs.map(({ id, label, icon: Icon }) => (
+            <button
+              key={id}
+              onClick={() => setActiveTab(id)}
+              className={\`flex-1 flex items-center justify-center gap-2 px-4 py-2 rounded-md text-sm font-medium transition \${
+                activeTab === id
+                  ? 'bg-blue-600 text-white'
+                  : 'text-slate-400 hover:text-white hover:bg-slate-700'
+              }\`}
+            >
+              <Icon className="w-4 h-4" />
+              {label}
+            </button>
+          ))}
+        </nav>
+        <main>
+          {activeTab === 'health' && <HealthPanel />}
+          {activeTab === 'users' && <UsersPanel />}
+          {activeTab === 'tasks' && <TasksPanel />}
+          {activeTab === 'tools' && <ToolsPanel />}
+        </main>
+        <footer className="mt-8 pt-6 border-t border-slate-800 text-center text-slate-500 text-sm">
+          Built with Kozo + React + TailwindCSS
+        </footer>
+      </div>
+    </div>
+  );
+}
+`;
+}
+async function scaffoldFullstackReadme(projectDir, projectName) {
+  const readme = `# ${projectName}
+Full-stack application built with **Kozo** framework and React.
+## Project Structure
+\`\`\`
+apps/
+\u251C\u2500\u2500 api/                    # Backend Kozo
+\u2502   \u2514\u2500\u2500 src/
+\u2502       \u251C\u2500\u2500 data/          # Schemas e dati in-memory
+\u2502       \u2502   \u2514\u2500\u2500 index.ts
+\u2502       \u251C\u2500\u2500 routes/        # Routes organizzate per risorsa
+\u2502       \u2502   \u251C\u2500\u2500 health.ts  # Health check e stats
+\u2502       \u2502   \u251C\u2500\u2500 users.ts   # CRUD Users
+\u2502       \u2502   \u251C\u2500\u2500 posts.ts   # CRUD Posts
+\u2502       \u2502   \u251C\u2500\u2500 tasks.ts   # CRUD Tasks
+\u2502       \u2502   \u251C\u2500\u2500 tools.ts   # Utility endpoints
+\u2502       \u2502   \u2514\u2500\u2500 index.ts   # Route registration
+\u2502       \u2514\u2500\u2500 index.ts       # Entry point
+\u2514\u2500\u2500 web/                   # Frontend React
+    \u2514\u2500\u2500 src/
+        \u251C\u2500\u2500 App.tsx        # UI principale con tabs
+        \u251C\u2500\u2500 main.tsx       # Entry point
+        \u2514\u2500\u2500 index.css      # TailwindCSS v4
+\`\`\`
+## Technologies
+- **Backend**: Kozo (Hono-based), TypeScript, Zod
+- **Frontend**: React 18, TanStack Query, TailwindCSS v4, Lucide Icons
+- **Build**: Vite, pnpm workspace
+## Installation
+\`\`\`bash
+pnpm install
+\`\`\`
+## Development
+\`\`\`bash
+# Start API and Web in parallel
+pnpm dev
+# Or separately:
+pnpm --filter @${projectName}/api dev    # API on http://localhost:3000
+pnpm --filter @${projectName}/web dev    # Web on http://localhost:5173
+\`\`\`
+## API Endpoints
+### Health & Stats
+- \`GET /api/health\` - Health check with uptime
+- \`GET /api/stats\` - Global statistics
+### Users (Full CRUD)
+- \`GET /api/users\` - List all users
+- \`GET /api/users/:id\` - Get user by ID
+- \`POST /api/users\` - Create user
+- \`PUT /api/users/:id\` - Update user
+- \`DELETE /api/users/:id\` - Delete user
+### Posts (Full CRUD)
+- \`GET /api/posts?published=true\` - List posts (optional filter)
+- \`GET /api/posts/:id\` - Get post by ID
+- \`POST /api/posts\` - Create post
+- \`PUT /api/posts/:id\` - Update post
+- \`DELETE /api/posts/:id\` - Delete post
+### Tasks (Full CRUD)
+- \`GET /api/tasks?completed=true&priority=high\` - List tasks (optional filters)
+- \`GET /api/tasks/:id\` - Get task by ID
+- \`POST /api/tasks\` - Create task
+- \`PUT /api/tasks/:id\` - Update task
+- \`PATCH /api/tasks/:id/toggle\` - Toggle completion
+- \`DELETE /api/tasks/:id\` - Delete task
+### Tools
+- \`GET /api/echo?message=hello\` - Echo test
+- \`POST /api/validate\` - Zod validation (email + age)
+## Type Safety
+The frontend uses Hono RPC client for type-safe API calls:
+\`\`\`typescript
+const res = await client.api.users.$get();
+const users = await res.json(); // Fully typed!
+\`\`\`
+`;
+  await import_fs_extra.default.writeFile(import_node_path.default.join(projectDir, "README.md"), readme);
+}
 // src/utils/ascii-art.ts
 var import_picocolors = __toESM(require("picocolors"));
@@ -1112,39 +2294,64 @@ async function newCommand(projectName) {
           }
         });
       },
+      runtime: () => p.select({
+        message: "Target runtime",
+        options: [
+          { value: "node", label: "Node.js / Docker", hint: "Maximum compatibility (default)" },
+          { value: "cloudflare", label: "Cloudflare Workers", hint: "Edge-native, global deployment" },
+          { value: "bun", label: "Bun", hint: "Maximum local speed" }
+        ],
+        initialValue: "node"
+      }),
       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)" }
+          { value: "api-only", label: "API Only", hint: "Minimal, no database" }
         ]
       }),
       database: ({ results }) => {
-        if (results.template === "complete") {
+        if (results.template === "complete" || results.template === "api-only") {
           return Promise.resolve("none");
         }
         return p.select({
-          message: "Database provider",
+          message: "Database",
           options: [
-            { value: "postgresql", label: "PostgreSQL", hint: "Neon, Supabase, Railway" },
-            { value: "mysql", label: "MySQL", hint: "PlanetScale" },
-            { value: "sqlite", label: "SQLite", hint: "Turso, local dev" }
+            { value: "sqlite", label: "SQLite / Turso", hint: "Perfect for Edge and local dev" },
+            { value: "postgresql", label: "PostgreSQL + Drizzle", hint: "Standard Enterprise" },
+            { value: "mysql", label: "MySQL + Drizzle", hint: "PlanetScale compatible" }
           ]
         });
       },
+      frontend: () => p.select({
+        message: "Frontend",
+        options: [
+          { value: "none", label: "None (API only)", hint: "Backend microservice" },
+          { value: "react", label: "React (Vite + TanStack Query)", hint: "Full-stack type-safe" },
+          { value: "solid", label: "SolidJS (Vite)", hint: "Performance purist choice" },
+          { value: "vue", label: "Vue (Vite)", hint: "Progressive framework" }
+        ],
+        initialValue: "none"
+      }),
+      extras: () => p.multiselect({
+        message: "Extras",
+        options: [
+          { value: "docker", label: "Docker", hint: "Multi-stage Dockerfile" },
+          { value: "github-actions", label: "GitHub Actions", hint: "CI/CD pipeline" },
+          { value: "auth", label: "Authentication", hint: "JWT middleware + login routes" }
+        ],
+        required: false
+      }),
       packageSource: () => p.select({
-        message: "Package source for @kozojs/core",
+        message: "Package source",
         options: [
-          { value: "npm", label: "npm registry", hint: "Use published version (recommended)" },
-          { value: "local", label: "Local workspace", hint: "Link to local monorepo (for development)" }
+          { value: "npm", label: "npm registry", hint: "Published version (recommended)" },
+          { value: "local", label: "Local workspace", hint: "Link to monorepo (dev only)" }
         ],
         initialValue: "npm"
       }),
-      install: () => {
-        return Promise.resolve(true);
-      }
+      install: () => Promise.resolve(true)
     },
     {
       onCancel: () => {
@@ -1158,8 +2365,11 @@ async function newCommand(projectName) {
   try {
     await scaffoldProject({
       projectName: project.name,
-      database: project.database,
+      runtime: project.runtime,
       template: project.template,
+      database: project.database,
+      frontend: project.frontend,
+      extras: project.extras,
       packageSource: project.packageSource
     });
     s.stop("Project structure created!");
@@ -1200,10 +2410,295 @@ ${import_picocolors2.default.dim("Documentation:")} ${import_picocolors2.default
 `);
 }
+// src/commands/build.ts
+var import_execa2 = require("execa");
+var import_picocolors3 = __toESM(require("picocolors"));
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_node_path4 = __toESM(require("path"));
+// src/routing/manifest.ts
+var import_node_crypto = require("crypto");
+var import_node_fs2 = require("fs");
+var import_node_path3 = require("path");
+var import_glob2 = require("glob");
+// src/routing/scan.ts
+var import_glob = require("glob");
+var import_node_path2 = require("path");
+var import_node_fs = require("fs");
+var HTTP_METHODS = ["get", "post", "put", "patch", "delete"];
+function fileToRoute(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const lastDot = normalized.lastIndexOf(".");
+  const withoutExt = lastDot !== -1 ? normalized.slice(0, lastDot) : normalized;
+  const parts = withoutExt.split("/").filter(Boolean);
+  if (parts.length === 0) return null;
+  const last = parts[parts.length - 1].toLowerCase();
+  let method = "get";
+  let includeLast = true;
+  if (HTTP_METHODS.includes(last)) {
+    method = last;
+    includeLast = false;
+  } else if (last === "index") {
+    includeLast = false;
+  }
+  const segments = includeLast ? parts : parts.slice(0, -1);
+  const urlSegments = segments.map((seg) => {
+    if (seg.startsWith("[...") && seg.endsWith("]")) return "*";
+    if (seg.startsWith("[") && seg.endsWith("]")) return ":" + seg.slice(1, -1);
+    return seg;
+  });
+  const path3 = "/" + urlSegments.join("/");
+  return { path: path3, method };
+}
+function extractParams(urlPath) {
+  return urlPath.split("/").filter((seg) => seg.startsWith(":")).map((seg) => seg.slice(1));
+}
+function isRouteFile(file) {
+  const name = file.split("/").pop() ?? "";
+  if (name.startsWith("_")) return false;
+  if (name.includes(".test.") || name.includes(".spec.")) return false;
+  return true;
+}
+function detectSchemas(absolutePath) {
+  let source = "";
+  try {
+    source = (0, import_node_fs.readFileSync)(absolutePath, "utf8");
+  } catch {
+    return { hasBodySchema: false, hasQuerySchema: false };
+  }
+  const hasBodySchema = /export\s+(const|let|var)\s+body(Schema)?\s*[=:]/.test(source) || /export\s+\{[^}]*\bbody(Schema)?\b[^}]*\}/.test(source);
+  const hasQuerySchema = /export\s+(const|let|var)\s+query(Schema)?\s*[=:]/.test(source) || /export\s+\{[^}]*\bquery(Schema)?\b[^}]*\}/.test(source);
+  return { hasBodySchema, hasQuerySchema };
+}
+function routeScore(urlPath) {
+  const segments = urlPath.split("/").filter(Boolean);
+  let score = segments.length * 10;
+  for (const seg of segments) {
+    if (seg === "*") score -= 100;
+    else if (seg.startsWith(":")) score -= 5;
+    else score += 1;
+  }
+  return score;
+}
+async function scanRoutes(options) {
+  const { routesDir, verbose = false } = options;
+  const files = await (0, import_glob.glob)("**/*.{ts,js}", {
+    cwd: routesDir,
+    nodir: true,
+    ignore: ["**/_*.ts", "**/_*.js", "**/*.test.ts", "**/*.spec.ts", "**/*.test.js", "**/*.spec.js"]
+  });
+  const routes = [];
+  for (const file of files) {
+    if (!isRouteFile(file)) continue;
+    const parsed = fileToRoute(file);
+    if (!parsed) continue;
+    const absolutePath = (0, import_node_path2.join)(routesDir, file);
+    const { hasBodySchema, hasQuerySchema } = detectSchemas(absolutePath);
+    const params = extractParams(parsed.path);
+    routes.push({
+      path: parsed.path,
+      method: parsed.method,
+      handler: absolutePath,
+      relativePath: file,
+      params,
+      hasBodySchema,
+      hasQuerySchema
+    });
+  }
+  routes.sort((a, b) => routeScore(b.path) - routeScore(a.path));
+  if (verbose) {
+    for (const r of routes) {
+      const method = r.method.toUpperCase().padEnd(6);
+      console.log(`  ${method} ${r.path}  (${r.relativePath})`);
+    }
+  }
+  return routes;
+}
+// src/routing/manifest.ts
+async function hashRouteFiles(routesDir) {
+  const files = await (0, import_glob2.glob)("**/*.{ts,js}", {
+    cwd: routesDir,
+    nodir: true,
+    ignore: ["**/_*.ts", "**/_*.js", "**/*.test.ts", "**/*.spec.ts", "**/*.test.js", "**/*.spec.js"]
+  });
+  files.sort();
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  for (const file of files) {
+    hash.update(file);
+    try {
+      const content = (0, import_node_fs2.readFileSync)((0, import_node_path3.join)(routesDir, file));
+      hash.update(content);
+    } catch {
+    }
+  }
+  return hash.digest("hex");
+}
+function readExistingManifest(manifestPath) {
+  if (!(0, import_node_fs2.existsSync)(manifestPath)) return null;
+  try {
+    const raw = (0, import_node_fs2.readFileSync)(manifestPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function generateManifest(options) {
+  const {
+    routesDir,
+    projectRoot,
+    outputPath = (0, import_node_path3.join)(projectRoot, "routes-manifest.json"),
+    cache = true,
+    verbose = false
+  } = options;
+  const contentHash = await hashRouteFiles(routesDir);
+  if (cache) {
+    const existing = readExistingManifest(outputPath);
+    if (existing && existing.contentHash === contentHash && existing.version === MANIFEST_VERSION) {
+      if (verbose) {
+        console.log(`  \u2713 routes-manifest.json up-to-date (hash: ${contentHash.slice(0, 8)}\u2026)`);
+      }
+      return existing;
+    }
+  }
+  if (verbose) {
+    console.log(`  Scanning routes in: ${routesDir}`);
+  }
+  const scanned = await scanRoutes({ routesDir, verbose: false });
+  const entries = scanned.map((r) => ({
+    path: r.path,
+    method: r.method,
+    handler: r.relativePath,
+    // relative to routesDir; callers can join with projectRoot
+    params: r.params,
+    hasBodySchema: r.hasBodySchema,
+    hasQuerySchema: r.hasQuerySchema
+  }));
+  const manifest = {
+    version: MANIFEST_VERSION,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    contentHash,
+    routes: entries
+  };
+  const dir = (0, import_node_path3.dirname)(outputPath);
+  if (!(0, import_node_fs2.existsSync)(dir)) {
+    (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+  }
+  (0, import_node_fs2.writeFileSync)(outputPath, JSON.stringify(manifest, null, 2) + "\n", "utf8");
+  if (verbose) {
+    console.log(`  \u2713 Generated routes-manifest.json (${entries.length} routes, hash: ${contentHash.slice(0, 8)}\u2026)`);
+  }
+  return manifest;
+}
+var MANIFEST_VERSION = 1;
+// src/commands/build.ts
+function printBox(title) {
+  const width = 50;
+  const pad = Math.max(0, Math.floor((width - title.length) / 2));
+  const line = "\u2500".repeat(width);
+  console.log(import_picocolors3.default.cyan(`\u250C${line}\u2510`));
+  console.log(import_picocolors3.default.cyan("\u2502") + " ".repeat(pad) + import_picocolors3.default.bold(title) + " ".repeat(width - pad - title.length) + import_picocolors3.default.cyan("\u2502"));
+  console.log(import_picocolors3.default.cyan(`\u2514${line}\u2518`));
+  console.log();
+}
+function step(n, total, label) {
+  console.log(import_picocolors3.default.dim(`[${n}/${total}]`) + " " + import_picocolors3.default.cyan("\u2192") + " " + label);
+}
+function ok(label) {
+  console.log(import_picocolors3.default.green("  \u2713") + " " + label);
+}
+function fail(label, err) {
+  console.log(import_picocolors3.default.red("  \u2717") + " " + label);
+  if (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(import_picocolors3.default.dim("    " + msg));
+  }
+}
+async function buildCommand(options = {}) {
+  console.clear();
+  printBox("Kozo Build");
+  const cwd = process.cwd();
+  const TOTAL_STEPS = options.noManifest ? 3 : 4;
+  let currentStep = 0;
+  currentStep++;
+  step(currentStep, TOTAL_STEPS, "Checking project structure\u2026");
+  if (!import_fs_extra2.default.existsSync(import_node_path4.default.join(cwd, "package.json"))) {
+    fail("No package.json found. Run this command inside a Kozo project.");
+    process.exit(1);
+  }
+  if (!import_fs_extra2.default.existsSync(import_node_path4.default.join(cwd, "node_modules"))) {
+    fail("Dependencies not installed. Run `npm install` first.");
+    process.exit(1);
+  }
+  ok("Project structure OK");
+  currentStep++;
+  step(currentStep, TOTAL_STEPS, "Cleaning previous build\u2026");
+  try {
+    await import_fs_extra2.default.remove(import_node_path4.default.join(cwd, "dist"));
+    ok("dist/ cleaned");
+  } catch (err) {
+    fail("Failed to clean dist/", err);
+    process.exit(1);
+  }
+  if (!options.noManifest) {
+    currentStep++;
+    step(currentStep, TOTAL_STEPS, "Generating routes manifest\u2026");
+    const routesDirRel = options.routesDir ?? "src/routes";
+    const routesDirAbs = import_node_path4.default.join(cwd, routesDirRel);
+    if (!import_fs_extra2.default.existsSync(routesDirAbs)) {
+      console.log(import_picocolors3.default.dim(`  \u26A0  Routes directory not found (${routesDirRel}), skipping manifest.`));
+    } else {
+      try {
+        const manifestOutAbs = options.manifestOut ? import_node_path4.default.join(cwd, options.manifestOut) : import_node_path4.default.join(cwd, "routes-manifest.json");
+        const manifest = await generateManifest({
+          routesDir: routesDirAbs,
+          projectRoot: cwd,
+          outputPath: manifestOutAbs,
+          cache: !options.forceManifest,
+          verbose: true
+        });
+        ok(`Manifest ready \u2014 ${manifest.routes.length} route(s)`);
+      } catch (err) {
+        fail("Manifest generation failed", err);
+        console.log(import_picocolors3.default.dim("  Continuing build without manifest\u2026"));
+      }
+    }
+  }
+  currentStep++;
+  step(currentStep, TOTAL_STEPS, "Compiling with tsup\u2026");
+  try {
+    const tsupArgs = ["tsup", ...options.tsupArgs ?? []];
+    await (0, import_execa2.execa)("npx", tsupArgs, {
+      cwd,
+      stdio: "inherit",
+      env: { ...process.env, NODE_ENV: "production" }
+    });
+    ok("Compilation complete");
+  } catch (err) {
+    fail("tsup compilation failed", err);
+    process.exit(1);
+  }
+  console.log();
+  console.log(import_picocolors3.default.green("\u2705  Build successful"));
+  console.log();
+}
 // 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.command("build").description("Build the project (generates routes manifest then compiles with tsup)").option("--no-manifest", "Skip routes-manifest.json generation").option("--force-manifest", "Force manifest regeneration even if routes are unchanged").option("--routes-dir <dir>", "Routes directory relative to project root", "src/routes").option("--manifest-out <path>", "Output path for routes-manifest.json relative to project root").allowUnknownOption().action(async (opts, cmd) => {
+  const tsupArgs = cmd.args.length > 0 ? cmd.args : void 0;
+  await buildCommand({
+    noManifest: opts.noManifest === false || opts.manifest === false,
+    forceManifest: opts.forceManifest ?? false,
+    routesDir: opts.routesDir,
+    manifestOut: opts.manifestOut,
+    tsupArgs
+  });
+});
 program.parse();