@codecanvascollective/scaffold 0.1.0

package/dist/index.js

@@ -0,0 +1,833 @@
+#!/usr/bin/env node
+import {
+  createDir,
+  directoryExists,
+  getTemplatesDir,
+  renderAndWrite
+} from "./chunk-2A65KFCS.js";
+
+// src/cli.ts
+import { Command as Command4 } from "commander";
+
+// src/commands/create.ts
+import { Command } from "commander";
+import path4 from "path";
+import fs2 from "fs-extra";
+
+// src/prompts/framework.ts
+import inquirer from "inquirer";
+async function promptProjectType() {
+  const { projectType } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "projectType",
+      message: "What type of project?",
+      choices: [
+        { name: "Frontend (React, Next.js, Angular)", value: "frontend" },
+        { name: "Backend (Express, FastAPI)", value: "backend" },
+        { name: "Full-Stack (Frontend + Backend)", value: "fullstack" }
+      ]
+    }
+  ]);
+  return projectType;
+}
+async function promptFramework(projectType) {
+  if (projectType === "frontend") {
+    const { framework: framework2 } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "framework",
+        message: "Which frontend framework?",
+        choices: [
+          { name: "React + Vite", value: "react" },
+          { name: "Next.js (App Router)", value: "nextjs" },
+          { name: "Angular 18", value: "angular" }
+        ]
+      }
+    ]);
+    return framework2;
+  }
+  if (projectType === "backend") {
+    const { framework: framework2 } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "framework",
+        message: "Which backend framework?",
+        choices: [
+          { name: "Express.js", value: "express" },
+          { name: "FastAPI (Python)", value: "fastapi" }
+        ]
+      }
+    ]);
+    return framework2;
+  }
+  const { framework } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "framework",
+      message: "Which frontend framework?",
+      choices: [
+        { name: "React + Vite", value: "react" },
+        { name: "Next.js", value: "nextjs" },
+        { name: "Angular 18", value: "angular" }
+      ]
+    }
+  ]);
+  return framework;
+}
+
+// src/prompts/features.ts
+import inquirer2 from "inquirer";
+async function promptFeatures(projectType, framework) {
+  const isPython = framework === "fastapi";
+  const choices = [
+    {
+      name: "TypeScript",
+      value: "typescript",
+      checked: true,
+      disabled: isPython ? "N/A for Python" : false
+    },
+    { name: "ESLint + Prettier", value: "eslint", checked: !isPython, disabled: isPython ? "N/A for Python" : false },
+    { name: "Tailwind CSS", value: "tailwind", checked: false },
+    { name: "shadcn/ui components", value: "shadcn", checked: false },
+    { name: isPython ? "Pytest testing" : "Vitest testing", value: "testing", checked: true },
+    { name: "GitHub Actions CI/CD", value: "githubActions", checked: false },
+    { name: "Docker setup", value: "docker", checked: false },
+    { name: "Husky pre-commit hooks", value: "husky", checked: false, disabled: isPython ? "N/A for Python" : false },
+    { name: ".env example file", value: "envExample", checked: false }
+  ];
+  const filteredChoices = projectType === "backend" ? choices.filter((c) => !["tailwind", "shadcn"].includes(c.value)) : choices;
+  const { features } = await inquirer2.prompt([
+    {
+      type: "checkbox",
+      name: "features",
+      message: "Select features:",
+      choices: filteredChoices
+    }
+  ]);
+  const selectedFeatures = features;
+  return {
+    typescript: !isPython && selectedFeatures.includes("typescript"),
+    eslint: !isPython && selectedFeatures.includes("eslint"),
+    prettier: !isPython && selectedFeatures.includes("eslint"),
+    tailwind: selectedFeatures.includes("tailwind"),
+    shadcn: selectedFeatures.includes("shadcn"),
+    testing: selectedFeatures.includes("testing"),
+    githubActions: selectedFeatures.includes("githubActions"),
+    docker: selectedFeatures.includes("docker"),
+    husky: !isPython && selectedFeatures.includes("husky"),
+    envExample: selectedFeatures.includes("envExample")
+  };
+}
+
+// src/prompts/config.ts
+import inquirer3 from "inquirer";
+
+// src/constants.ts
+var FRAMEWORKS = {
+  react: {
+    name: "react",
+    displayName: "React + Vite",
+    description: "React 19 with Vite and TypeScript",
+    type: "frontend",
+    variants: ["base", "with-tailwind", "with-shadcn"],
+    language: "typescript"
+  },
+  nextjs: {
+    name: "nextjs",
+    displayName: "Next.js (App Router)",
+    description: "Next.js 15 with App Router and TypeScript",
+    type: "frontend",
+    variants: ["base", "with-auth", "with-prisma"],
+    language: "typescript"
+  },
+  angular: {
+    name: "angular",
+    displayName: "Angular 18",
+    description: "Angular 18 standalone with TypeScript",
+    type: "frontend",
+    variants: ["base"],
+    language: "typescript"
+  },
+  express: {
+    name: "express",
+    displayName: "Express.js",
+    description: "Express 5 with TypeScript",
+    type: "backend",
+    variants: ["base", "with-prisma"],
+    language: "typescript"
+  },
+  fastapi: {
+    name: "fastapi",
+    displayName: "FastAPI",
+    description: "FastAPI with Pydantic and Python",
+    type: "backend",
+    variants: ["base"],
+    language: "python"
+  }
+};
+var VARIANT_DISPLAY_NAMES = {
+  base: "Base (minimal setup)",
+  "with-tailwind": "With Tailwind CSS",
+  "with-shadcn": "With shadcn/ui",
+  "with-auth": "With NextAuth.js",
+  "with-prisma": "With Prisma ORM"
+};
+
+// src/prompts/config.ts
+async function promptVariant(framework) {
+  const meta = FRAMEWORKS[framework];
+  if (meta.variants.length <= 1) {
+    return "base";
+  }
+  const { variant } = await inquirer3.prompt([
+    {
+      type: "list",
+      name: "variant",
+      message: "Select a template variant:",
+      choices: meta.variants.map((v) => ({
+        name: VARIANT_DISPLAY_NAMES[v],
+        value: v
+      }))
+    }
+  ]);
+  return variant;
+}
+async function promptPackageManager() {
+  const { packageManager } = await inquirer3.prompt([
+    {
+      type: "list",
+      name: "packageManager",
+      message: "Package manager?",
+      choices: [
+        { name: "npm", value: "npm" },
+        { name: "yarn", value: "yarn" },
+        { name: "pnpm", value: "pnpm" }
+      ]
+    }
+  ]);
+  return packageManager;
+}
+async function promptGitInit() {
+  const { gitInit } = await inquirer3.prompt([
+    {
+      type: "confirm",
+      name: "gitInit",
+      message: "Initialize git repository?",
+      default: true
+    }
+  ]);
+  return gitInit;
+}
+
+// src/prompts/index.ts
+async function runPrompts(projectName) {
+  const type = await promptProjectType();
+  const framework = await promptFramework(type);
+  const variant = await promptVariant(framework);
+  const features = await promptFeatures(type, framework);
+  const isPython = framework === "fastapi";
+  const packageManager = isPython ? "npm" : await promptPackageManager();
+  const gitInit = await promptGitInit();
+  return {
+    name: projectName,
+    type,
+    framework,
+    variant,
+    features,
+    packageManager,
+    gitInit
+  };
+}
+
+// src/generators/react.ts
+import path2 from "path";
+
+// src/generators/base.ts
+import path from "path";
+import fs from "fs-extra";
+import { execSync } from "child_process";
+
+// src/utils/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+var verbose = false;
+function setVerbose(value) {
+  verbose = value;
+}
+function success(message) {
+  console.log(chalk.green("\u2714"), message);
+}
+function error(message) {
+  console.log(chalk.red("\u2716"), message);
+}
+function debug(message) {
+  if (verbose) {
+    console.log(chalk.gray("\u2B25"), chalk.gray(message));
+  }
+}
+function spinner(text) {
+  return ora({ text, color: "cyan" });
+}
+function newLine() {
+  console.log();
+}
+function banner(text) {
+  console.log(chalk.bold.cyan(text));
+}
+
+// src/utils/validator.ts
+var VALID_PROJECT_NAME = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+function validateProjectName(name) {
+  if (!name || name.trim().length === 0) {
+    return "Project name is required.";
+  }
+  if (!VALID_PROJECT_NAME.test(name)) {
+    return "Project name must be a valid npm package name (lowercase, no spaces, can use hyphens and dots).";
+  }
+  if (name.length > 214) {
+    return "Project name must be less than 214 characters.";
+  }
+  return true;
+}
+async function validateDirectory(dirPath) {
+  if (await directoryExists(dirPath)) {
+    return `Directory "${dirPath}" already exists. Use --force to overwrite.`;
+  }
+  return true;
+}
+
+// src/generators/base.ts
+var BaseGenerator = class {
+  config;
+  targetDir;
+  templatesDir;
+  result = { filesCreated: [], warnings: [] };
+  constructor(config, targetDir) {
+    this.config = config;
+    this.targetDir = targetDir;
+    this.templatesDir = getTemplatesDir();
+  }
+  async generate() {
+    await this.createProjectDir();
+    await this.generateBase();
+    await this.applyVariant();
+    await this.applySharedConfigs();
+    await this.applyFeatures();
+    await this.initGit();
+    return this.result;
+  }
+  async applyVariant() {
+    if (this.config.variant === "base") return;
+    const variantDir = this.getVariantTemplateDir();
+    if (await fs.pathExists(variantDir)) {
+      const s = spinner(`Applying ${this.config.variant} variant`);
+      s.start();
+      await this.renderDirectory(variantDir, this.targetDir);
+      s.stop();
+      success(`Applied ${this.config.variant} variant`);
+    }
+  }
+  async applySharedConfigs() {
+    const sharedDir = path.join(this.templatesDir, "shared");
+    if (this.config.features.eslint) {
+      const s = spinner("Setting up ESLint + Prettier");
+      s.start();
+      await this.renderTemplateFile(
+        path.join(sharedDir, "eslint.config.js.hbs"),
+        path.join(this.targetDir, "eslint.config.js")
+      );
+      await this.renderTemplateFile(
+        path.join(sharedDir, "prettier.config.js.hbs"),
+        path.join(this.targetDir, ".prettierrc")
+      );
+      s.stop();
+      success("Setting up ESLint + Prettier");
+    }
+    await this.renderTemplateFile(
+      path.join(sharedDir, "gitignore.hbs"),
+      path.join(this.targetDir, ".gitignore")
+    );
+    const s2 = spinner("Generating README.md");
+    s2.start();
+    await this.renderTemplateFile(
+      path.join(sharedDir, "readme.md.hbs"),
+      path.join(this.targetDir, "README.md")
+    );
+    s2.stop();
+    success("Generating README.md");
+    await this.renderTemplateFile(
+      path.join(sharedDir, "license.hbs"),
+      path.join(this.targetDir, "LICENSE")
+    );
+  }
+  async applyFeatures() {
+    const sharedDir = path.join(this.templatesDir, "shared");
+    if (this.config.features.githubActions) {
+      const s = spinner("Creating GitHub Actions workflow");
+      s.start();
+      await this.renderTemplateFile(
+        path.join(sharedDir, "github-ci.yml.hbs"),
+        path.join(this.targetDir, ".github", "workflows", "ci.yml")
+      );
+      s.stop();
+      success("Creating GitHub Actions workflow");
+    }
+    if (this.config.features.docker) {
+      const s = spinner("Adding Docker configuration");
+      s.start();
+      await this.renderTemplateFile(
+        path.join(sharedDir, "docker", "Dockerfile.hbs"),
+        path.join(this.targetDir, "Dockerfile")
+      );
+      await this.renderTemplateFile(
+        path.join(sharedDir, "docker", "docker-compose.yml.hbs"),
+        path.join(this.targetDir, "docker-compose.yml")
+      );
+      s.stop();
+      success("Adding Docker configuration");
+    }
+  }
+  async createProjectDir() {
+    const s = spinner("Creating project structure");
+    s.start();
+    await createDir(this.targetDir);
+    s.stop();
+    success("Creating project structure");
+  }
+  async initGit() {
+    if (!this.config.gitInit) return;
+    const s = spinner("Initializing git repository");
+    s.start();
+    try {
+      execSync("git init", { cwd: this.targetDir, stdio: "pipe" });
+      execSync("git add -A", { cwd: this.targetDir, stdio: "pipe" });
+      execSync('git commit -m "Initial commit from scaffold"', {
+        cwd: this.targetDir,
+        stdio: "pipe"
+      });
+      s.stop();
+      success("Initializing git repository");
+    } catch {
+      s.stop();
+      debug("Git initialization skipped (git not available)");
+    }
+  }
+  async renderTemplateFile(templatePath, outputPath) {
+    const templateData = this.getTemplateData();
+    if (await fs.pathExists(templatePath)) {
+      await renderAndWrite(templatePath, outputPath, templateData);
+      this.result.filesCreated.push(outputPath);
+    } else {
+      debug(`Template not found: ${templatePath}`);
+    }
+  }
+  async renderDirectory(srcDir, destDir) {
+    const entries = await fs.readdir(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = path.join(srcDir, entry.name);
+      const destName = entry.name.replace(/\.hbs$/, "");
+      const destPath = path.join(destDir, destName);
+      if (entry.isDirectory()) {
+        await this.renderDirectory(srcPath, destPath);
+      } else if (entry.name.endsWith(".hbs")) {
+        await this.renderTemplateFile(srcPath, destPath);
+      } else {
+        await fs.ensureDir(path.dirname(destPath));
+        await fs.copy(srcPath, destPath);
+        this.result.filesCreated.push(destPath);
+      }
+    }
+  }
+  getTemplateData() {
+    return {
+      ...this.config,
+      year: (/* @__PURE__ */ new Date()).getFullYear()
+    };
+  }
+  getBaseTemplateDir() {
+    return path.join(this.templatesDir, this.config.framework, "base");
+  }
+  getVariantTemplateDir() {
+    return path.join(this.templatesDir, this.config.framework, this.config.variant);
+  }
+};
+
+// src/generators/react.ts
+var ReactGenerator = class extends BaseGenerator {
+  async generateBase() {
+    const baseDir = this.getBaseTemplateDir();
+    const s = spinner("Configuring React + Vite + TypeScript");
+    s.start();
+    await this.renderDirectory(baseDir, this.targetDir);
+    s.stop();
+    success("Configuring React + Vite + TypeScript");
+    if (this.config.features.testing) {
+      success("Configuring Vitest");
+    }
+  }
+  getVariantPath(variant) {
+    return path2.join(this.templatesDir, "react", variant);
+  }
+};
+
+// src/generators/nextjs.ts
+var NextjsGenerator = class extends BaseGenerator {
+  async generateBase() {
+    const baseDir = this.getBaseTemplateDir();
+    const s = spinner("Configuring Next.js + App Router + TypeScript");
+    s.start();
+    await this.renderDirectory(baseDir, this.targetDir);
+    s.stop();
+    success("Configuring Next.js + App Router + TypeScript");
+    if (this.config.features.testing) {
+      success("Configuring Vitest");
+    }
+  }
+};
+
+// src/generators/angular.ts
+var AngularGenerator = class extends BaseGenerator {
+  async generateBase() {
+    const baseDir = this.getBaseTemplateDir();
+    const s = spinner("Configuring Angular 18 + TypeScript");
+    s.start();
+    await this.renderDirectory(baseDir, this.targetDir);
+    s.stop();
+    success("Configuring Angular 18 + TypeScript");
+  }
+};
+
+// src/generators/express.ts
+var ExpressGenerator = class extends BaseGenerator {
+  async generateBase() {
+    const baseDir = this.getBaseTemplateDir();
+    const s = spinner("Configuring Express 5 + TypeScript");
+    s.start();
+    await this.renderDirectory(baseDir, this.targetDir);
+    s.stop();
+    success("Configuring Express 5 + TypeScript");
+    if (this.config.features.testing) {
+      success("Configuring Vitest");
+    }
+  }
+};
+
+// src/generators/fastapi.ts
+var FastAPIGenerator = class extends BaseGenerator {
+  async generateBase() {
+    const baseDir = this.getBaseTemplateDir();
+    const s = spinner("Configuring FastAPI + Pydantic");
+    s.start();
+    await this.renderDirectory(baseDir, this.targetDir);
+    s.stop();
+    success("Configuring FastAPI + Pydantic");
+    if (this.config.features.testing) {
+      success("Configuring Pytest");
+    }
+  }
+  async applySharedConfigs() {
+    const path5 = await import("path");
+    const sharedDir = path5.join(this.templatesDir, "shared");
+    await this.renderTemplateFile(
+      path5.join(sharedDir, "gitignore.hbs"),
+      path5.join(this.targetDir, ".gitignore")
+    );
+    const s = spinner("Generating README.md");
+    s.start();
+    await this.renderTemplateFile(
+      path5.join(sharedDir, "readme.md.hbs"),
+      path5.join(this.targetDir, "README.md")
+    );
+    s.stop();
+    success("Generating README.md");
+    await this.renderTemplateFile(
+      path5.join(sharedDir, "license.hbs"),
+      path5.join(this.targetDir, "LICENSE")
+    );
+  }
+};
+
+// src/generators/fullstack.ts
+import path3 from "path";
+var FullstackGenerator = class extends BaseGenerator {
+  async generateBase() {
+    const s = spinner("Setting up full-stack monorepo");
+    s.start();
+    const webDir = path3.join(this.targetDir, "apps", "web");
+    const apiDir = path3.join(this.targetDir, "apps", "api");
+    await createDir(webDir);
+    await createDir(apiDir);
+    s.stop();
+    success("Setting up full-stack monorepo");
+    const frontendConfig = {
+      ...this.config,
+      type: "frontend",
+      gitInit: false
+    };
+    const FrontendGenerator = this.getFrontendGeneratorClass();
+    const frontendGen = new FrontendGenerator(frontendConfig, webDir);
+    await frontendGen.generateBase();
+    const backendConfig = {
+      ...this.config,
+      type: "backend",
+      framework: "express",
+      gitInit: false
+    };
+    const backendGen = new ExpressGenerator(backendConfig, apiDir);
+    await backendGen.generateBase();
+    const rootPkgPath = path3.join(this.targetDir, "package.json");
+    const rootPkg = {
+      name: this.config.name,
+      private: true,
+      workspaces: ["apps/*"],
+      scripts: {
+        dev: "npm run --workspaces dev",
+        build: "npm run --workspaces build",
+        lint: "npm run --workspaces lint",
+        test: "npm run --workspaces test"
+      }
+    };
+    const { writeFile: writeFile2 } = await import("./file-5IKT7CEX.js");
+    await writeFile2(rootPkgPath, JSON.stringify(rootPkg, null, 2) + "\n");
+  }
+  getFrontendGeneratorClass() {
+    switch (this.config.framework) {
+      case "nextjs":
+        return NextjsGenerator;
+      case "angular":
+        return AngularGenerator;
+      case "react":
+      default:
+        return ReactGenerator;
+    }
+  }
+};
+
+// src/generators/index.ts
+function createGenerator(config, targetDir) {
+  if (config.type === "fullstack") {
+    return new FullstackGenerator(config, targetDir);
+  }
+  switch (config.framework) {
+    case "react":
+      return new ReactGenerator(config, targetDir);
+    case "nextjs":
+      return new NextjsGenerator(config, targetDir);
+    case "angular":
+      return new AngularGenerator(config, targetDir);
+    case "express":
+      return new ExpressGenerator(config, targetDir);
+    case "fastapi":
+      return new FastAPIGenerator(config, targetDir);
+    default:
+      throw new Error(`Unknown framework: ${config.framework}`);
+  }
+}
+
+// src/types/config.ts
+var DEFAULT_FEATURES = {
+  typescript: true,
+  eslint: true,
+  prettier: true,
+  tailwind: false,
+  shadcn: false,
+  testing: true,
+  githubActions: false,
+  docker: false,
+  husky: false,
+  envExample: false
+};
+var DEFAULT_CONFIG = {
+  name: "",
+  type: "frontend",
+  framework: "react",
+  variant: "base",
+  features: { ...DEFAULT_FEATURES },
+  packageManager: "npm",
+  gitInit: true
+};
+
+// src/commands/create.ts
+function createCommand() {
+  const cmd = new Command("create").description("Create a new project").argument("<project-name>", "Name of the project").option("--react", "Create a React + Vite project").option("--nextjs", "Create a Next.js project").option("--angular", "Create an Angular project").option("--express", "Create an Express.js project").option("--fastapi", "Create a FastAPI project").option("-y, --yes", "Skip prompts and use defaults").option("--from <path>", "Create from a config file").option("--force", "Overwrite existing directory").action(async (projectName, options) => {
+    try {
+      await handleCreate(projectName, options);
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+async function handleCreate(projectName, options) {
+  const nameValidation = validateProjectName(projectName);
+  if (nameValidation !== true) {
+    throw new Error(nameValidation);
+  }
+  const targetDir = path4.resolve(process.cwd(), projectName);
+  if (!options.force) {
+    const dirValidation = await validateDirectory(targetDir);
+    if (dirValidation !== true) {
+      throw new Error(dirValidation);
+    }
+  }
+  let config;
+  if (options.from) {
+    config = await loadConfigFromFile(options.from, projectName);
+  } else if (options.yes || hasFrameworkFlag(options)) {
+    config = buildQuickConfig(projectName, options);
+  } else {
+    config = await runPrompts(projectName);
+  }
+  newLine();
+  banner(`Creating project "${config.name}"...`);
+  newLine();
+  const generator = createGenerator(config, targetDir);
+  await generator.generate();
+  newLine();
+  success(`Project "${config.name}" created successfully! \u{1F389}`);
+  newLine();
+  console.log("Next steps:");
+  console.log(`  cd ${config.name}`);
+  if (config.framework === "fastapi") {
+    console.log("  pip install -r requirements.txt");
+    console.log("  uvicorn app.main:app --reload");
+  } else {
+    console.log(`  ${config.packageManager} install`);
+    console.log(`  ${config.packageManager} run dev`);
+  }
+  newLine();
+  console.log("Happy coding! \u{1F680}");
+  newLine();
+}
+function hasFrameworkFlag(options) {
+  return !!(options.react || options.nextjs || options.angular || options.express || options.fastapi);
+}
+function buildQuickConfig(projectName, options) {
+  const config = { ...DEFAULT_CONFIG, name: projectName };
+  if (options.react) {
+    config.type = "frontend";
+    config.framework = "react";
+  } else if (options.nextjs) {
+    config.type = "frontend";
+    config.framework = "nextjs";
+  } else if (options.angular) {
+    config.type = "frontend";
+    config.framework = "angular";
+  } else if (options.express) {
+    config.type = "backend";
+    config.framework = "express";
+  } else if (options.fastapi) {
+    config.type = "backend";
+    config.framework = "fastapi";
+  }
+  return config;
+}
+async function loadConfigFromFile(configPath, projectName) {
+  const resolvedPath = path4.resolve(process.cwd(), configPath);
+  const content = await fs2.readJSON(resolvedPath);
+  return { ...DEFAULT_CONFIG, ...content, name: projectName };
+}
+
+// src/commands/list.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+function listCommand() {
+  return new Command2("list").description("List all available templates").action(() => {
+    newLine();
+    console.log(chalk2.bold.cyan("Available Templates"));
+    console.log(chalk2.gray("\u2500".repeat(60)));
+    newLine();
+    const categories = {
+      Frontend: ["react", "nextjs", "angular"],
+      Backend: ["express", "fastapi"]
+    };
+    for (const [category, frameworks] of Object.entries(categories)) {
+      console.log(chalk2.bold.white(`  ${category}`));
+      newLine();
+      for (const fw of frameworks) {
+        const meta = FRAMEWORKS[fw];
+        console.log(`  ${chalk2.green(meta.displayName.padEnd(25))} ${chalk2.gray(meta.description)}`);
+        for (const variant of meta.variants) {
+          const label = VARIANT_DISPLAY_NAMES[variant];
+          console.log(`    ${chalk2.gray("\u2022")} ${label}`);
+        }
+        newLine();
+      }
+    }
+    console.log(chalk2.gray("\u2500".repeat(60)));
+    console.log(
+      chalk2.gray("  Use"),
+      chalk2.cyan("scaffold create <name> --<framework>"),
+      chalk2.gray("for quick setup")
+    );
+    newLine();
+  });
+}
+
+// src/commands/doctor.ts
+import { Command as Command3 } from "commander";
+import { execSync as execSync2 } from "child_process";
+import chalk3 from "chalk";
+var CHECKS = [
+  { name: "Node.js", command: "node", versionFlag: "--version", required: true },
+  { name: "npm", command: "npm", versionFlag: "--version", required: false },
+  { name: "yarn", command: "yarn", versionFlag: "--version", required: false },
+  { name: "pnpm", command: "pnpm", versionFlag: "--version", required: false },
+  { name: "git", command: "git", versionFlag: "--version", required: true },
+  { name: "Python", command: "python3", versionFlag: "--version", required: false }
+];
+function doctorCommand() {
+  return new Command3("doctor").description("Check system dependencies").action(() => {
+    newLine();
+    console.log(chalk3.bold.cyan("System Check"));
+    console.log(chalk3.gray("\u2500".repeat(40)));
+    newLine();
+    let allGood = true;
+    for (const check of CHECKS) {
+      try {
+        const version = execSync2(`${check.command} ${check.versionFlag ?? "--version"}`, {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        const versionStr = version.split("\n")[0];
+        console.log(`  ${chalk3.green("\u2714")} ${check.name.padEnd(12)} ${chalk3.gray(versionStr)}`);
+      } catch {
+        if (check.required) {
+          console.log(`  ${chalk3.red("\u2716")} ${check.name.padEnd(12)} ${chalk3.red("not found (required)")}`);
+          allGood = false;
+        } else {
+          console.log(`  ${chalk3.yellow("\u2013")} ${check.name.padEnd(12)} ${chalk3.gray("not found (optional)")}`);
+        }
+      }
+    }
+    newLine();
+    if (allGood) {
+      console.log(chalk3.green("  All required dependencies are installed!"));
+    } else {
+      console.log(chalk3.red("  Some required dependencies are missing."));
+    }
+    newLine();
+  });
+}
+
+// src/cli.ts
+function createCli() {
+  const program2 = new Command4();
+  program2.name("scaffold").description("CLI tool for scaffolding modern full-stack projects").version("0.1.0").option("--verbose", "Enable verbose output").hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.verbose) {
+      setVerbose(true);
+    }
+  });
+  program2.addCommand(createCommand());
+  program2.addCommand(listCommand());
+  program2.addCommand(doctorCommand());
+  return program2;
+}
+
+// src/index.ts
+var program = createCli();
+program.parse();
+//# sourceMappingURL=index.js.map