@alexmc2/create-express-api-starter 0.1.0

package/dist/cli.js

@@ -0,0 +1,930 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import pc4 from "picocolors";
+import { pathToFileURL } from "url";
+import fs4 from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/cli/args.ts
+var TRUE_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+var FALSE_VALUES = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
+function parseBooleanValue(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (TRUE_VALUES.has(normalized)) {
+    return true;
+  }
+  if (FALSE_VALUES.has(normalized)) {
+    return false;
+  }
+  return void 0;
+}
+function splitFlag(token) {
+  const withoutPrefix = token.slice(2);
+  const equalsIndex = withoutPrefix.indexOf("=");
+  if (equalsIndex === -1) {
+    return {
+      name: withoutPrefix,
+      value: void 0
+    };
+  }
+  return {
+    name: withoutPrefix.slice(0, equalsIndex),
+    value: withoutPrefix.slice(equalsIndex + 1)
+  };
+}
+function parseArgs(argv) {
+  const flags = {
+    yes: false,
+    dryRun: false,
+    install: true,
+    git: true,
+    verbose: false
+  };
+  const provided = {
+    yes: false,
+    dryRun: false,
+    install: false,
+    git: false,
+    verbose: false
+  };
+  const unknownFlags = [];
+  const positionals = [];
+  let positionalOnly = false;
+  for (const token of argv) {
+    if (positionalOnly) {
+      positionals.push(token);
+      continue;
+    }
+    if (token === "--") {
+      positionalOnly = true;
+      continue;
+    }
+    if (!token.startsWith("-") || token === "-") {
+      positionals.push(token);
+      continue;
+    }
+    if (!token.startsWith("--")) {
+      unknownFlags.push(token);
+      continue;
+    }
+    const { name, value } = splitFlag(token);
+    if (name === "yes") {
+      const parsedValue = parseBooleanValue(value);
+      if (value !== void 0 && parsedValue === void 0) {
+        unknownFlags.push(token);
+        continue;
+      }
+      flags.yes = parsedValue ?? true;
+      provided.yes = true;
+      continue;
+    }
+    if (name === "dry-run") {
+      const parsedValue = parseBooleanValue(value);
+      if (value !== void 0 && parsedValue === void 0) {
+        unknownFlags.push(token);
+        continue;
+      }
+      flags.dryRun = parsedValue ?? true;
+      provided.dryRun = true;
+      continue;
+    }
+    if (name === "no-install") {
+      const parsedValue = parseBooleanValue(value);
+      if (value !== void 0 && parsedValue === void 0) {
+        unknownFlags.push(token);
+        continue;
+      }
+      const noInstall = parsedValue ?? true;
+      flags.install = !noInstall;
+      provided.install = true;
+      continue;
+    }
+    if (name === "no-git") {
+      const parsedValue = parseBooleanValue(value);
+      if (value !== void 0 && parsedValue === void 0) {
+        unknownFlags.push(token);
+        continue;
+      }
+      const noGit = parsedValue ?? true;
+      flags.git = !noGit;
+      provided.git = true;
+      continue;
+    }
+    if (name === "verbose") {
+      const parsedValue = parseBooleanValue(value);
+      if (value !== void 0 && parsedValue === void 0) {
+        unknownFlags.push(token);
+        continue;
+      }
+      flags.verbose = parsedValue ?? true;
+      provided.verbose = true;
+      continue;
+    }
+    unknownFlags.push(token);
+  }
+  return {
+    projectName: positionals[0],
+    positionals,
+    unknownFlags,
+    flags,
+    provided
+  };
+}
+
+// src/cli/output.ts
+import path from "path";
+import pc2 from "picocolors";
+
+// src/core/labels.ts
+function languageLabel(language) {
+  return language === "ts" ? "TypeScript" : "JavaScript";
+}
+function moduleSystemLabel(moduleSystem) {
+  return moduleSystem === "esm" ? "ES Modules" : "CommonJS";
+}
+function jsDevWatcherLabel(jsDevWatcher) {
+  return jsDevWatcher === "nodemon" ? "nodemon" : "node --watch";
+}
+function architectureLabel(architecture) {
+  return architecture === "mvc" ? "MVC" : "Simple";
+}
+function databaseLabel(databaseMode) {
+  if (databaseMode === "postgres-psql") {
+    return "Postgres (psql)";
+  }
+  if (databaseMode === "postgres-docker") {
+    return "Postgres (Docker)";
+  }
+  return "In-memory";
+}
+
+// src/utils/terminalUi.ts
+import pc from "picocolors";
+var ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
+function stripAnsi(value) {
+  return value.replace(ANSI_PATTERN, "");
+}
+function displayLength(value) {
+  return stripAnsi(value).length;
+}
+function padDisplay(value, width) {
+  const padding = width - displayLength(value);
+  if (padding <= 0) {
+    return value;
+  }
+  return `${value}${" ".repeat(padding)}`;
+}
+function minimumContentWidth(lines) {
+  return lines.reduce((max, line) => {
+    return Math.max(max, displayLength(line));
+  }, 0);
+}
+function styleValue(value, tone) {
+  if (tone === "accent") {
+    return pc.cyan(value);
+  }
+  if (tone === "success") {
+    return pc.green(value);
+  }
+  if (tone === "warn") {
+    return pc.yellow(value);
+  }
+  if (tone === "muted") {
+    return pc.dim(value);
+  }
+  return value;
+}
+function statusTag(tone) {
+  if (tone === "success") {
+    return pc.bold(pc.green("[ok]"));
+  }
+  if (tone === "warn") {
+    return pc.bold(pc.yellow("[!!]"));
+  }
+  if (tone === "error") {
+    return pc.bold(pc.red("[x]"));
+  }
+  return pc.bold(pc.cyan("[..]"));
+}
+function formatKeyValueLines(rows) {
+  const keyWidth = rows.reduce((max, row) => Math.max(max, row.key.length), 0);
+  return rows.map((row) => {
+    const key = pc.bold(padDisplay(row.key, keyWidth));
+    const value = styleValue(row.value, row.tone ?? "default");
+    return `${key}  ${value}`;
+  });
+}
+function formatCommandLines(commands) {
+  return commands.map((command) => pc.bold(pc.cyan(command)));
+}
+function printCard(title, lines) {
+  const content = lines.length > 0 ? lines : [pc.dim("(none)")];
+  const width = Math.max(30, minimumContentWidth([title, ...content]));
+  const border = pc.dim(pc.cyan(`+${"-".repeat(width + 2)}+`));
+  const edge = pc.dim(pc.cyan("|"));
+  const divider = pc.dim("-".repeat(width));
+  console.log(border);
+  console.log(
+    `${edge} ${padDisplay(pc.bold(pc.cyan(title)), width)} ${edge}`
+  );
+  console.log(`${edge} ${divider} ${edge}`);
+  for (const line of content) {
+    console.log(`${edge} ${padDisplay(line, width)} ${edge}`);
+  }
+  console.log(border);
+}
+
+// src/cli/output.ts
+function buildNextStepCommands(selection) {
+  const commands = [`cd ${selection.projectName}`];
+  if (!selection.installDeps) {
+    commands.push("npm install");
+  }
+  commands.push("cp .env.example .env");
+  if (selection.databaseMode === "postgres-psql") {
+    commands.push("npm run db:create");
+    commands.push("npm run db:setup");
+    commands.push("npm run db:seed");
+  }
+  if (selection.databaseMode === "postgres-docker") {
+    commands.push("npm run db:up");
+    commands.push("npm run db:setup");
+    commands.push("npm run db:seed");
+  }
+  commands.push("npm run dev");
+  if (selection.language === "ts") {
+    commands.push("npm run build");
+  }
+  commands.push("npm test");
+  return commands;
+}
+function printDryRunPlan(selection, plan) {
+  const languageValue = selection.language === "js" ? `${languageLabel(selection.language)} (${moduleSystemLabel(selection.moduleSystem)})` : languageLabel(selection.language);
+  const summaryEntries = [
+    {
+      key: "Target",
+      value: formatTargetPath(plan.targetDir),
+      tone: "accent"
+    },
+    {
+      key: "Language",
+      value: languageValue,
+      tone: "accent"
+    },
+    {
+      key: "Architecture",
+      value: architectureLabel(selection.architecture),
+      tone: "accent"
+    },
+    {
+      key: "Database",
+      value: databaseLabel(selection.databaseMode),
+      tone: "accent"
+    }
+  ];
+  if (selection.language === "js") {
+    summaryEntries.push({
+      key: "Dev watcher",
+      value: jsDevWatcherLabel(selection.jsDevWatcher),
+      tone: "accent"
+    });
+  }
+  summaryEntries.push(
+    {
+      key: "Educational",
+      value: selection.educational ? "On" : "Off",
+      tone: selection.educational ? "success" : "muted"
+    },
+    {
+      key: "Install deps",
+      value: selection.installDeps ? "Yes" : "No",
+      tone: selection.installDeps ? "success" : "warn"
+    },
+    {
+      key: "Init git",
+      value: selection.initGit ? "Yes" : "No",
+      tone: selection.initGit ? "success" : "warn"
+    }
+  );
+  const summaryLines = formatKeyValueLines(summaryEntries);
+  const fileLines = plan.files.map((file) => `${pc2.dim("-")} ${file.outputRelativePath}`);
+  console.log("");
+  printCard("Dry Run: Configuration", summaryLines);
+  console.log("");
+  printCard(`Dry Run: Files (${plan.files.length})`, fileLines);
+}
+function printNextSteps(selection) {
+  const stackParts = [
+    selection.language === "js" ? `${languageLabel(selection.language)} (${moduleSystemLabel(selection.moduleSystem)})` : languageLabel(selection.language),
+    architectureLabel(selection.architecture),
+    databaseLabel(selection.databaseMode)
+  ];
+  const summaryEntries = [
+    {
+      key: "Project",
+      value: selection.projectName,
+      tone: "accent"
+    },
+    {
+      key: "Stack",
+      value: stackParts.join(" | "),
+      tone: "accent"
+    },
+    {
+      key: "Educational",
+      value: selection.educational ? "On" : "Off",
+      tone: selection.educational ? "success" : "muted"
+    }
+  ];
+  if (selection.language === "js") {
+    summaryEntries.push({
+      key: "Dev watcher",
+      value: jsDevWatcherLabel(selection.jsDevWatcher),
+      tone: "accent"
+    });
+  }
+  const summaryLines = formatKeyValueLines(summaryEntries);
+  const nextStepCommands = buildNextStepCommands(selection);
+  console.log("");
+  printCard("Project Ready", summaryLines);
+  console.log("");
+  printCard("Next Steps", formatCommandLines(nextStepCommands));
+  if (selection.databaseMode === "postgres-psql") {
+    const setupLines = [
+      pc2.yellow("Linux first-time setup (run once if needed):"),
+      pc2.dim("# Create a Postgres role matching your OS user"),
+      ...formatCommandLines([
+        'sudo -u postgres createuser --createdb "$USER"',
+        `sudo -u postgres psql -c "ALTER USER \\"$USER\\" WITH PASSWORD 'postgres';"`
+      ])
+    ];
+    console.log("");
+    printCard("Postgres Setup", setupLines);
+  }
+}
+function formatTargetPath(targetDir) {
+  const relative = path.relative(process.cwd(), targetDir);
+  return relative || ".";
+}
+
+// src/cli/prompts.ts
+import {
+  confirm,
+  intro,
+  isCancel,
+  outro,
+  select,
+  text
+} from "@clack/prompts";
+import pc3 from "picocolors";
+
+// src/core/defaults.ts
+var DEFAULT_PROJECT_NAME = "my-api";
+var DEFAULT_SELECTIONS = {
+  language: "js",
+  moduleSystem: "commonjs",
+  jsDevWatcher: "node-watch",
+  architecture: "simple",
+  databaseMode: "memory",
+  educational: true,
+  installDeps: true,
+  initGit: true
+};
+
+// src/cli/prompts.ts
+var PromptCancelledError = class extends Error {
+  constructor() {
+    super("Prompt cancelled by user.");
+  }
+};
+function unwrapPrompt(value) {
+  if (isCancel(value)) {
+    throw new PromptCancelledError();
+  }
+  return value;
+}
+async function collectSelections(parsedArgs) {
+  if (parsedArgs.flags.yes || !process.stdin.isTTY) {
+    return {
+      projectName: parsedArgs.projectName ?? DEFAULT_PROJECT_NAME,
+      language: DEFAULT_SELECTIONS.language,
+      moduleSystem: DEFAULT_SELECTIONS.moduleSystem,
+      jsDevWatcher: DEFAULT_SELECTIONS.jsDevWatcher,
+      architecture: DEFAULT_SELECTIONS.architecture,
+      databaseMode: DEFAULT_SELECTIONS.databaseMode,
+      educational: DEFAULT_SELECTIONS.educational,
+      installDeps: parsedArgs.flags.install,
+      initGit: parsedArgs.flags.git,
+      dryRun: parsedArgs.flags.dryRun
+    };
+  }
+  intro(
+    [
+      pc3.bold(pc3.cyan("Create Express API Starter")),
+      pc3.dim("Scaffold an Express backend with practical defaults.")
+    ].join("\n")
+  );
+  const projectName = parsedArgs.projectName ? parsedArgs.projectName : unwrapPrompt(
+    await text({
+      message: "Project name",
+      placeholder: DEFAULT_PROJECT_NAME,
+      defaultValue: DEFAULT_PROJECT_NAME,
+      validate(value) {
+        if (!value.trim()) {
+          return "Project name is required.";
+        }
+        return void 0;
+      }
+    })
+  );
+  const language = unwrapPrompt(
+    await select({
+      message: "Language",
+      initialValue: DEFAULT_SELECTIONS.language,
+      options: [
+        {
+          value: "js",
+          label: "JavaScript"
+        },
+        {
+          value: "ts",
+          label: "TypeScript"
+        }
+      ]
+    })
+  );
+  const moduleSystem = language === "js" ? unwrapPrompt(
+    await select({
+      message: "Module system",
+      initialValue: DEFAULT_SELECTIONS.moduleSystem,
+      options: [
+        {
+          value: "commonjs",
+          label: "CommonJS"
+        },
+        {
+          value: "esm",
+          label: "ES Modules"
+        }
+      ]
+    })
+  ) : "commonjs";
+  const jsDevWatcher = language === "js" ? unwrapPrompt(
+    await select({
+      message: "Dev watcher (JavaScript)",
+      initialValue: DEFAULT_SELECTIONS.jsDevWatcher,
+      options: [
+        {
+          value: "node-watch",
+          label: "node --watch (built-in)"
+        },
+        {
+          value: "nodemon",
+          label: "nodemon"
+        }
+      ]
+    })
+  ) : DEFAULT_SELECTIONS.jsDevWatcher;
+  const architecture = unwrapPrompt(
+    await select({
+      message: "Architecture",
+      initialValue: DEFAULT_SELECTIONS.architecture,
+      options: [
+        {
+          value: "simple",
+          label: "Simple"
+        },
+        {
+          value: "mvc",
+          label: "MVC"
+        }
+      ]
+    })
+  );
+  const databaseMode = unwrapPrompt(
+    await select({
+      message: "Database",
+      initialValue: DEFAULT_SELECTIONS.databaseMode,
+      options: [
+        {
+          value: "memory",
+          label: "In-memory"
+        },
+        {
+          value: "postgres-psql",
+          label: "Postgres (psql)"
+        },
+        {
+          value: "postgres-docker",
+          label: "Postgres (Docker)"
+        }
+      ]
+    })
+  );
+  const educational = unwrapPrompt(
+    await confirm({
+      message: "Add educational comments",
+      initialValue: DEFAULT_SELECTIONS.educational
+    })
+  );
+  const installDeps = parsedArgs.provided.install ? parsedArgs.flags.install : unwrapPrompt(
+    await confirm({
+      message: "Install dependencies now",
+      initialValue: DEFAULT_SELECTIONS.installDeps
+    })
+  );
+  const initGit = parsedArgs.provided.git ? parsedArgs.flags.git : unwrapPrompt(
+    await confirm({
+      message: "Initialize git repository",
+      initialValue: DEFAULT_SELECTIONS.initGit
+    })
+  );
+  outro(pc3.cyan("Scaffolding project files..."));
+  return {
+    projectName,
+    language,
+    moduleSystem,
+    jsDevWatcher,
+    architecture,
+    databaseMode,
+    educational,
+    installDeps,
+    initGit,
+    dryRun: parsedArgs.flags.dryRun
+  };
+}
+
+// src/core/validation.ts
+import path2 from "path";
+function validateProjectName(projectName) {
+  const trimmed = projectName.trim();
+  if (!trimmed) {
+    return "Project name is required.";
+  }
+  if (trimmed === "." || trimmed === "..") {
+    return 'Project name cannot be "." or "..".';
+  }
+  if (trimmed !== path2.basename(trimmed)) {
+    return "Project name must be a folder name, not a path.";
+  }
+  if (/[^a-zA-Z0-9._-]/.test(trimmed)) {
+    return 'Project name can only include letters, numbers, ".", "_", and "-".';
+  }
+  return null;
+}
+
+// src/generator/index.ts
+import path4 from "path";
+import os from "os";
+import fs2 from "fs-extra";
+import ejs from "ejs";
+
+// src/utils/paths.ts
+import path3 from "path";
+import { fileURLToPath } from "url";
+import fs from "fs-extra";
+function resolveTargetDir(baseDir, projectName) {
+  return path3.resolve(baseDir, projectName);
+}
+function resolveTemplatesDir() {
+  const moduleDir = path3.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path3.resolve(moduleDir, "../templates"),
+    path3.resolve(moduleDir, "../../templates"),
+    path3.resolve(process.cwd(), "templates")
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error("Unable to locate templates directory.");
+}
+
+// src/generator/index.ts
+function toPosixPath(value) {
+  return value.split(path4.sep).join("/");
+}
+function isEjsTemplate(relativePath) {
+  return relativePath.endsWith(".ejs");
+}
+function stripEjsSuffix(relativePath) {
+  return relativePath.endsWith(".ejs") ? relativePath.slice(0, -".ejs".length) : relativePath;
+}
+function resolveTemplateRoot(config) {
+  const templatesDir = resolveTemplatesDir();
+  return path4.join(templatesDir, config.language, config.architecture);
+}
+async function listFilesRecursive(directory, baseDir = directory) {
+  const entries = await fs2.readdir(directory, {
+    withFileTypes: true
+  });
+  const sortedEntries = entries.sort((a, b) => a.name.localeCompare(b.name));
+  const results = [];
+  for (const entry of sortedEntries) {
+    const entryPath = path4.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      const childEntries = await listFilesRecursive(entryPath, baseDir);
+      results.push(...childEntries);
+      continue;
+    }
+    results.push(path4.relative(baseDir, entryPath));
+  }
+  return results;
+}
+function shouldIncludeTemplate(relativePath, config) {
+  if (relativePath === "compose.yaml.ejs") {
+    return config.databaseMode === "postgres-docker";
+  }
+  if (relativePath === "scripts/dbCreate.js.ejs") {
+    return config.databaseMode === "postgres-psql";
+  }
+  if (relativePath.startsWith("scripts/")) {
+    return config.databaseMode !== "memory";
+  }
+  if (relativePath.startsWith("db/")) {
+    return config.databaseMode !== "memory";
+  }
+  if (relativePath.startsWith("src/db/")) {
+    return config.databaseMode !== "memory";
+  }
+  return true;
+}
+function toPlannedFile(relativeTemplatePath) {
+  return {
+    templateRelativePath: relativeTemplatePath,
+    outputRelativePath: stripEjsSuffix(relativeTemplatePath),
+    isTemplate: isEjsTemplate(relativeTemplatePath)
+  };
+}
+function toPackageName(projectName) {
+  const cleaned = projectName.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+  return cleaned || "express-api";
+}
+function toDatabaseName(projectName) {
+  const cleaned = projectName.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+/, "").replace(/_+$/, "");
+  return (cleaned || "express_api") + "_dev";
+}
+function getOsUsername() {
+  try {
+    return os.userInfo().username;
+  } catch {
+    return process.env.USER ?? process.env.USERNAME ?? "postgres";
+  }
+}
+function templateData(config) {
+  const isTypeScript = config.language === "ts";
+  const isEsm = config.moduleSystem === "esm";
+  const isJavaScript = config.language === "js";
+  const useNodemon = isJavaScript && config.jsDevWatcher === "nodemon";
+  const isPostgres = config.databaseMode !== "memory";
+  const isDocker = config.databaseMode === "postgres-docker";
+  const isPsql = config.databaseMode === "postgres-psql";
+  const dbName = toDatabaseName(config.projectName);
+  const username = isPostgres ? getOsUsername() : "";
+  return {
+    ...config,
+    isTypeScript,
+    isEsm,
+    isCommonJs: !isEsm,
+    isPostgres,
+    isDocker,
+    isPsql,
+    packageName: toPackageName(config.projectName),
+    databaseName: dbName,
+    educationalLabel: config.educational ? "On" : "Off",
+    languageLabel: languageLabel(config.language),
+    moduleSystemLabel: moduleSystemLabel(config.moduleSystem),
+    architectureLabel: architectureLabel(config.architecture),
+    databaseLabel: databaseLabel(config.databaseMode),
+    jsDevWatcherLabel: jsDevWatcherLabel(config.jsDevWatcher),
+    jsDevCommand: useNodemon ? "nodemon src/server.js" : "node --watch src/server.js",
+    useNodemon,
+    databaseUrl: config.databaseMode === "postgres-docker" ? `postgres://postgres:postgres@localhost:5433/${dbName}` : `postgres://${encodeURIComponent(username)}:postgres@localhost:5432/${dbName}`,
+    osUsername: username
+  };
+}
+function fromPosixPath(relativePath) {
+  return relativePath.split("/").join(path4.sep);
+}
+async function planProject(config, targetDir) {
+  const templateRoot = resolveTemplateRoot(config);
+  const templateRootExists = await fs2.pathExists(templateRoot);
+  if (!templateRootExists) {
+    throw new Error(`Template root not found: ${templateRoot}`);
+  }
+  const allFiles = await listFilesRecursive(templateRoot);
+  const files = allFiles.map(toPosixPath).filter((relativePath) => shouldIncludeTemplate(relativePath, config)).map(toPlannedFile);
+  return {
+    targetDir,
+    actions: [
+      `Create project directory: ${targetDir}`,
+      `Write ${files.length} files`
+    ],
+    files
+  };
+}
+async function generateProject({
+  config,
+  targetDir,
+  dryRun = false
+}) {
+  const templateRoot = resolveTemplateRoot(config);
+  const plan = await planProject(config, targetDir);
+  if (dryRun) {
+    return plan;
+  }
+  await fs2.ensureDir(targetDir);
+  const data = templateData(config);
+  for (const file of plan.files) {
+    const sourcePath = path4.join(
+      templateRoot,
+      fromPosixPath(file.templateRelativePath)
+    );
+    const destinationPath = path4.join(
+      targetDir,
+      fromPosixPath(file.outputRelativePath)
+    );
+    await fs2.ensureDir(path4.dirname(destinationPath));
+    if (file.isTemplate) {
+      const template = await fs2.readFile(sourcePath, "utf8");
+      const rendered = ejs.render(template, data);
+      await fs2.writeFile(destinationPath, rendered, "utf8");
+      continue;
+    }
+    await fs2.copy(sourcePath, destinationPath);
+  }
+  return plan;
+}
+
+// src/utils/exec.ts
+import { execa } from "execa";
+async function commandExists(command, args = ["--version"]) {
+  try {
+    await execa(command, args, {
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runCommand(command, args, cwd) {
+  await execa(command, args, {
+    cwd,
+    stdio: "inherit"
+  });
+}
+async function installDependencies(cwd, verbose = false) {
+  const args = ["install", "--no-audit", "--no-fund"];
+  if (!verbose) {
+    args.push("--loglevel=error");
+  }
+  await runCommand("npm", args, cwd);
+}
+async function initGitRepo(cwd) {
+  await runCommand("git", ["init"], cwd);
+}
+
+// src/utils/files.ts
+import path5 from "path";
+import fs3 from "fs-extra";
+async function assertSafeTargetDir(targetDir) {
+  const exists = await fs3.pathExists(targetDir);
+  if (!exists) {
+    return;
+  }
+  const stats = await fs3.stat(targetDir);
+  if (!stats.isDirectory()) {
+    throw new Error(`Target path already exists and is not a directory: ${targetDir}`);
+  }
+  const entries = await fs3.readdir(targetDir);
+  if (entries.length > 0) {
+    throw new Error(
+      `Target directory "${path5.basename(targetDir)}" already exists and is not empty.`
+    );
+  }
+}
+
+// src/utils/logger.ts
+var logger = {
+  info(message) {
+    console.log(`${statusTag("info")} ${message}`);
+  },
+  success(message) {
+    console.log(`${statusTag("success")} ${message}`);
+  },
+  warn(message) {
+    console.warn(`${statusTag("warn")} ${message}`);
+  },
+  error(message) {
+    console.error(`${statusTag("error")} ${message}`);
+  }
+};
+
+// src/cli/index.ts
+async function ensurePsqlAvailable() {
+  const hasPsql = await commandExists("psql", ["--version"]);
+  if (!hasPsql) {
+    throw new Error(
+      [
+        "Postgres (psql) mode requires the `psql` client tool, but it was not found.",
+        "Install Postgres client tools and make sure `psql --version` works, or rerun and choose Postgres (Docker)."
+      ].join(" ")
+    );
+  }
+}
+function registerSigintHandler() {
+  process.on("SIGINT", () => {
+    logger.warn("Cancelled by user.");
+    process.exit(1);
+  });
+}
+async function runCli(argv) {
+  const parsedArgs = parseArgs(argv);
+  for (const unknownFlag of parsedArgs.unknownFlags) {
+    logger.warn(`Unknown flag "${unknownFlag}" was ignored.`);
+  }
+  const selections = await collectSelections(parsedArgs);
+  const projectNameError = validateProjectName(selections.projectName);
+  if (projectNameError) {
+    throw new Error(projectNameError);
+  }
+  const targetDir = resolveTargetDir(process.cwd(), selections.projectName);
+  await assertSafeTargetDir(targetDir);
+  if (selections.databaseMode === "postgres-psql") {
+    await ensurePsqlAvailable();
+  }
+  const templateConfig = {
+    projectName: selections.projectName,
+    language: selections.language,
+    moduleSystem: selections.moduleSystem,
+    jsDevWatcher: selections.jsDevWatcher,
+    architecture: selections.architecture,
+    educational: selections.educational,
+    databaseMode: selections.databaseMode
+  };
+  const plan = await planProject(templateConfig, targetDir);
+  if (selections.dryRun) {
+    printDryRunPlan(selections, plan);
+    return;
+  }
+  await generateProject({
+    config: templateConfig,
+    targetDir
+  });
+  logger.success(`Project files generated at ${targetDir}.`);
+  if (selections.installDeps) {
+    const installCommand = parsedArgs.flags.verbose ? "npm install --no-audit --no-fund" : "npm install --no-audit --no-fund --loglevel=error";
+    logger.info(`Installing dependencies (${installCommand})...`);
+    await installDependencies(targetDir, parsedArgs.flags.verbose);
+    logger.success("Dependencies installed.");
+  } else {
+    logger.info("Skipped dependency installation.");
+  }
+  if (selections.initGit) {
+    logger.info("Initializing git repository...");
+    await initGitRepo(targetDir);
+    logger.success("Git repository initialized.");
+  } else {
+    logger.info("Skipped git initialization.");
+  }
+  logger.success("Scaffolding complete.");
+  printNextSteps(selections);
+}
+function isCliEntrypoint() {
+  if (typeof process.argv[1] !== "string") {
+    return false;
+  }
+  try {
+    const argvPath = fs4.realpathSync(process.argv[1]);
+    const modulePath = fs4.realpathSync(fileURLToPath2(import.meta.url));
+    return argvPath === modulePath;
+  } catch {
+    return pathToFileURL(process.argv[1]).href === import.meta.url;
+  }
+}
+var isEntrypoint = isCliEntrypoint();
+if (isEntrypoint) {
+  registerSigintHandler();
+  runCli(process.argv.slice(2)).catch((error) => {
+    if (error instanceof PromptCancelledError) {
+      logger.warn("Cancelled by user.");
+      process.exit(1);
+    }
+    const message = error instanceof Error ? error.message : "Unexpected error";
+    logger.error(message);
+    if (error instanceof Error && error.stack) {
+      console.error(pc4.gray(error.stack));
+    }
+    process.exit(1);
+  });
+}
+export {
+  runCli
+};
+//# sourceMappingURL=cli.js.map