@kozojs/cli 0.1.31 → 0.1.32

package/lib/index.js

@@ -3880,8 +3880,8 @@ function fileToRoute(filePath) {
     if (seg.startsWith("[") && seg.endsWith("]")) return ":" + seg.slice(1, -1);
     return seg;
   });
-  const path7 = "/" + urlSegments.join("/");
-  return { path: path7, method };
+  const path9 = "/" + urlSegments.join("/");
+  return { path: path9, method };
 }
 function extractParams(urlPath) {
   return urlPath.split("/").filter((seg) => seg.startsWith(":")).map((seg) => seg.slice(1));
@@ -4117,6 +4117,285 @@ async function buildCommand(options = {}) {
   console.log();
 }
 
+// src/commands/dev.ts
+var import_child_process = require("child_process");
+var import_chokidar = __toESM(require("chokidar"));
+var import_picocolors4 = __toESM(require("picocolors"));
+var import_fs_extra7 = __toESM(require("fs-extra"));
+var import_path = __toESM(require("path"));
+async function devCommand() {
+  console.clear();
+  printBox2("Kozo Development Server");
+  await runStep(1, 4, "Checking project structure...", async () => {
+    if (!import_fs_extra7.default.existsSync(import_path.default.join(process.cwd(), "package.json"))) {
+      throw new Error("No package.json found. Run this command in a Kozo project.");
+    }
+  });
+  await runStep(2, 4, "Checking dependencies...", async () => {
+    if (!import_fs_extra7.default.existsSync(import_path.default.join(process.cwd(), "node_modules"))) {
+      throw new Error("Dependencies not installed. Run: pnpm install");
+    }
+    await sleep(300);
+  });
+  const routesDir = resolveRoutesDir(process.cwd());
+  await runStep(3, 4, "Scanning routes...", async () => {
+    if (routesDir) {
+      await generateManifest({ routesDir, useCache: false, verbose: false });
+    }
+    await sleep(300);
+  });
+  await runStep(4, 4, "Starting server on port 3000...", async () => {
+    await sleep(200);
+  });
+  console.log(import_picocolors4.default.gray("\n\u2139  \u{1F440} Watching for file changes... (Ctrl+C to stop)\n"));
+  console.log(import_picocolors4.default.dim("\u2500".repeat(50)) + "\n");
+  const child = (0, import_child_process.spawn)("npx", ["tsx", "watch", "src/index.ts"], {
+    stdio: "inherit",
+    shell: true,
+    cwd: process.cwd(),
+    env: { ...process.env, FORCE_COLOR: "1" }
+  });
+  child.on("error", (err) => {
+    console.error(import_picocolors4.default.red("\n\u274C Failed to start server"));
+    console.error(err);
+    process.exit(1);
+  });
+  child.on("close", (code) => {
+    if (code === 0 || code === null) {
+      console.log("\n" + import_picocolors4.default.dim("Server stopped"));
+    }
+    process.exit(code ?? 0);
+  });
+  if (routesDir) {
+    startRouteWatcher(routesDir);
+  }
+  process.on("SIGINT", () => {
+    console.log("\n" + import_picocolors4.default.yellow("\u23F9  Stopping Kozo dev server..."));
+    child.kill("SIGTERM");
+    process.exit(0);
+  });
+}
+function startRouteWatcher(routesDir) {
+  let debounceTimer = null;
+  const watcher = import_chokidar.default.watch(routesDir, {
+    ignored: /(^|[/\\])\..|(\.test\.[tj]s$)|(\.spec\.[tj]s$)/,
+    persistent: true,
+    ignoreInitial: true,
+    // don't fire for files already present at startup
+    awaitWriteFinish: {
+      stabilityThreshold: 80,
+      pollInterval: 50
+    }
+  });
+  const handleChange = (eventType, filePath) => {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(async () => {
+      try {
+        const manifest = await generateManifest({
+          routesDir,
+          useCache: false,
+          // always regenerate on file change
+          verbose: false
+        });
+        const count = manifest.routes.length;
+        console.log(
+          import_picocolors4.default.cyan("[Kozo]") + " \u2728 Routes updated " + import_picocolors4.default.dim(`(${count} found)`) + import_picocolors4.default.dim(` \u2014 ${import_path.default.relative(process.cwd(), filePath)}`)
+        );
+      } catch (err) {
+        console.error(
+          import_picocolors4.default.red("[Kozo] \u274C Failed to regenerate routes manifest:"),
+          err.message
+        );
+      }
+    }, 120);
+  };
+  watcher.on("add", (p3) => handleChange("add", p3)).on("change", (p3) => handleChange("change", p3)).on("unlink", (p3) => handleChange("unlink", p3)).on("error", (err) => console.error(import_picocolors4.default.red("[Kozo] Watcher error:"), err));
+  return watcher;
+}
+function resolveRoutesDir(cwd) {
+  const candidates = [
+    import_path.default.join(cwd, "src", "routes"),
+    import_path.default.join(cwd, "routes"),
+    import_path.default.join(cwd, "src", "app", "routes"),
+    import_path.default.join(cwd, "app", "routes")
+  ];
+  for (const candidate of candidates) {
+    if (import_fs_extra7.default.existsSync(candidate) && import_fs_extra7.default.statSync(candidate).isDirectory()) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function printBox2(title) {
+  const width = 50;
+  const pad = Math.floor((width - title.length) / 2);
+  const line = "\u2500".repeat(width);
+  console.log(import_picocolors4.default.cyan("\u250C" + line + "\u2510"));
+  console.log(import_picocolors4.default.cyan("\u2502") + " ".repeat(pad) + import_picocolors4.default.bold(title) + " ".repeat(width - pad - title.length) + import_picocolors4.default.cyan("\u2502"));
+  console.log(import_picocolors4.default.cyan("\u2514" + line + "\u2518"));
+  console.log();
+}
+async function runStep(step2, total, label, fn) {
+  const prefix = import_picocolors4.default.dim(`[${step2}/${total}]`);
+  process.stdout.write(`${prefix} ${label}`);
+  try {
+    await fn();
+    process.stdout.write(" " + import_picocolors4.default.green("\u2713") + "\n");
+  } catch (err) {
+    process.stdout.write(" " + import_picocolors4.default.red("\u2717") + "\n");
+    console.error(import_picocolors4.default.red(`
+  Error: ${err.message}`));
+    process.exit(1);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/commands/generate.ts
+var p2 = __toESM(require("@clack/prompts"));
+var import_picocolors5 = __toESM(require("picocolors"));
+var import_fs_extra8 = __toESM(require("fs-extra"));
+var import_node_path9 = __toESM(require("path"));
+var ROUTE_TEMPLATE = `import { z } from 'zod';
+import type { HandlerContext } from '@kozo/core';
+
+// Validation schema (optional)
+export const schema = {
+  body: z.object({
+    // Define your schema here
+  })
+};
+
+type Body = z.infer<typeof schema.body>;
+
+export default async ({ body, services }: HandlerContext<Body>) => {
+  // TODO: Implement handler
+  return { message: 'Not implemented' };
+};
+`;
+var GET_ROUTE_TEMPLATE = `import type { HandlerContext } from '@kozo/core';
+
+export default async ({ params, services }: HandlerContext) => {
+  // TODO: Implement handler
+  return { message: 'Not implemented' };
+};
+`;
+var MIDDLEWARE_TEMPLATE = `import type { Context, Next } from 'hono';
+
+export async function {{name}}(c: Context, next: Next) {
+  // Before handler
+  console.log('{{name}} middleware - before');
+  
+  await next();
+  
+  // After handler
+  console.log('{{name}} middleware - after');
+}
+`;
+async function generateCommand(type, name) {
+  if (!type) {
+    p2.log.error("Please specify what to generate: route, middleware");
+    process.exit(1);
+  }
+  switch (type.toLowerCase()) {
+    case "route":
+    case "r":
+      await generateRoute(name);
+      break;
+    case "middleware":
+    case "mw":
+      await generateMiddleware(name);
+      break;
+    default:
+      p2.log.error(`Unknown generator: ${type}`);
+      p2.log.info("Available: route, middleware");
+      process.exit(1);
+  }
+}
+async function generateRoute(routePath) {
+  let targetPath = routePath;
+  if (!targetPath) {
+    const result = await p2.text({
+      message: "Route path (e.g., users/profile)",
+      placeholder: "users/[id]",
+      validate: (v) => !v ? "Path is required" : void 0
+    });
+    if (p2.isCancel(result)) {
+      p2.cancel("Cancelled");
+      process.exit(0);
+    }
+    targetPath = result;
+  }
+  const method = await p2.select({
+    message: "HTTP method",
+    options: [
+      { value: "get", label: "GET" },
+      { value: "post", label: "POST" },
+      { value: "put", label: "PUT" },
+      { value: "patch", label: "PATCH" },
+      { value: "delete", label: "DELETE" }
+    ]
+  });
+  if (p2.isCancel(method)) {
+    p2.cancel("Cancelled");
+    process.exit(0);
+  }
+  const routesDir = import_node_path9.default.join(process.cwd(), "src", "routes");
+  const filePath = import_node_path9.default.join(routesDir, targetPath, `${method}.ts`);
+  if (await import_fs_extra8.default.pathExists(filePath)) {
+    const overwrite = await p2.confirm({
+      message: `File ${filePath} already exists. Overwrite?`,
+      initialValue: false
+    });
+    if (p2.isCancel(overwrite) || !overwrite) {
+      p2.cancel("Cancelled");
+      process.exit(0);
+    }
+  }
+  await import_fs_extra8.default.ensureDir(import_node_path9.default.dirname(filePath));
+  const template = method === "get" ? GET_ROUTE_TEMPLATE : ROUTE_TEMPLATE;
+  await import_fs_extra8.default.writeFile(filePath, template);
+  const relativePath = import_node_path9.default.relative(process.cwd(), filePath);
+  p2.log.success(`Created ${import_picocolors5.default.cyan(relativePath)}`);
+  const urlPath = "/" + targetPath.replace(/\[([^\]]+)\]/g, ":$1");
+  console.log(`
+  ${import_picocolors5.default.bold(String(method).toUpperCase())} ${import_picocolors5.default.green(urlPath)}
+`);
+}
+async function generateMiddleware(middlewareName) {
+  let name = middlewareName;
+  if (!name) {
+    const result = await p2.text({
+      message: "Middleware name",
+      placeholder: "auth",
+      validate: (v) => !v ? "Name is required" : void 0
+    });
+    if (p2.isCancel(result)) {
+      p2.cancel("Cancelled");
+      process.exit(0);
+    }
+    name = result;
+  }
+  const middlewareDir = import_node_path9.default.join(process.cwd(), "src", "middleware");
+  const filePath = import_node_path9.default.join(middlewareDir, `${name}.ts`);
+  if (await import_fs_extra8.default.pathExists(filePath)) {
+    const overwrite = await p2.confirm({
+      message: `File ${filePath} already exists. Overwrite?`,
+      initialValue: false
+    });
+    if (p2.isCancel(overwrite) || !overwrite) {
+      p2.cancel("Cancelled");
+      process.exit(0);
+    }
+  }
+  await import_fs_extra8.default.ensureDir(middlewareDir);
+  const content = MIDDLEWARE_TEMPLATE.replace(/\{\{name\}\}/g, name);
+  await import_fs_extra8.default.writeFile(filePath, content);
+  const relativePath = import_node_path9.default.relative(process.cwd(), filePath);
+  p2.log.success(`Created ${import_picocolors5.default.cyan(relativePath)}`);
+}
+
 // src/index.ts
 var program = new import_commander.Command();
 program.name("kozo").description("CLI to scaffold new Kozo Framework projects").version("0.2.6");
@@ -4133,4 +4412,10 @@ program.command("build").description("Build the project (generates routes manife
     tsupArgs
   });
 });
+program.command("dev").description("Start development server with hot reload and route watcher").action(async () => {
+  await devCommand();
+});
+program.command("generate [type] [name]").alias("g").description("Generate scaffolding: route, middleware").action(async (type, name) => {
+  await generateCommand(type ?? "", name);
+});
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kozojs/cli",
-  "version": "0.1.31",
+  "version": "0.1.32",
   "description": "CLI to scaffold new Kozo Framework projects - The next-gen TypeScript Backend Framework",
   "bin": {
     "create-kozo": "./lib/index.js",
@@ -40,7 +40,8 @@
     "ora": "^8.1.0",
     "execa": "^9.5.0",
     "fs-extra": "^11.2.0",
-    "glob": "^11.0.0"
+    "glob": "^11.0.0",
+    "chokidar": "^3.6.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",