create-bunspace 0.3.1 → 0.5.0

package/dist/bin.js

@@ -5189,6 +5189,11 @@ async function selectTemplate(args) {
         title: "Fumadocs - Documentaci\xF3n con Next.js + MDX + Fumadocs",
         value: "fumadocs",
         description: "Bilingual documentation site with GitHub Pages deployment"
+      },
+      {
+        title: "React Starter - BaseUI + React 19 + Vite 8 + Theme Manager",
+        value: "react-starter",
+        description: "Opinionated React starter with animated UI components and theme management"
       }
     ]
   }, {
@@ -5444,6 +5449,69 @@ Operation cancelled`));
     runInstall: args.noInstall ? false : response.runInstall ?? true
   };
 }
+async function promptReactStarter(args) {
+  const gitUser = await getGitUser();
+  const parsed = parseProjectArg(args.projectName);
+  const response = await import_prompts.default([
+    {
+      type: args.projectName ? null : "text",
+      name: "name",
+      message: "Project name",
+      initial: parsed.name,
+      validate: (value) => {
+        if (!value)
+          return "Project name is required";
+        if (!isValidProjectName(value)) {
+          return "Invalid name. Use lowercase letters, numbers, and hyphens only";
+        }
+        return true;
+      },
+      format: (value) => value.toLowerCase().trim()
+    },
+    {
+      type: args.description ? null : "text",
+      name: "description",
+      message: "Description",
+      initial: "React app with BaseUI, theme management, and animated components"
+    },
+    {
+      type: args.author ? null : "text",
+      name: "author",
+      message: "Author",
+      initial: gitUser || "Anonymous"
+    },
+    {
+      type: args.noGit ? null : "confirm",
+      name: "initGit",
+      message: "Initialize git repository?",
+      initial: true
+    },
+    {
+      type: args.noInstall ? null : "confirm",
+      name: "runInstall",
+      message: "Run bun install?",
+      initial: true
+    }
+  ], {
+    onCancel: () => {
+      console.log(kleur_default.red(`
+Operation cancelled`));
+      process.exit(0);
+    }
+  });
+  const name = args.projectName ? parsed.name : response.name;
+  const targetDir = args.dir || `./${name}`;
+  return {
+    template: "react-starter",
+    name,
+    scope: "",
+    description: args.description || response.description || "",
+    author: args.author || response.author || gitUser || "Anonymous",
+    targetDir,
+    initGit: args.noGit ? false : response.initGit ?? true,
+    runInstall: args.noInstall ? false : response.runInstall ?? true
+  };
+}
 async function promptUser(args, templateType) {
   if (templateType === "telegram-bot") {
     return promptTelegramBot(args);
@@ -5451,6 +5519,9 @@ async function promptUser(args, templateType) {
   if (templateType === "fumadocs") {
     return promptFumadocs(args);
   }
+  if (templateType === "react-starter") {
+    return promptReactStarter(args);
+  }
   return promptMonorepo(args);
 }
 async function getDefaultsMonorepo(args) {
@@ -5512,13 +5583,192 @@ async function getDefaults(args, templateType) {
   if (templateType === "fumadocs") {
     return getDefaultsFumadocs(args);
   }
+  if (templateType === "react-starter") {
+    return getDefaultsReactStarter(args);
+  }
   return getDefaultsMonorepo(args);
 }
+async function getDefaultsReactStarter(args) {
+  const gitUser = await getGitUser();
+  const parsed = parseProjectArg(args.projectName);
+  const targetDir = args.dir || parsed.targetDir;
+  return {
+    template: "react-starter",
+    name: parsed.name,
+    scope: "",
+    description: args.description || "React app with BaseUI, theme management, and animated components",
+    author: args.author || gitUser || "Anonymous",
+    targetDir,
+    initGit: !args.noGit,
+    runInstall: !args.noInstall
+  };
+}
 
 // src/generator.ts
-import { mkdir, readdir, stat, readFile, writeFile, copyFile, rename } from "fs/promises";
-import { join, dirname } from "path";
+import { mkdir, readdir, stat as stat2, readFile as readFile2, writeFile as writeFile2, copyFile, rename } from "fs/promises";
+import { join as join2, dirname } from "path";
+import { existsSync as existsSync2 } from "fs";
+
+// src/guidelines-service.ts
 import { existsSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+var LOCAL_DOTFILES_PATH = join(homedir(), "dotfiles", "MUST-FOLLOW-GUIDELINES.md");
+var GITHUB_RAW_URL = "https://raw.githubusercontent.com/MKS2508/dotfiles/main/MUST-FOLLOW-GUIDELINES.md";
+var GUIDELINES_FILENAME = "MUST-FOLLOW-GUIDELINES.md";
+async function fetchGuidelines() {
+  if (existsSync(LOCAL_DOTFILES_PATH)) {
+    try {
+      const content = await readFile(LOCAL_DOTFILES_PATH, "utf-8");
+      const lines = content.split(`
+`).length;
+      return { content, source: "local", lines };
+    } catch {
+      console.log(kleur_default.yellow("  \u26A0\uFE0F  Failed to read local dotfiles, trying GitHub..."));
+    }
+  }
+  try {
+    const response = await fetch(GITHUB_RAW_URL);
+    if (response.ok) {
+      const content = await response.text();
+      const lines = content.split(`
+`).length;
+      return { content, source: "github", lines };
+    }
+  } catch {}
+  return null;
+}
+async function getGuidelinesForGeneration() {
+  const result = await fetchGuidelines();
+  return result?.content ?? null;
+}
+async function syncGuidelinesToTemplate(templatePath, templateName, guidelinesContent) {
+  const guidelinesPath = join(templatePath, GUIDELINES_FILENAME);
+  const linesCount = guidelinesContent.split(`
+`).length;
+  if (!existsSync(templatePath)) {
+    return {
+      templateName,
+      success: false,
+      action: "skipped",
+      error: "Template directory not found"
+    };
+  }
+  try {
+    if (existsSync(guidelinesPath)) {
+      const existingContent = await readFile(guidelinesPath, "utf-8");
+      if (existingContent === guidelinesContent) {
+        return {
+          templateName,
+          success: true,
+          action: "unchanged",
+          linesCount
+        };
+      }
+      await writeFile(guidelinesPath, guidelinesContent, "utf-8");
+      return {
+        templateName,
+        success: true,
+        action: "updated",
+        linesCount
+      };
+    }
+    await writeFile(guidelinesPath, guidelinesContent, "utf-8");
+    return {
+      templateName,
+      success: true,
+      action: "created",
+      linesCount
+    };
+  } catch (error) {
+    return {
+      templateName,
+      success: false,
+      action: "skipped",
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+async function syncGuidelinesToAllTemplates(templatesDir, templateNames) {
+  const guidelines = await fetchGuidelines();
+  if (!guidelines) {
+    console.log(kleur_default.yellow(`
+  \u26A0\uFE0F  Guidelines not available (no local dotfiles or internet)`));
+    return templateNames.map((name) => ({
+      templateName: name,
+      success: false,
+      action: "skipped",
+      error: "Guidelines source unavailable"
+    }));
+  }
+  console.log(`
+\uD83D\uDCCB Syncing ${kleur_default.cyan(GUIDELINES_FILENAME)} from ${kleur_default.dim(guidelines.source)}...`);
+  console.log(`   ${kleur_default.dim(`(${guidelines.lines} lines)`)}
+`);
+  const results = [];
+  for (const name of templateNames) {
+    const templatePath = join(templatesDir, name);
+    const result = await syncGuidelinesToTemplate(templatePath, name, guidelines.content);
+    results.push(result);
+    const icon = result.success ? result.action === "unchanged" ? "\u2713" : "\u2705" : "\u274C";
+    const actionText = result.action === "created" ? kleur_default.green("created") : result.action === "updated" ? kleur_default.yellow("updated") : result.action === "unchanged" ? kleur_default.dim("unchanged") : kleur_default.red("skipped");
+    console.log(`  ${icon} ${kleur_default.cyan(name)}: ${actionText}${result.error ? ` - ${result.error}` : ""}`);
+  }
+  return results;
+}
+async function checkGuidelinesStatus(templatesDir, templateNames) {
+  console.log(`
+\uD83D\uDCCB ${kleur_default.bold("Guidelines Status Check")}
+`);
+  const guidelines = await fetchGuidelines();
+  if (guidelines) {
+    console.log(`  ${kleur_default.green("\u2713")} Source: ${kleur_default.cyan(guidelines.source)}`);
+    console.log(`  ${kleur_default.green("\u2713")} Lines: ${kleur_default.cyan(guidelines.lines.toString())}`);
+    if (guidelines.source === "local") {
+      console.log(`  ${kleur_default.dim(`    Path: ${LOCAL_DOTFILES_PATH}`)}`);
+    } else {
+      console.log(`  ${kleur_default.dim(`    URL: ${GITHUB_RAW_URL}`)}`);
+    }
+  } else {
+    console.log(`  ${kleur_default.red("\u2717")} Guidelines unavailable`);
+    console.log(`  ${kleur_default.dim(`    Local: ${LOCAL_DOTFILES_PATH} (not found)`)}`);
+    console.log(`  ${kleur_default.dim(`    GitHub: ${GITHUB_RAW_URL} (unreachable)`)}`);
+    return;
+  }
+  console.log(`
+${kleur_default.bold("Template Status:")}
+`);
+  for (const name of templateNames) {
+    const templatePath = join(templatesDir, name);
+    const guidelinesPath = join(templatePath, GUIDELINES_FILENAME);
+    if (!existsSync(templatePath)) {
+      console.log(`  ${kleur_default.red("\u2717")} ${kleur_default.cyan(name)}: ${kleur_default.dim("template not found")}`);
+      continue;
+    }
+    if (!existsSync(guidelinesPath)) {
+      console.log(`  ${kleur_default.yellow("\u26A0")} ${kleur_default.cyan(name)}: ${kleur_default.yellow("missing")}`);
+      continue;
+    }
+    try {
+      const content = await readFile(guidelinesPath, "utf-8");
+      const templateLines = content.split(`
+`).length;
+      const isUpToDate = content === guidelines.content;
+      if (isUpToDate) {
+        console.log(`  ${kleur_default.green("\u2713")} ${kleur_default.cyan(name)}: ${kleur_default.green("up to date")} (${templateLines} lines)`);
+      } else {
+        console.log(`  ${kleur_default.yellow("\u26A0")} ${kleur_default.cyan(name)}: ${kleur_default.yellow("outdated")} (${templateLines} lines vs ${guidelines.lines})`);
+      }
+    } catch {
+      console.log(`  ${kleur_default.red("\u2717")} ${kleur_default.cyan(name)}: ${kleur_default.red("error reading file")}`);
+    }
+  }
+  console.log("");
+}
+
+// src/generator.ts
+var GUIDELINES_FILENAME2 = "MUST-FOLLOW-GUIDELINES.md";
 var TEXT_EXTENSIONS = new Set([
   ".ts",
   ".tsx",
@@ -5557,12 +5807,12 @@ var EXCLUDED_FILES = new Set([
   ".DS_Store"
 ]);
 async function getTemplateDir(templateType) {
-  const submodulePath = join(import.meta.dir, "..", "templates", templateType);
-  if (existsSync(submodulePath)) {
+  const submodulePath = join2(import.meta.dir, "..", "templates", templateType);
+  if (existsSync2(submodulePath)) {
     return submodulePath;
   }
-  const distPath = join(import.meta.dir, "..", "..", "templates", templateType);
-  if (existsSync(distPath)) {
+  const distPath = join2(import.meta.dir, "..", "..", "templates", templateType);
+  if (existsSync2(distPath)) {
     return distPath;
   }
   throw new Error(`Template '${templateType}' not found. Checked submodules and embedded templates.`);
@@ -5570,7 +5820,7 @@ async function getTemplateDir(templateType) {
 async function generateProject(config, templateType) {
   const templateDir = await getTemplateDir(templateType);
   const targetDir = config.targetDir;
-  if (existsSync(targetDir)) {
+  if (existsSync2(targetDir)) {
     const entries = await readdir(targetDir);
     if (entries.length > 0) {
       printError(`Directory ${targetDir} is not empty`);
@@ -5583,12 +5833,23 @@ async function generateProject(config, templateType) {
   printStep("Copying template files...");
   await copyTemplateDir(templateDir, targetDir, placeholders);
   if (templateType === "fumadocs") {
-    const contentTemplatePath = join(targetDir, "content-template");
-    const contentPath = join(targetDir, "content");
-    if (existsSync(contentTemplatePath)) {
+    const contentTemplatePath = join2(targetDir, "content-template");
+    const contentPath = join2(targetDir, "content");
+    if (existsSync2(contentTemplatePath)) {
       await rename(contentTemplatePath, contentPath);
     }
   }
+  printStep("Syncing MUST-FOLLOW-GUIDELINES.md...");
+  const guidelinesContent = await getGuidelinesForGeneration();
+  if (guidelinesContent) {
+    const guidelinesPath = join2(targetDir, GUIDELINES_FILENAME2);
+    await writeFile2(guidelinesPath, guidelinesContent, "utf-8");
+    const lines = guidelinesContent.split(`
+`).length;
+    printStep(`Guidelines synced (${lines} lines)`);
+  } else {
+    printStep("Guidelines source unavailable, using template version");
+  }
   if (config.initGit) {
     printStep("Initializing git repository...");
     await initGit(targetDir);
@@ -5631,6 +5892,15 @@ function generatePlaceholders(config, templateType) {
       SUPPORTED_LOCALES: config.supportedLocales || "es,en"
     };
   }
+  if (templateType === "react-starter") {
+    const projectTitle = config.name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+    return {
+      ...base,
+      PROJECT_NAME: config.name,
+      PROJECT_TITLE: projectTitle,
+      DESCRIPTION: config.description
+    };
+  }
   throw new Error(`Unknown template: ${templateType}`);
 }
 async function copyTemplateDir(src, dest, placeholders) {
@@ -5638,9 +5908,9 @@ async function copyTemplateDir(src, dest, placeholders) {
   for (const entry of entries) {
     if (EXCLUDED_FILES.has(entry))
       continue;
-    const srcPath = join(src, entry);
-    const destPath = join(dest, entry);
-    const stats = await stat(srcPath);
+    const srcPath = join2(src, entry);
+    const destPath = join2(dest, entry);
+    const stats = await stat2(srcPath);
     if (stats.isDirectory()) {
       await mkdir(destPath, { recursive: true });
       await copyTemplateDir(srcPath, destPath, placeholders);
@@ -5660,9 +5930,9 @@ function shouldReplacePlaceholders(filepath) {
 async function copyTemplateFile(src, dest, placeholders) {
   await mkdir(dirname(dest), { recursive: true });
   if (shouldReplacePlaceholders(src)) {
-    const content = await readFile(src, "utf-8");
+    const content = await readFile2(src, "utf-8");
     const replaced = replacePlaceholders(content, placeholders);
-    await writeFile(dest, replaced, "utf-8");
+    await writeFile2(dest, replaced, "utf-8");
   } else {
     await copyFile(src, dest);
   }
@@ -5694,24 +5964,25 @@ async function runBunInstall(targetDir) {
 
 // src/template-manager.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-var ROOT_DIR = join2(import.meta.dir, "..");
-var TEMPLATES_DIR = join2(ROOT_DIR, "templates");
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+var ROOT_DIR = join3(import.meta.dir, "..");
+var TEMPLATES_DIR = join3(ROOT_DIR, "templates");
+var ALL_TEMPLATES = ["monorepo", "telegram-bot", "fumadocs"];
 async function listTemplates() {
   console.log(`
 \uD83D\uDCE6 Templates Status:
 `);
   const templates = ["monorepo", "telegram-bot", "fumadocs"];
   for (const name of templates) {
-    const templatePath = join2(TEMPLATES_DIR, name);
-    if (!existsSync2(templatePath)) {
+    const templatePath = join3(TEMPLATES_DIR, name);
+    if (!existsSync3(templatePath)) {
       console.log(`  \u274C ${name} (missing)
 `);
       continue;
     }
-    const gitDir = join2(templatePath, ".git");
-    if (existsSync2(gitDir)) {
+    const gitDir = join3(templatePath, ".git");
+    if (existsSync3(gitDir)) {
       try {
         const url = await execGit(["config", "remote.origin.url"], { cwd: templatePath, silent: true });
         const branch = await execGit(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: templatePath, silent: true });
@@ -5731,19 +6002,19 @@ async function listTemplates() {
   }
 }
 async function syncTemplates(templateName) {
-  const templates = templateName ? [templateName] : ["monorepo", "telegram-bot"];
+  const templates = templateName ? [templateName] : ALL_TEMPLATES;
   console.log(`
 \uD83D\uDD04 Syncing ${templateName ? kleur_default.cyan(templateName) : "all templates"}...
 `);
   for (const name of templates) {
-    const templatePath = join2(TEMPLATES_DIR, name);
-    if (!existsSync2(templatePath)) {
+    const templatePath = join3(TEMPLATES_DIR, name);
+    if (!existsSync3(templatePath)) {
       console.log(`  \u26A0\uFE0F  Template '${name}' not found. Skipping.
 `);
       continue;
     }
-    const gitDir = join2(templatePath, ".git");
-    if (existsSync2(gitDir)) {
+    const gitDir = join3(templatePath, ".git");
+    if (existsSync3(gitDir)) {
       console.log(`  \uD83D\uDCE5 ${kleur_default.cyan(name)}:`);
       try {
         await execGit(["pull", "--ff-only"], { cwd: templatePath });
@@ -5758,21 +6029,22 @@ async function syncTemplates(templateName) {
 `);
     }
   }
+  await syncGuidelinesToAllTemplates(TEMPLATES_DIR, templates);
   console.log(`${kleur_default.green("\u2728")} Sync complete!
 `);
 }
 async function importTemplate(name, sourcePath) {
-  const targetPath = join2(TEMPLATES_DIR, name);
+  const targetPath = join3(TEMPLATES_DIR, name);
   console.log(`
 \uD83D\uDCE6 Importing '${kleur_default.cyan(name)}' from ${sourcePath}...
 `);
-  if (existsSync2(targetPath)) {
+  if (existsSync3(targetPath)) {
     console.log(`  \u26A0\uFE0F  Template '${name}' already exists.
 `);
     return;
   }
-  const sourceGitDir = join2(sourcePath, ".git");
-  if (existsSync2(sourceGitDir)) {
+  const sourceGitDir = join3(sourcePath, ".git");
+  if (existsSync3(sourceGitDir)) {
     console.log(`  \uD83D\uDD17 Adding as submodule...`);
     try {
       await execGit(["submodule", "add", sourcePath, `templates/${name}`]);
@@ -5846,6 +6118,10 @@ async function main(args) {
     await handleTemplatesCommand(args.slice(1));
     return;
   }
+  if (args[0] === "guidelines") {
+    await handleGuidelinesCommand(args.slice(1));
+    return;
+  }
   try {
     const templateType = await selectTemplate(parsedArgs);
     const config = parsedArgs.yes ? await getDefaults(parsedArgs, templateType) : await promptUser(parsedArgs, templateType);
@@ -5878,9 +6154,9 @@ async function handleTemplatesCommand(args) {
       break;
     default:
       console.error(`
-${printError.title("Unknown template command")} ${command}
+Unknown template command: ${command}
 
-${printError.info("Available commands:")}
+Available commands:
   bun run cli templates list              List all templates
   bun run cli templates sync [name]       Sync templates from git
   bun run cli templates import <name> <path>  Import template from local path
@@ -5888,6 +6164,31 @@ ${printError.info("Available commands:")}
       process.exit(1);
   }
 }
+async function handleGuidelinesCommand(args) {
+  const command = args[0];
+  const templateName = args[1];
+  const templates = templateName ? [templateName] : ALL_TEMPLATES;
+  switch (command) {
+    case "sync":
+      await syncGuidelinesToAllTemplates(TEMPLATES_DIR, templates);
+      console.log(`
+\u2728 Guidelines sync complete!
+`);
+      break;
+    case "check":
+      await checkGuidelinesStatus(TEMPLATES_DIR, ALL_TEMPLATES);
+      break;
+    default:
+      console.error(`
+Unknown guidelines command: ${command || "(none)"}
+
+Available commands:
+  bun run cli guidelines sync [template]  Sync MUST-FOLLOW-GUIDELINES.md to templates
+  bun run cli guidelines check            Check guidelines status across templates
+`);
+      process.exit(1);
+  }
+}
 
 // bin.ts
 main(process.argv.slice(2));