@kozojs/cli 0.1.19 → 0.1.21

package/lib/index.js

@@ -1494,31 +1494,32 @@ ${auth ? "JWT_SECRET=change-me-to-a-random-secret-at-least-32-chars\n" : ""}`;
   await import_fs_extra.default.writeJSON(import_node_path.default.join(apiDir, "tsconfig.json"), tsconfig, { spaces: 2 });
   const authImport = auth ? `import { authenticateJWT } from '@kozojs/auth';
 ` : "";
-  const servicesSetup = "\nconst services = {};\n";
   const authMiddleware = auth ? `
-// JWT protects all /api/* routes except /api/auth/*
+// JWT protects all /api/* routes except public ones
 const JWT_SECRET = process.env.JWT_SECRET || 'change-me';
 const _jwt = authenticateJWT(JWT_SECRET, { prefix: '' });
+const publicPaths = ['/api/auth/', '/api/health', '/api/stats'];
 app.getApp().use('/api/*', (c, next) => {
-  if (c.req.path.startsWith('/api/auth/')) return next();
+  if (publicPaths.some(p => c.req.path.startsWith(p))) return next();
   return _jwt(c, next);
 });
 ` : "";
-  await import_fs_extra.default.writeFile(import_node_path.default.join(apiDir, "src", "index.ts"), `import 'dotenv/config';
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "index.ts"), `import 'dotenv/config';
 import { createKozo } from '@kozojs/core';
-${authImport}import { registerRoutes } from './routes/index.js';
-${servicesSetup}
-const app = createKozo({ port: 3000, services });
-${authMiddleware}
-registerRoutes(app);
+${authImport}import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PORT = Number(process.env.PORT) || 3000;
+const app = createKozo({ port: PORT });
+${authMiddleware}await app.loadRoutes(join(__dirname, 'routes'));
 
 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');
+console.log(\`\u{1F525} ${projectName} API on http://localhost:\${PORT}\`);
 await app.listen();
 `);
-  await import_fs_extra.default.writeFile(import_node_path.default.join(apiDir, "src", "data", "index.ts"), `import { z } from 'zod';
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "schemas", "index.ts"), `import { z } from 'zod';
 
 export const UserSchema = z.object({
   id: z.string(),
@@ -1528,6 +1529,18 @@ export const UserSchema = z.object({
   createdAt: z.string().optional(),
 });
 
+export const CreateUserBody = z.object({
+  name: z.string().min(1),
+  email: z.string().email(),
+  role: z.enum(['admin', 'user']).optional(),
+});
+
+export const UpdateUserBody = z.object({
+  name: z.string().optional(),
+  email: z.string().email().optional(),
+  role: z.enum(['admin', 'user']).optional(),
+});
+
 export const PostSchema = z.object({
   id: z.string(),
   title: z.string(),
@@ -1537,6 +1550,19 @@ export const PostSchema = z.object({
   createdAt: z.string().optional(),
 });
 
+export const CreatePostBody = z.object({
+  title: z.string().min(1),
+  content: z.string().optional(),
+  authorId: z.string().optional(),
+  published: z.boolean().optional(),
+});
+
+export const UpdatePostBody = z.object({
+  title: z.string().optional(),
+  content: z.string().optional(),
+  published: z.boolean().optional(),
+});
+
 export const TaskSchema = z.object({
   id: z.string(),
   title: z.string(),
@@ -1545,302 +1571,415 @@ export const TaskSchema = z.object({
   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 CreateTaskBody = z.object({
+  title: z.string().min(1),
+  priority: z.enum(['low', 'medium', 'high']).optional(),
+});
+
+export const UpdateTaskBody = z.object({
+  title: z.string().optional(),
+  completed: z.boolean().optional(),
+  priority: z.enum(['low', 'medium', 'high']).optional(),
+});
+`);
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "data", "index.ts"), `export const users = [
+  { id: '1', name: 'Alice', email: 'alice@example.com', role: 'admin' as const, createdAt: new Date().toISOString() },
+  { id: '2', name: 'Bob', email: 'bob@example.com', role: 'user' as const, createdAt: new Date().toISOString() },
 ];
 
-export const posts: z.infer<typeof PostSchema>[] = [
+export const posts = [
   { 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() },
+export const tasks = [
+  { id: '1', title: 'Setup project', completed: true, priority: 'high' as const, createdAt: new Date().toISOString() },
+  { id: '2', title: 'Write tests', completed: false, priority: 'medium' as const, createdAt: new Date().toISOString() },
+  { id: '3', title: 'Deploy', completed: false, priority: 'low' as const, createdAt: new Date().toISOString() },
 ];
 `);
-  const authRoutesImport = auth ? `import { registerAuthRoutes } from './auth';
-` : "";
-  const authRoutesCall = auth ? `  registerAuthRoutes(app); // Public auth endpoint must register before JWT middleware
-` : "";
-  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';
-${authRoutesImport}
-export function registerRoutes(app: Kozo) {
-${authRoutesCall}  registerHealthRoutes(app);
-  registerUserRoutes(app);
-  registerPostRoutes(app);
-  registerTaskRoutes(app);
-  registerToolRoutes(app);
-}
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "health", "get.ts"), `import { z } from 'zod';
+
+export const schema = {
+  response: z.object({
+    status: z.string(),
+    timestamp: z.string(),
+    version: z.string(),
+    uptime: z.number(),
+  }),
+};
+
+export default async () => ({
+  status: 'ok',
+  timestamp: new Date().toISOString(),
+  version: '1.0.0',
+  uptime: process.uptime(),
+});
 `);
-  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';
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "stats", "get.ts"), `import { z } from 'zod';
+import { users, posts, tasks } from '../../../data/index.js';
 
-export function registerHealthRoutes(app: Kozo) {
-  app.get('/api/health', {}, () => ({
-    status: 'ok',
-    timestamp: new Date().toISOString(),
-    version: '1.0.0',
-    uptime: process.uptime(),
-  }));
+export const schema = {
+  response: z.object({
+    users: z.number(),
+    posts: z.number(),
+    tasks: z.number(),
+    publishedPosts: z.number(),
+    completedTasks: z.number(),
+  }),
+};
 
-  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,
-  }));
-}
+export default async () => ({
+  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';
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "echo", "get.ts"), `import { z } from 'zod';
 
-export function registerUserRoutes(app: Kozo) {
-  app.get('/api/users', {
-    response: z.array(UserSchema),
-  }, () => users);
+export const schema = {
+  query: z.object({ message: z.string() }),
+  response: z.object({
+    echo: z.string(),
+    timestamp: z.string(),
+  }),
+};
 
-  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;
-  });
+export default async ({ query }: { query: { message: string } }) => ({
+  echo: query.message,
+  timestamp: new Date().toISOString(),
+});
+`);
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "validate", "post.ts"), `import { z } from 'zod';
 
-  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;
-  });
+export const schema = {
+  body: z.object({
+    email: z.string().email(),
+    age: z.number().min(0).max(150),
+  }),
+  response: z.object({
+    valid: z.boolean(),
+    data: z.object({ email: z.string(), age: z.number() }),
+  }),
+};
 
-  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];
-  });
+export default async ({ body }: { body: { email: string; age: number } }) => ({
+  valid: true,
+  data: body,
+});
+`);
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "users", "get.ts"), `import { z } from 'zod';
+import { users } from '../../../data/index.js';
+import { UserSchema } from '../../../schemas/index.js';
 
-  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' };
-  });
-}
+export const schema = {
+  response: z.array(UserSchema),
+};
+
+export default async () => users;
 `);
-  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';
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "users", "post.ts"), `import { users } from '../../../data/index.js';
+import { UserSchema, CreateUserBody } from '../../../schemas/index.js';
 
-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;
-  });
+export const schema = {
+  body: CreateUserBody,
+  response: UserSchema,
+};
 
-  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;
-  });
+export default async ({ body }: { body: { name: string; email: string; role?: 'admin' | 'user' } }) => {
+  const newUser = {
+    id: String(Date.now()),
+    name: body.name,
+    email: body.email,
+    role: body.role ?? ('user' as const),
+    createdAt: new Date().toISOString(),
+  };
+  users.push(newUser);
+  return newUser;
+};
+`);
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "users", "[id]", "get.ts"), `import { z } from 'zod';
+import { KozoError } from '@kozojs/core';
+import { users } from '../../../../data/index.js';
+import { UserSchema } from '../../../../schemas/index.js';
 
-  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;
-  });
+export const schema = {
+  params: z.object({ id: z.string() }),
+  response: UserSchema,
+};
 
-  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];
-  });
+export default async ({ params }: { params: { id: string } }) => {
+  const user = users.find(u => u.id === params.id);
+  if (!user) throw new KozoError('User not found', 404, 'NOT_FOUND');
+  return user;
+};
+`);
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "users", "[id]", "put.ts"), `import { z } from 'zod';
+import { KozoError } from '@kozojs/core';
+import { users } from '../../../../data/index.js';
+import { UserSchema, UpdateUserBody } from '../../../../schemas/index.js';
 
-  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' };
-  });
-}
+export const schema = {
+  params: z.object({ id: z.string() }),
+  body: UpdateUserBody,
+  response: UserSchema,
+};
+
+export default async ({
+  params,
+  body,
+}: {
+  params: { id: string };
+  body: { name?: string; email?: string; role?: 'admin' | 'user' };
+}) => {
+  const idx = users.findIndex(u => u.id === params.id);
+  if (idx === -1) throw new KozoError('User not found', 404, 'NOT_FOUND');
+  users[idx] = { ...users[idx], ...body };
+  return users[idx];
+};
 `);
-  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';
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "users", "[id]", "delete.ts"), `import { z } from 'zod';
+import { KozoError } from '@kozojs/core';
+import { users } from '../../../../data/index.js';
 
-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;
-  });
+export const schema = {
+  params: z.object({ id: z.string() }),
+  response: z.object({ success: z.boolean(), message: z.string() }),
+};
 
-  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;
-  });
+export default async ({ params }: { params: { id: string } }) => {
+  const idx = users.findIndex(u => u.id === params.id);
+  if (idx === -1) throw new KozoError('User not found', 404, 'NOT_FOUND');
+  users.splice(idx, 1);
+  return { success: true, message: 'User deleted' };
+};
+`);
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "posts", "get.ts"), `import { z } from 'zod';
+import { posts } from '../../../data/index.js';
+import { PostSchema } from '../../../schemas/index.js';
 
-  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;
-  });
+export const schema = {
+  query: z.object({ published: z.coerce.boolean().optional() }),
+  response: z.array(PostSchema),
+};
 
-  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];
-  });
+export default async ({ query }: { query: { published?: boolean } }) => {
+  if (query.published !== undefined) {
+    return posts.filter(p => p.published === query.published);
+  }
+  return posts;
+};
+`);
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "posts", "post.ts"), `import { posts, users } from '../../../data/index.js';
+import { PostSchema, CreatePostBody } from '../../../schemas/index.js';
 
-  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];
-  });
+export const schema = {
+  body: CreatePostBody,
+  response: PostSchema,
+};
 
-  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' };
-  });
-}
+export default async ({
+  body,
+}: {
+  body: { title: string; content?: string; authorId?: string; published?: boolean };
+}) => {
+  const authorId = body.authorId ?? users[0]?.id ?? 'unknown';
+  const newPost = {
+    id: String(Date.now()),
+    title: body.title,
+    content: body.content ?? '',
+    authorId,
+    published: body.published ?? false,
+    createdAt: new Date().toISOString(),
+  };
+  posts.push(newPost);
+  return newPost;
+};
 `);
-  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';
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "posts", "[id]", "get.ts"), `import { z } from 'zod';
+import { KozoError } from '@kozojs/core';
+import { posts } from '../../../../data/index.js';
+import { PostSchema } from '../../../../schemas/index.js';
 
-export function registerToolRoutes(app: Kozo) {
-  app.get('/api/echo', {
-    query: z.object({ message: z.string() }),
-  }, (c) => ({
-    echo: c.query.message,
-    timestamp: new Date().toISOString(),
-  }));
+export const schema = {
+  params: z.object({ id: z.string() }),
+  response: PostSchema,
+};
 
-  app.post('/api/validate', {
-    body: z.object({
-      email: z.string().email(),
-      age: z.number().min(0).max(150),
-    }),
-  }, (c) => ({
-    valid: true,
-    data: c.body,
-  }));
-}
+export default async ({ params }: { params: { id: string } }) => {
+  const post = posts.find(p => p.id === params.id);
+  if (!post) throw new KozoError('Post not found', 404, 'NOT_FOUND');
+  return post;
+};
+`);
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "posts", "[id]", "put.ts"), `import { z } from 'zod';
+import { KozoError } from '@kozojs/core';
+import { posts } from '../../../../data/index.js';
+import { PostSchema, UpdatePostBody } from '../../../../schemas/index.js';
+
+export const schema = {
+  params: z.object({ id: z.string() }),
+  body: UpdatePostBody,
+  response: PostSchema,
+};
+
+export default async ({
+  params,
+  body,
+}: {
+  params: { id: string };
+  body: { title?: string; content?: string; published?: boolean };
+}) => {
+  const idx = posts.findIndex(p => p.id === params.id);
+  if (idx === -1) throw new KozoError('Post not found', 404, 'NOT_FOUND');
+  posts[idx] = { ...posts[idx], ...body };
+  return posts[idx];
+};
+`);
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "posts", "[id]", "delete.ts"), `import { z } from 'zod';
+import { KozoError } from '@kozojs/core';
+import { posts } from '../../../../data/index.js';
+
+export const schema = {
+  params: z.object({ id: z.string() }),
+  response: z.object({ success: z.boolean(), message: z.string() }),
+};
+
+export default async ({ params }: { params: { id: string } }) => {
+  const idx = posts.findIndex(p => p.id === params.id);
+  if (idx === -1) throw new KozoError('Post not found', 404, 'NOT_FOUND');
+  posts.splice(idx, 1);
+  return { success: true, message: 'Post deleted' };
+};
+`);
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "tasks", "get.ts"), `import { z } from 'zod';
+import { tasks } from '../../../data/index.js';
+import { TaskSchema } from '../../../schemas/index.js';
+
+export const schema = {
+  query: z.object({
+    completed: z.coerce.boolean().optional(),
+    priority: z.enum(['low', 'medium', 'high']).optional(),
+  }),
+  response: z.array(TaskSchema),
+};
+
+export default async ({
+  query,
+}: {
+  query: { completed?: boolean; priority?: 'low' | 'medium' | 'high' };
+}) => {
+  let result = [...tasks];
+  if (query.completed !== undefined) {
+    result = result.filter(t => t.completed === query.completed);
+  }
+  if (query.priority) {
+    result = result.filter(t => t.priority === query.priority);
+  }
+  return result;
+};
+`);
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "tasks", "post.ts"), `import { tasks } from '../../../data/index.js';
+import { TaskSchema, CreateTaskBody } from '../../../schemas/index.js';
+
+export const schema = {
+  body: CreateTaskBody,
+  response: TaskSchema,
+};
+
+export default async ({
+  body,
+}: {
+  body: { title: string; priority?: 'low' | 'medium' | 'high' };
+}) => {
+  const newTask = {
+    id: String(Date.now()),
+    title: body.title,
+    completed: false,
+    priority: body.priority ?? ('medium' as const),
+    createdAt: new Date().toISOString(),
+  };
+  tasks.push(newTask);
+  return newTask;
+};
+`);
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "tasks", "[id]", "get.ts"), `import { z } from 'zod';
+import { KozoError } from '@kozojs/core';
+import { tasks } from '../../../../data/index.js';
+import { TaskSchema } from '../../../../schemas/index.js';
+
+export const schema = {
+  params: z.object({ id: z.string() }),
+  response: TaskSchema,
+};
+
+export default async ({ params }: { params: { id: string } }) => {
+  const task = tasks.find(t => t.id === params.id);
+  if (!task) throw new KozoError('Task not found', 404, 'NOT_FOUND');
+  return task;
+};
+`);
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "tasks", "[id]", "put.ts"), `import { z } from 'zod';
+import { KozoError } from '@kozojs/core';
+import { tasks } from '../../../../data/index.js';
+import { TaskSchema, UpdateTaskBody } from '../../../../schemas/index.js';
+
+export const schema = {
+  params: z.object({ id: z.string() }),
+  body: UpdateTaskBody,
+  response: TaskSchema,
+};
+
+export default async ({
+  params,
+  body,
+}: {
+  params: { id: string };
+  body: { title?: string; completed?: boolean; priority?: 'low' | 'medium' | 'high' };
+}) => {
+  const idx = tasks.findIndex(t => t.id === params.id);
+  if (idx === -1) throw new KozoError('Task not found', 404, 'NOT_FOUND');
+  tasks[idx] = { ...tasks[idx], ...body };
+  return tasks[idx];
+};
+`);
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "tasks", "[id]", "delete.ts"), `import { z } from 'zod';
+import { KozoError } from '@kozojs/core';
+import { tasks } from '../../../../data/index.js';
+
+export const schema = {
+  params: z.object({ id: z.string() }),
+  response: z.object({ success: z.boolean(), message: z.string() }),
+};
+
+export default async ({ params }: { params: { id: string } }) => {
+  const idx = tasks.findIndex(t => t.id === params.id);
+  if (idx === -1) throw new KozoError('Task not found', 404, 'NOT_FOUND');
+  tasks.splice(idx, 1);
+  return { success: true, message: 'Task deleted' };
+};
+`);
+  await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "tasks", "[id]", "toggle", "patch.ts"), `import { z } from 'zod';
+import { KozoError } from '@kozojs/core';
+import { tasks } from '../../../../../data/index.js';
+import { TaskSchema } from '../../../../../schemas/index.js';
+
+export const schema = {
+  params: z.object({ id: z.string() }),
+  response: TaskSchema,
+};
+
+export default async ({ params }: { params: { id: string } }) => {
+  const idx = tasks.findIndex(t => t.id === params.id);
+  if (idx === -1) throw new KozoError('Task not found', 404, 'NOT_FOUND');
+  tasks[idx].completed = !tasks[idx].completed;
+  return tasks[idx];
+};
 `);
   if (auth) {
-    await import_fs_extra.default.writeFile(import_node_path.default.join(apiDir, "src", "routes", "auth.ts"), `import type { Kozo } from '@kozojs/core';
-import { z } from 'zod';
+    await import_fs_extra.default.outputFile(import_node_path.default.join(apiDir, "src", "routes", "api", "auth", "login", "post.ts"), `import { z } from 'zod';
 import { createJWT, UnauthorizedError } from '@kozojs/auth';
 
 const JWT_SECRET = process.env.JWT_SECRET || 'change-me';
@@ -1850,21 +1989,31 @@ const DEMO_USERS = [
   { email: 'user@demo.com', password: 'user123', role: 'user', name: 'User' },
 ];
 
-export function registerAuthRoutes(app: Kozo) {
-  app.post('/api/auth/login', {
-    body: z.object({ email: z.string().email(), password: z.string() }),
-  }, async (c) => {
-    const { email, password } = c.body;
-    const user = DEMO_USERS.find(u => u.email === email && u.password === password);
-    if (!user) throw new UnauthorizedError('Invalid credentials');
-    const token = await createJWT(
-      { email: user.email, role: user.role, name: user.name },
-      JWT_SECRET,
-      { expiresIn: '24h' },
-    );
-    return { token, user: { email: user.email, role: user.role, name: user.name } };
-  });
-}
+export const schema = {
+  body: z.object({
+    email: z.string().email(),
+    password: z.string(),
+  }),
+  response: z.object({
+    token: z.string(),
+    user: z.object({
+      email: z.string(),
+      role: z.string(),
+      name: z.string(),
+    }),
+  }),
+};
+
+export default async ({ body }: { body: { email: string; password: string } }) => {
+  const user = DEMO_USERS.find(u => u.email === body.email && u.password === body.password);
+  if (!user) throw new UnauthorizedError('Invalid credentials');
+  const token = await createJWT(
+    { email: user.email, role: user.role, name: user.name },
+    JWT_SECRET,
+    { expiresIn: '24h' },
+  );
+  return { token, user: { email: user.email, role: user.role, name: user.name } };
+};
 `);
   }
 }

package/package.json

@@ -1,51 +1,51 @@
-{
-  "name": "@kozojs/cli",
-  "version": "0.1.19",
-  "description": "CLI to scaffold new Kozo Framework projects - The next-gen TypeScript Backend Framework",
-  "bin": {
-    "create-kozo": "./lib/index.js",
-    "kozo": "./lib/index.js"
-  },
-  "main": "./lib/index.js",
-  "types": "./lib/index.d.ts",
-  "files": [
-    "lib",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch"
-  },
-  "keywords": [
-    "kozo",
-    "framework",
-    "backend",
-    "typescript",
-    "hono",
-    "api",
-    "rest",
-    "cli",
-    "scaffold",
-    "generator"
-  ],
-  "author": "Kozo Team",
-  "license": "MIT",
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "dependencies": {
-    "@clack/prompts": "^0.8.0",
-    "commander": "^12.0.0",
-    "picocolors": "^1.1.0",
-    "ora": "^8.1.0",
-    "execa": "^9.5.0",
-    "fs-extra": "^11.2.0",
-    "glob": "^11.0.0"
-  },
-  "devDependencies": {
-    "@types/fs-extra": "^11.0.4",
-    "@types/node": "^22.0.0",
-    "tsup": "^8.3.0",
-    "typescript": "^5.6.0"
-  }
-}
+{
+  "name": "@kozojs/cli",
+  "version": "0.1.21",
+  "description": "CLI to scaffold new Kozo Framework projects - The next-gen TypeScript Backend Framework",
+  "bin": {
+    "create-kozo": "./lib/index.js",
+    "kozo": "./lib/index.js"
+  },
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "files": [
+    "lib",
+    "README.md"
+  ],
+  "keywords": [
+    "kozo",
+    "framework",
+    "backend",
+    "typescript",
+    "hono",
+    "api",
+    "rest",
+    "cli",
+    "scaffold",
+    "generator"
+  ],
+  "author": "Kozo Team",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.8.0",
+    "commander": "^12.0.0",
+    "picocolors": "^1.1.0",
+    "ora": "^8.1.0",
+    "execa": "^9.5.0",
+    "fs-extra": "^11.2.0",
+    "glob": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.0.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}