create-fullstack-scaffold 0.4.3 → 0.4.4

package/dist/cli/index.js

@@ -1,13 +1,433 @@
 #!/usr/bin/env node
-import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
-import path, { join } from 'path';
+import { program } from 'commander';
+import { hc } from 'hono/client';
+import { z } from '@hono/zod-openapi';
+import fs, { readdirSync, statSync, existsSync, readFileSync } from 'fs';
+import path2, { join } from 'path';
+import os from 'os';
 import { fileURLToPath, pathToFileURL } from 'url';
-import { Command } from 'commander';
+import fs2 from 'fs-extra';
 import chalk from 'chalk';
-import { select } from '@inquirer/prompts';
-import fs from 'fs-extra';
 import ora from 'ora';
 
+function createRPCClient(baseUrl) {
+  return hc(baseUrl);
+}
+
+// src/cli/utils/api.ts
+var DEFAULT_BASE_URL = "http://localhost:3010";
+var globalBaseUrl = process.env.BIOMIMIC_API_URL || DEFAULT_BASE_URL;
+function setBaseUrl(url) {
+  globalBaseUrl = url;
+}
+function getBaseUrl() {
+  return globalBaseUrl;
+}
+function getClient() {
+  return createRPCClient(globalBaseUrl);
+}
+
+// src/cli/utils/logger.ts
+var Logger = class {
+  level = "info";
+  constructor(options = {}) {
+    if (options.debug || process.env.BIOMIMIC_DEBUG === "true") {
+      this.level = "debug";
+    } else if (options.verbose || process.env.BIOMIMIC_VERBOSE === "true") {
+      this.level = "info";
+    }
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  shouldLog(level) {
+    const levels = ["silent", "error", "warn", "info", "debug"];
+    return levels.indexOf(level) <= levels.indexOf(this.level);
+  }
+  info(message, ...args) {
+    if (this.shouldLog("info")) {
+      process.stdout.write(`${message}${args.length ? " " + args.join(" ") : ""}
+`);
+    }
+  }
+  debug(message, ...args) {
+    if (this.shouldLog("debug")) {
+      process.stdout.write(`[debug] ${message}${args.length ? " " + args.join(" ") : ""}
+`);
+    }
+  }
+  warn(message) {
+    if (this.shouldLog("warn")) {
+      process.stderr.write(`[warn] ${message}
+`);
+    }
+  }
+  error(message) {
+    if (this.shouldLog("error")) {
+      process.stderr.write(`[error] ${message}
+`);
+    }
+  }
+  success(message, ...args) {
+    if (this.shouldLog("info")) {
+      process.stdout.write(`\u2713 ${message}${args.length ? " " + args.join(" ") : ""}
+`);
+    }
+  }
+  fail(message) {
+    if (this.shouldLog("error")) {
+      process.stderr.write(`\u2717 ${message}
+`);
+    }
+  }
+};
+var logger = null;
+function createLogger(options = {}) {
+  logger = new Logger(options);
+  return logger;
+}
+function getLogger() {
+  if (!logger) {
+    logger = new Logger();
+  }
+  return logger;
+}
+
+// src/cli/utils/auto-command.ts
+function extractZodInfo(schema) {
+  const def = schema._def;
+  if (def.typeName === "ZodOptional") {
+    const inner = schema._def.innerType;
+    const info = extractZodInfo(inner);
+    return { ...info, required: false };
+  }
+  if (def.typeName === "ZodDefault") {
+    const innerDef = schema._def;
+    const defaultValue = innerDef.defaultValue();
+    const info = extractZodInfo(innerDef.innerType);
+    return { ...info, required: false, defaultValue };
+  }
+  if (def.typeName === "ZodEnum") {
+    const enumValues = [...schema._def.values];
+    return { type: "enum", required: true, enumValues };
+  }
+  if (def.typeName === "ZodString") return { type: "string", required: true };
+  if (def.typeName === "ZodNumber") return { type: "number", required: true };
+  if (def.typeName === "ZodBoolean") return { type: "boolean", required: true };
+  if (def.typeName === "ZodObject") return { type: "object", required: true };
+  return { type: "string", required: true };
+}
+function schemaToOptions(schema) {
+  const options = [];
+  const shape = schema.shape;
+  for (const [key, zodType] of Object.entries(shape)) {
+    const info = extractZodInfo(zodType);
+    const longFlag = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+    let flags = `--${longFlag} <value>`;
+    if (info.type === "boolean") {
+      flags = `--${longFlag}`;
+    }
+    let description = String(info.type);
+    if (info.enumValues) {
+      description = `${info.type} (${info.enumValues.join("|")})`;
+    }
+    options.push({
+      flags,
+      description,
+      required: info.required,
+      defaultValue: info.defaultValue
+    });
+  }
+  return options;
+}
+function pathToApiCall(client, _method, path3) {
+  const pathParts = path3.split("/").filter(Boolean);
+  let current = client.api;
+  for (const part of pathParts) {
+    if (part.startsWith("{") && part.endsWith("}")) {
+      continue;
+    }
+    current = current[part] || current[`:${part}`];
+  }
+  return current;
+}
+function createCommandFromRoute(config) {
+  const options = [];
+  const arguments_ = [];
+  if (config.params) {
+    const shape = config.params.shape;
+    for (const [key] of Object.entries(shape)) {
+      arguments_.push({
+        name: key,
+        description: `${key} parameter`,
+        required: true
+      });
+    }
+  }
+  if (config.body) {
+    const bodySchema = config.body;
+    if (bodySchema.shape) {
+      options.push(...schemaToOptions(bodySchema) || []);
+    }
+  }
+  if (config.query) {
+    options.push(...schemaToOptions(config.query) || []);
+  }
+  return {
+    name: config.command,
+    description: config.description,
+    options,
+    arguments: arguments_,
+    action: async (opts, args) => {
+      const logger2 = getLogger();
+      const client = getClient();
+      const param = {};
+      if (config.params) {
+        const shape = config.params.shape;
+        const keys = Object.keys(shape);
+        keys.forEach((key, i) => {
+          param[key] = args[i] || String(opts[key]);
+        });
+      }
+      const json = {};
+      if (config.body && opts) {
+        const bodySchema = config.body;
+        if (bodySchema.shape) {
+          const shape = bodySchema.shape;
+          for (const key of Object.keys(shape)) {
+            if (opts[key] !== void 0) {
+              json[key] = opts[key];
+            }
+          }
+        }
+      }
+      const query = {};
+      if (config.query && opts) {
+        const shape = config.query.shape;
+        for (const key of Object.keys(shape)) {
+          if (opts[key] !== void 0) {
+            query[key] = String(opts[key]);
+          }
+        }
+      }
+      const apiCall = pathToApiCall(client, config.method, config.path);
+      const methodCall = apiCall[`$${config.method.charAt(0).toUpperCase() + config.method.slice(1)}`] || apiCall.$get;
+      const res = await methodCall.call(apiCall, {
+        param: Object.keys(param).length > 0 ? param : void 0,
+        query: Object.keys(query).length > 0 ? query : void 0,
+        json: Object.keys(json).length > 0 ? json : void 0
+      });
+      const data = await res.json();
+      logger2.info(JSON.stringify(data, null, 2));
+    }
+  };
+}
+function registerAutoCommand(program2, config) {
+  const cmd = createCommandFromRoute(config);
+  const command = program2.command(cmd.name).description(cmd.description).action(async (firstArg, opts) => {
+    const args = typeof firstArg === "string" ? [firstArg] : [];
+    const options = (typeof firstArg === "object" ? firstArg : opts) || {};
+    await cmd.action(options, args);
+  });
+  cmd.options?.forEach((opt) => {
+    if (opt.required) {
+      command.requiredOption(opt.flags, opt.description, opt.defaultValue);
+    } else {
+      command.option(opt.flags, opt.description, opt.defaultValue);
+    }
+  });
+  cmd.arguments?.forEach((arg) => {
+    command.argument(arg.required ? `<${arg.name}>` : `[${arg.name}]`, arg.description);
+  });
+}
+var TodoStatusSchema = z.enum(["pending", "in_progress", "completed"]);
+var todoRoutes = [
+  {
+    method: "get",
+    path: "/todos",
+    command: "list",
+    description: "List all todos"
+  },
+  {
+    method: "get",
+    path: "/todos/{id}",
+    command: "get",
+    description: "Get a todo by ID",
+    params: z.object({ id: z.string() })
+  },
+  {
+    method: "post",
+    path: "/todos",
+    command: "create",
+    description: "Create a new todo",
+    body: z.object({
+      title: z.string().min(1),
+      description: z.string().optional()
+    })
+  },
+  {
+    method: "put",
+    path: "/todos/{id}",
+    command: "update",
+    description: "Update a todo",
+    params: z.object({ id: z.string() }),
+    body: z.object({
+      title: z.string().optional(),
+      description: z.string().optional(),
+      status: TodoStatusSchema.optional()
+    })
+  },
+  {
+    method: "delete",
+    path: "/todos/{id}",
+    command: "delete",
+    description: "Delete a todo",
+    params: z.object({ id: z.string() })
+  }
+];
+function registerTodoCommands(program2) {
+  const todo = program2.command("todo").description("Todo management commands");
+  for (const route of todoRoutes) {
+    registerAutoCommand(todo, route);
+  }
+}
+
+// src/cli/modules/notification/index.ts
+function registerNotificationCommands(program2) {
+  const notification = program2.command("notification").description("Notification management commands");
+  notification.command("list").description("List all notifications").option("--unread-only", "Show only unread notifications").option("--limit <number>", "Limit number of results", "20").action(async (options) => {
+    const logger2 = getLogger();
+    const client = getClient();
+    const unreadOnly = Boolean(options.unreadOnly);
+    const limit = parseInt(options.limit || "20");
+    const res = await client.api.notifications.$get({
+      query: { unreadOnly: String(unreadOnly), limit: String(limit) }
+    });
+    const data = await res.json();
+    logger2.info(JSON.stringify(data, null, 2));
+  });
+  notification.command("create").description("Create a new notification").requiredOption("-t, --title <title>", "Notification title").requiredOption("-m, --message <message>", "Notification message").option("--type <type>", "Notification type (info|warning|success|error)", "info").action(async (options) => {
+    const logger2 = getLogger();
+    const client = getClient();
+    const res = await client.api.notifications.$post({
+      json: {
+        type: options.type,
+        title: options.title,
+        message: options.message
+      }
+    });
+    const data = await res.json();
+    logger2.success("Notification created");
+    logger2.info(JSON.stringify(data, null, 2));
+  });
+  notification.command("unread-count").description("Get unread notification count").action(async () => {
+    const logger2 = getLogger();
+    const client = getClient();
+    const res = await client.api.notifications["unread-count"].$get();
+    const data = await res.json();
+    logger2.info(JSON.stringify(data, null, 2));
+  });
+  notification.command("mark-read").description("Mark a notification as read").argument("<id>", "Notification ID").action(async (id) => {
+    const logger2 = getLogger();
+    const client = getClient();
+    const res = await client.api.notifications[":id"].read.$patch({ param: { id } });
+    const data = await res.json();
+    logger2.success("Notification marked as read");
+    logger2.info(JSON.stringify(data, null, 2));
+  });
+  notification.command("delete").description("Delete a notification").argument("<id>", "Notification ID").action(async (id) => {
+    const logger2 = getLogger();
+    const client = getClient();
+    const res = await client.api.notifications[":id"].$delete({ param: { id } });
+    const data = await res.json();
+    logger2.success("Notification deleted");
+    logger2.info(JSON.stringify(data, null, 2));
+  });
+}
+var CONFIG_DIR = path2.join(os.homedir(), ".biomimic");
+var CONFIG_FILE = path2.join(CONFIG_DIR, "config.json");
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const content = fs.readFileSync(CONFIG_FILE, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return { baseUrl: "http://localhost:3010" };
+}
+function saveConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function registerConfigCommands(program2) {
+  const config = program2.command("config").description("CLI configuration and service management");
+  config.command("get").description("Show current configuration").option("-k, --key <key>", "Get specific config key").action((options) => {
+    const logger2 = getLogger();
+    const cfg = loadConfig();
+    if (options.key) {
+      const value = cfg[options.key];
+      logger2.info(`${options.key}: ${value ?? "not set"}`);
+    } else {
+      logger2.info(JSON.stringify(cfg, null, 2));
+    }
+  });
+  config.command("set").description("Set configuration value").option("-u, --url <url>", "Set server URL").action((options) => {
+    const logger2 = getLogger();
+    const cfg = loadConfig();
+    if (options.url) {
+      cfg.baseUrl = options.url;
+      setBaseUrl(options.url);
+      logger2.success(`Server URL set to: ${options.url}`);
+    }
+    saveConfig(cfg);
+  });
+  config.command("url").description("Show or set server URL").argument("[url]", "New server URL").action((url) => {
+    const logger2 = getLogger();
+    if (url) {
+      const cfg = loadConfig();
+      cfg.baseUrl = url;
+      setBaseUrl(url);
+      saveConfig(cfg);
+      logger2.success(`Server URL set to: ${url}`);
+    } else {
+      logger2.info(`Current server URL: ${getBaseUrl()}`);
+    }
+  });
+  config.command("status").description("Check server connection status").action(async () => {
+    const logger2 = getLogger();
+    const client = getClient();
+    try {
+      const res = await client.health.$get();
+      const data = await res.json();
+      logger2.success("Server is reachable");
+      logger2.info(JSON.stringify(data, null, 2));
+    } catch (error) {
+      logger2.error(`Server not reachable: ${getBaseUrl()}`);
+      logger2.error(String(error));
+    }
+  });
+  config.command("reset").description("Reset configuration to defaults").action(() => {
+    const logger2 = getLogger();
+    const defaultConfig = { baseUrl: "http://localhost:3010" };
+    saveConfig(defaultConfig);
+    setBaseUrl(defaultConfig.baseUrl);
+    logger2.success("Configuration reset to defaults");
+  });
+  config.command("path").description("Show config file path").action(() => {
+    const logger2 = getLogger();
+    logger2.info(`Config file: ${CONFIG_FILE}`);
+  });
+}
+
+// src/cli/modules/index.ts
+function registerModules(program2) {
+  registerTodoCommands(program2);
+  registerNotificationCommands(program2);
+  registerConfigCommands(program2);
+}
 var tsImportFn;
 async function getTsImport() {
   if (tsImportFn) return tsImportFn;
@@ -3006,7 +3426,7 @@ if (typeof window !== 'undefined') {
 
 // src/commands/create.ts
 var __filename$1 = fileURLToPath(import.meta.url);
-var __dirname$1 = path.dirname(__filename$1);
+var __dirname$1 = path2.dirname(__filename$1);
 var TEMPLATE_PROJECT_NAME = "biomimic-todo-app";
 var TEMPLATE_DB_NAME = "biomimic-todo-db";
 var ScaffoldError = class extends Error {
@@ -3048,11 +3468,11 @@ function generateDbName(projectName) {
   return `${sanitized}-db`;
 }
 async function updateWranglerToml(targetDir, projectName) {
-  const wranglerPath = path.join(targetDir, "wrangler.toml");
-  if (!await fs.pathExists(wranglerPath)) {
+  const wranglerPath = path2.join(targetDir, "wrangler.toml");
+  if (!await fs2.pathExists(wranglerPath)) {
     return;
   }
-  let content = await fs.readFile(wranglerPath, "utf-8");
+  let content = await fs2.readFile(wranglerPath, "utf-8");
   const dbName = generateDbName(projectName);
   content = content.replace(
     new RegExp(`^name = "${TEMPLATE_PROJECT_NAME}"`, "m"),
@@ -3066,43 +3486,43 @@ async function updateWranglerToml(targetDir, projectName) {
     /database_id = "[^"]+"/,
     `database_id = ""  # TODO: Run 'wrangler d1 create ${dbName}' and paste the ID here`
   );
-  await fs.writeFile(wranglerPath, content);
+  await fs2.writeFile(wranglerPath, content);
 }
 async function updatePackageJson(targetDir, projectName, resolved) {
-  const pkgJsonPath = path.join(targetDir, "package.json");
-  if (!await fs.pathExists(pkgJsonPath)) {
+  const pkgJsonPath = path2.join(targetDir, "package.json");
+  if (!await fs2.pathExists(pkgJsonPath)) {
     return;
   }
-  let pkgJson = await fs.readJson(pkgJsonPath);
+  let pkgJson = await fs2.readJson(pkgJsonPath);
   pkgJson = filterPackageJson(pkgJson, resolved);
   pkgJson.name = projectName;
   if (pkgJson.bin) {
     delete pkgJson.bin;
   }
-  await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+  await fs2.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
 }
 async function updatePackageLockJson(targetDir, projectName) {
-  const lockFilePath = path.join(targetDir, "package-lock.json");
-  if (!await fs.pathExists(lockFilePath)) {
+  const lockFilePath = path2.join(targetDir, "package-lock.json");
+  if (!await fs2.pathExists(lockFilePath)) {
     return;
   }
-  const lockFile = await fs.readJson(lockFilePath);
+  const lockFile = await fs2.readJson(lockFilePath);
   if (lockFile.name === TEMPLATE_PROJECT_NAME) {
     lockFile.name = projectName;
   }
   if (lockFile.packages?.[""]?.name === TEMPLATE_PROJECT_NAME) {
     lockFile.packages[""].name = projectName;
   }
-  await fs.writeJson(lockFilePath, lockFile, { spaces: 2 });
+  await fs2.writeJson(lockFilePath, lockFile, { spaces: 2 });
 }
 async function updateReadme(targetDir, projectName) {
-  const readmePath = path.join(targetDir, "README.md");
-  if (!await fs.pathExists(readmePath)) {
+  const readmePath = path2.join(targetDir, "README.md");
+  if (!await fs2.pathExists(readmePath)) {
     return;
   }
-  let content = await fs.readFile(readmePath, "utf-8");
+  let content = await fs2.readFile(readmePath, "utf-8");
   content = content.replace(/^# (.+)$/m, `# ${projectName}`);
-  await fs.writeFile(readmePath, content);
+  await fs2.writeFile(readmePath, content);
 }
 async function createProject(projectNameOrOptions, useCurrentDir = false, preset) {
   let projectName;
@@ -3125,19 +3545,19 @@ async function createProject(projectNameOrOptions, useCurrentDir = false, preset
   if (!currentDir) {
     validateProjectName(projectName);
   }
-  const templateDir = path.join(__dirname$1, "../../template");
+  const templateDir = path2.join(__dirname$1, "../../template");
   let targetDir;
   if (currentDir) {
     targetDir = process.cwd();
-    projectName = path.basename(targetDir);
+    projectName = path2.basename(targetDir);
   } else if (outputDir) {
-    targetDir = path.resolve(outputDir);
-    if (await fs.pathExists(targetDir)) {
+    targetDir = path2.resolve(outputDir);
+    if (await fs2.pathExists(targetDir)) {
       throw new ScaffoldError(`Directory ${outputDir} already exists`);
     }
   } else {
-    targetDir = path.resolve(process.cwd(), projectName);
-    if (await fs.pathExists(targetDir)) {
+    targetDir = path2.resolve(process.cwd(), projectName);
+    if (await fs2.pathExists(targetDir)) {
       throw new ScaffoldError(`Directory ${projectName} already exists`);
     }
   }
@@ -3164,16 +3584,16 @@ async function createProject(projectNameOrOptions, useCurrentDir = false, preset
       for (const file of generatedFiles2) {
         console.log(`  ${chalk.green("\u2713")} ${file}`);
       }
-      const gitignorePath2 = path.join(templateDir, ".gitignore");
+      const gitignorePath2 = path2.join(templateDir, ".gitignore");
       let ignorePatterns2 = [];
-      if (await fs.pathExists(gitignorePath2)) {
-        const gitignoreContent = await fs.readFile(gitignorePath2, "utf-8");
+      if (await fs2.pathExists(gitignorePath2)) {
+        const gitignoreContent = await fs2.readFile(gitignorePath2, "utf-8");
         ignorePatterns2 = parseGitignore(gitignoreContent);
       }
       ignorePatterns2.push("node_modules", ".wrangler");
       const excludePatterns2 = getExcludePatterns(resolved, allManifests);
       let templateFileCount = 0;
-      const templateFiles = await fs.readdir(templateDir, { recursive: true });
+      const templateFiles = await fs2.readdir(templateDir, { recursive: true });
       for (const file of templateFiles) {
         const relative = String(file);
         if (!relative) continue;
@@ -3208,21 +3628,21 @@ async function createProject(projectNameOrOptions, useCurrentDir = false, preset
     }
     if (!currentDir) {
       const dirSpinner = ora("Creating project directory...").start();
-      await fs.ensureDir(targetDir);
+      await fs2.ensureDir(targetDir);
       dirSpinner.succeed(chalk.green("Project directory created"));
     }
     const copySpinner = ora("Copying template files...").start();
-    const gitignorePath = path.join(templateDir, ".gitignore");
+    const gitignorePath = path2.join(templateDir, ".gitignore");
     let ignorePatterns = [];
-    if (await fs.pathExists(gitignorePath)) {
-      const gitignoreContent = await fs.readFile(gitignorePath, "utf-8");
+    if (await fs2.pathExists(gitignorePath)) {
+      const gitignoreContent = await fs2.readFile(gitignorePath, "utf-8");
       ignorePatterns = parseGitignore(gitignoreContent);
     }
     ignorePatterns.push("node_modules", ".wrangler");
     const excludePatterns = getExcludePatterns(resolved, allManifests);
-    await fs.copy(templateDir, targetDir, {
+    await fs2.copy(templateDir, targetDir, {
       filter: (src) => {
-        const relative = path.relative(templateDir, src);
+        const relative = path2.relative(templateDir, src);
         if (relative === "") return true;
         const negated = ignorePatterns.filter((p) => p.startsWith("!"));
         const gitIgnored = ignorePatterns.filter((p) => !p.startsWith("!") && relative.startsWith(p));
@@ -3244,80 +3664,80 @@ async function createProject(projectNameOrOptions, useCurrentDir = false, preset
     copySpinner.succeed(chalk.green("Template files copied"));
     const genSpinner = ora("Generating module-specific files...").start();
     const routeRegistryContent = generateRouteRegistry(resolved);
-    await fs.writeFile(path.join(targetDir, "src/server/route-registry.ts"), routeRegistryContent);
+    await fs2.writeFile(path2.join(targetDir, "src/server/route-registry.ts"), routeRegistryContent);
     const dbSchemaContent = generateDbSchemaBarrel(resolved);
-    await fs.writeFile(path.join(targetDir, "src/server/db/schema/index.ts"), dbSchemaContent);
+    await fs2.writeFile(path2.join(targetDir, "src/server/db/schema/index.ts"), dbSchemaContent);
     if (resolved.hasClient) {
       const clientNavContent = generateClientNavigation(resolved);
-      await fs.writeFile(
-        path.join(targetDir, "src/client/components/Navigation.tsx"),
+      await fs2.writeFile(
+        path2.join(targetDir, "src/client/components/Navigation.tsx"),
         clientNavContent
       );
       const clientAppTestContent = generateClientAppTest(resolved);
-      await fs.ensureDir(path.join(targetDir, "src/client/components/__tests__"));
-      await fs.writeFile(
-        path.join(targetDir, "src/client/components/__tests__/App.test.tsx"),
+      await fs2.ensureDir(path2.join(targetDir, "src/client/components/__tests__"));
+      await fs2.writeFile(
+        path2.join(targetDir, "src/client/components/__tests__/App.test.tsx"),
         clientAppTestContent
       );
       const clientNavTestContent = generateClientNavigationTest(resolved);
-      await fs.writeFile(
-        path.join(targetDir, "src/client/components/__tests__/Navigation.test.tsx"),
+      await fs2.writeFile(
+        path2.join(targetDir, "src/client/components/__tests__/Navigation.test.tsx"),
         clientNavTestContent
       );
       const presetUIConfigContent = generatePresetUIConfig(resolved, selectedPreset.id);
-      await fs.writeFile(
-        path.join(targetDir, "src/client/preset-ui-config.ts"),
+      await fs2.writeFile(
+        path2.join(targetDir, "src/client/preset-ui-config.ts"),
         presetUIConfigContent
       );
       const clientMainContent = generateClientMain(resolved, selectedPreset.id);
-      await fs.writeFile(path.join(targetDir, "src/client/main.tsx"), clientMainContent);
+      await fs2.writeFile(path2.join(targetDir, "src/client/main.tsx"), clientMainContent);
     }
     if (resolved.hasClient && resolved.modules.has("admin")) {
       const adminAppContent = generateAdminApp(resolved);
       if (adminAppContent) {
-        await fs.ensureDir(path.join(targetDir, "src/admin"));
-        await fs.writeFile(path.join(targetDir, "src/admin/App.tsx"), adminAppContent);
+        await fs2.ensureDir(path2.join(targetDir, "src/admin"));
+        await fs2.writeFile(path2.join(targetDir, "src/admin/App.tsx"), adminAppContent);
       }
     }
     const serverAppContent = generateServerApp(resolved);
-    await fs.writeFile(path.join(targetDir, "src/server/app.ts"), serverAppContent);
+    await fs2.writeFile(path2.join(targetDir, "src/server/app.ts"), serverAppContent);
     const generatedFiles = getGeneratedFiles(resolved);
     if (generatedFiles.includes("src/server/db/init.ts")) {
       const dbInitContent = generateDbInit(resolved);
-      await fs.writeFile(path.join(targetDir, "src/server/db/init.ts"), dbInitContent);
+      await fs2.writeFile(path2.join(targetDir, "src/server/db/init.ts"), dbInitContent);
     }
     const sharedModulesContent = generateSharedModulesIndex(resolved);
-    await fs.writeFile(path.join(targetDir, "src/shared/modules/index.ts"), sharedModulesContent);
+    await fs2.writeFile(path2.join(targetDir, "src/shared/modules/index.ts"), sharedModulesContent);
     const sharedSchemasContent = generateSharedSchemasIndex(resolved);
-    await fs.writeFile(path.join(targetDir, "src/shared/schemas/index.ts"), sharedSchemasContent);
+    await fs2.writeFile(path2.join(targetDir, "src/shared/schemas/index.ts"), sharedSchemasContent);
     const middlewareIndexContent = generateMiddlewareIndex(resolved);
-    await fs.writeFile(
-      path.join(targetDir, "src/server/middleware/index.ts"),
+    await fs2.writeFile(
+      path2.join(targetDir, "src/server/middleware/index.ts"),
       middlewareIndexContent
     );
     if (generatedFiles.includes("src/server/middleware/auth.ts")) {
       const authMiddlewareContent = generateAuthMiddleware(resolved);
-      await fs.writeFile(
-        path.join(targetDir, "src/server/middleware/auth.ts"),
+      await fs2.writeFile(
+        path2.join(targetDir, "src/server/middleware/auth.ts"),
         authMiddlewareContent
       );
     }
     if (generatedFiles.includes("src/server/utils/auth.ts")) {
       const authUtilsContent = generateAuthUtils(resolved);
-      await fs.writeFile(path.join(targetDir, "src/server/utils/auth.ts"), authUtilsContent);
+      await fs2.writeFile(path2.join(targetDir, "src/server/utils/auth.ts"), authUtilsContent);
     }
     if (resolved.hasClient) {
       const clientComponentsContent = generateClientComponentsIndex(resolved);
-      await fs.writeFile(
-        path.join(targetDir, "src/client/components/index.ts"),
+      await fs2.writeFile(
+        path2.join(targetDir, "src/client/components/index.ts"),
         clientComponentsContent
       );
     }
     const cliModulesContent = generateCliModulesIndex(resolved);
-    await fs.writeFile(path.join(targetDir, "src/cli/modules/index.ts"), cliModulesContent);
+    await fs2.writeFile(path2.join(targetDir, "src/cli/modules/index.ts"), cliModulesContent);
     if (resolved.hasClient && generatedFiles.includes("vite.config.ts")) {
       const viteConfigContent = generateViteConfig(resolved, templateDir);
-      await fs.writeFile(path.join(targetDir, "vite.config.ts"), viteConfigContent);
+      await fs2.writeFile(path2.join(targetDir, "vite.config.ts"), viteConfigContent);
     }
     genSpinner.succeed(chalk.green("Module-specific files generated"));
     const pkgSpinner = ora("Configuring package.json...").start();
@@ -3369,66 +3789,37 @@ async function createProject(projectNameOrOptions, useCurrentDir = false, preset
   }
 }
 
-// src/index.ts
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path.dirname(__filename2);
-var rootDir = __dirname2.endsWith(path.join("src")) || __dirname2.endsWith(path.join("dist")) ? path.resolve(__dirname2, "..") : path.resolve(__dirname2, "..", "..");
-var packageJson = JSON.parse(readFileSync(path.join(rootDir, "package.json"), "utf-8"));
-var program = new Command();
-program.name("create-fullstack-scaffold").description("Create a new full-stack scaffold app with Todo List example").version(packageJson.version).argument("[project-name]", "Name of your project").option("-c, --current-dir", "Create project in current directory").option(
-  "-p, --preset <preset>",
-  "Template preset to use (fullstack-admin, todo-app, cli-only, minimal)"
-).option("-o, --output-dir <path>", "Output directory (defaults to project name)").option("--dry-run", "Show what would be generated without creating files").action(
-  async (projectName = "my-fullstack-app", options) => {
-    console.log("");
-    console.log(chalk.cyan.bold("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
-    console.log(chalk.cyan.bold("  \u2551   Create Fullstack Scaffold App          \u2551"));
-    console.log(chalk.cyan.bold("  \u2551   React + Hono + Vite + Zustand + TS     \u2551"));
-    console.log(chalk.cyan.bold("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
-    console.log("");
-    let preset = options.preset;
-    if (!preset && process.stdin.isTTY) {
-      const templateDir = path.join(__dirname2, "../template");
-      const presets = await loadPresets(templateDir);
-      preset = await select({
-        message: "Choose a template preset:",
-        choices: presets.map((p) => ({
-          value: p.id,
-          name: `${p.name} \u2014 ${p.description}`
-        }))
-      });
-    }
-    if (!preset) {
-      preset = "fullstack-admin";
-    }
-    try {
-      await createProject({
-        projectName,
-        currentDir: options.currentDir ?? false,
-        preset,
-        outputDir: options.outputDir,
-        dryRun: options.dryRun ?? false
-      });
-    } catch (error) {
-      if (error instanceof ScaffoldError) {
-        console.error(chalk.red(`  \u2716 ${error.message}`));
-        process.exit(1);
-      }
-      throw error;
-    }
+// src/cli/index.ts
+var MODULE_COMMANDS = ["todo", "notification", "config"];
+program.name("create-fullstack-scaffold").description("Create a new fullstack scaffolded project").version("0.1.1").argument("[project-name]", "Name of the project to create").option("-v, --verbose", "Enable verbose output").option("-u, --url <url>", "Server URL", "http://localhost:3010").option("-p, --preset <preset>", "Template preset to use", "fullstack-admin").option("-d, --dry-run", "Preview files without creating them").option("--current-dir", "Scaffold in the current directory").action(async (projectName, cmdOptions) => {
+  if (projectName && !MODULE_COMMANDS.includes(projectName)) {
+    const isCurrentDir = cmdOptions.currentDir === true || projectName === ".";
+    createLogger({ verbose: cmdOptions.verbose });
+    const options = {
+      projectName: isCurrentDir ? "." : projectName,
+      currentDir: isCurrentDir,
+      preset: cmdOptions.preset,
+      dryRun: cmdOptions.dryRun
+    };
+    await createProject(options).catch((err) => {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    });
+    return;
+  }
+  if (!projectName) {
+    program.outputHelp();
+    process.exit(1);
   }
-);
-program.command("presets").description("List available template presets").action(async () => {
-  const templateDir = path.join(__dirname2, "../template");
-  const presets = await loadPresets(templateDir);
-  console.log(chalk.cyan("\nAvailable presets:\n"));
-  for (const preset of presets) {
-    console.log(`  ${chalk.green(preset.id.padEnd(20))} ${preset.name}`);
-    console.log(`  ${" ".repeat(20)} ${preset.description}`);
-    console.log(`  ${" ".repeat(20)} Modules: ${preset.modules.join(", ")}`);
-    console.log();
+});
+program.hook("preAction", (thisCommand) => {
+  const options = thisCommand.opts();
+  createLogger({ verbose: options.verbose });
+  if (options.url) {
+    setBaseUrl(options.url);
   }
 });
+registerModules(program);
 program.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map