@codefast/cli 0.3.1-canary.1 → 0.3.1-canary.11

package/dist/index.cjs

@@ -0,0 +1,1011 @@
+#!/usr/bin/env node
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return 'undefined' == typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+var __webpack_exports__ = {};
+const external_commander_namespaceObject = require("commander");
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_readline_namespaceObject = require("node:readline");
+var external_node_readline_default = /*#__PURE__*/ __webpack_require__.n(external_node_readline_namespaceObject);
+const rl = external_node_readline_default().createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+function utils_prompt(question) {
+    return new Promise((resolve)=>{
+        rl.question(question, (answer)=>{
+            resolve(answer.trim());
+        });
+    });
+}
+function runCommand(command) {
+    (0, external_node_child_process_namespaceObject.execSync)(command, {
+        stdio: "inherit"
+    });
+}
+function writeConfigFile(filePath, content) {
+    external_node_fs_default().writeFileSync(filePath, content);
+    console.log(`📝 Created ${filePath}`);
+}
+function validateProjectName(name) {
+    if (!name || /^\s*$/.test(name)) return {
+        valid: false,
+        error: "Project name cannot be empty or contain only whitespace."
+    };
+    if (name.length > 100) return {
+        valid: false,
+        error: "Project name is too long (maximum 100 characters)."
+    };
+    const npmNameRegex = /^[a-z0-9-~][a-z0-9-._~]*$/;
+    if (!npmNameRegex.test(name)) return {
+        valid: false,
+        error: "Project name must be URL-friendly (letters, numbers, hyphens, underscores, dots; no @ or scoped packages)."
+    };
+    if ("." === name || ".." === name) return {
+        valid: false,
+        error: "Project name cannot be '.' or '..'."
+    };
+    const reservedNames = /^(?<reserved>CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i;
+    if (reservedNames.test(name)) return {
+        valid: false,
+        error: `Project name "${name}" is a reserved system name.`
+    };
+    const fullPath = external_node_path_default().resolve(process.cwd(), name);
+    if (external_node_fs_default().existsSync(fullPath)) return {
+        valid: false,
+        error: `A directory named "${name}" already exists.`
+    };
+    try {
+        external_node_fs_default().accessSync(process.cwd(), external_node_fs_default().constants.W_OK);
+    } catch  {
+        return {
+            valid: false,
+            error: "Cannot create project: No write permission in current directory."
+        };
+    }
+    return {
+        valid: true
+    };
+}
+async function getValidProjectName(initialName, attempts = 0, maxAttempts = 3) {
+    const projectName = initialName ?? await utils_prompt("Enter project name: ");
+    const validation = validateProjectName(projectName);
+    if (validation.valid) return projectName;
+    if (attempts >= maxAttempts - 1) throw new Error(`❌ Exceeded maximum attempts to enter a valid project name.`);
+    console.error(`❌ ${validation.error} (${maxAttempts - attempts - 1} attempts remaining)`);
+    return getValidProjectName(void 0, attempts + 1, maxAttempts);
+}
+async function checkExistingProject(projectNameArg) {
+    const packageJsonPath = external_node_path_default().join(process.cwd(), "package.json");
+    const packageJsonExists = external_node_fs_default().existsSync(packageJsonPath);
+    if (packageJsonExists) {
+        console.log(`⚠️ A package.json file has been detected in the current directory.`);
+        const confirm = await utils_prompt("Do you want to continue configuring this existing project? [Y/n]: ");
+        if ("" === confirm || "y" === confirm.toLowerCase()) {
+            const packageJson = JSON.parse(external_node_fs_default().readFileSync(packageJsonPath, "utf8"));
+            const projectName = packageJson.name ?? await getValidProjectName(projectNameArg);
+            return {
+                projectName,
+                packageJsonExists
+            };
+        }
+        console.log("Aborting...");
+        throw new Error("User aborted the operation.");
+    }
+    const projectName = await getValidProjectName(projectNameArg);
+    return {
+        projectName,
+        packageJsonExists
+    };
+}
+const MAIN_DEPENDENCIES = [
+    "@codefast/ui",
+    "@codefast/hooks",
+    "recharts",
+    "react-hook-form",
+    "next-themes",
+    "date-fns",
+    "lucide-react"
+];
+const DEV_DEPENDENCIES = {
+    commitLint: [
+        "@commitlint/cli",
+        "@commitlint/config-conventional",
+        "@commitlint/types"
+    ],
+    gitTools: [
+        "simple-git-hooks"
+    ],
+    formatting: [
+        "prettier",
+        "prettier-plugin-packagejson",
+        "prettier-plugin-tailwindcss",
+        "lint-staged"
+    ],
+    linting: [
+        "@codefast/eslint-config"
+    ]
+};
+const PACKAGES_TO_REMOVE = [
+    "@eslint/eslintrc",
+    "eslint-config-next"
+];
+const configGroups = {
+    deployment: [
+        {
+            path: ".vercelignore",
+            content: `#-------------------------------------------------------------------------------
+# Dependencies and package managers
+#-------------------------------------------------------------------------------
+
+# Node dependencies
+node_modules
+.pnpm-store
+.yarn
+
+#-------------------------------------------------------------------------------
+# Development and environment
+#-------------------------------------------------------------------------------
+
+# Environment variables (except examples)
+.env*
+!.env.example
+
+# Build artifacts
+.next
+build
+dist
+.git
+.github
+.turbo
+.changeset
+.eslintcache
+
+# Debug logs
+npm-debug.log*
+yarn-debug.log*
+
+#-------------------------------------------------------------------------------
+# Testing
+#-------------------------------------------------------------------------------
+
+# Test coverage reports and config snapshots
+coverage
+*.test.*
+*.e2e.*
+
+#-------------------------------------------------------------------------------
+# Editor and IDE configuration
+#-------------------------------------------------------------------------------
+
+# IDE project files
+.idea
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+
+#-------------------------------------------------------------------------------
+# Operating system files
+#-------------------------------------------------------------------------------
+
+# System metadata files
+.DS_Store
+Thumbs.db
+
+#-------------------------------------------------------------------------------
+# Deployment
+#-------------------------------------------------------------------------------
+
+# Vercel deployment configuration
+.vercel
+`,
+            description: "Ignore files that should not be deployed to Vercel"
+        }
+    ],
+    formatting: [
+        {
+            path: "prettier.config.mjs",
+            content: `/**
+ * @see https://prettier.io/docs/en/configuration.html
+ * @type {import('prettier').Config}
+ */
+const config = {
+  plugins: ["prettier-plugin-packagejson", "prettier-plugin-tailwindcss"],
+  printWidth: 100,
+  tailwindAttributes: ["classNames"],
+  tailwindFunctions: ["tv"],
+};
+
+export default config;
+`,
+            description: "Prettier configuration for source code formatting"
+        },
+        {
+            path: ".editorconfig",
+            content: `# https://editorconfig.org
+root = true
+
+[*]
+charset = utf-8
+insert_final_newline = true
+
+end_of_line = lf
+indent_style = space
+indent_size = 2
+max_line_length = 120
+
+trim_trailing_whitespace = true
+
+[Makefile]
+indent_style = tab
+
+[{go.mod,go.sum,*.go}]
+indent_style = tab
+
+[*.rs]
+# Keep in sync with rustfmt
+indent_size = 4
+`,
+            description: "Editor configuration for source code formatting"
+        },
+        {
+            path: ".prettierignore",
+            content: `# changesets
+.changeset
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# lock files
+package-lock.json
+yarn.lock
+pnpm-lock.yaml
+src/app/globals.css
+`,
+            description: ""
+        }
+    ],
+    linting: [
+        {
+            path: "commitlint.config.mjs",
+            content: `/**
+ * @see https://commitlint.js.org/reference/configuration.html
+ * @type {import('@commitlint/types').UserConfig}
+ */
+const config = {
+  extends: ["@commitlint/config-conventional"],
+  rules: {
+    "body-max-line-length": [2, "always", 350],
+  },
+};
+
+export default config;
+`,
+            description: "Commitlint configuration"
+        },
+        {
+            path: "eslint.config.mjs",
+            content: `import { config } from "@codefast/eslint-config/next";
+/**
+ * @see https://eslint.org/docs/latest/use/configure/configuration-files
+ * @type {import('eslint').Linter.Config[]}
+ */
+const eslintConfig = [...config];
+
+export default eslintConfig;
+`,
+            description: "ESLint configuration for the project"
+        },
+        {
+            path: "lint-staged.config.mjs",
+            content: `import { relative } from "node:path";
+
+/**
+ * Builds an ESLint command with the given filenames.
+ *
+ * @param {string[]} filenames - An array of filenames to be passed to the
+ *   ESLint command.
+ * @returns {string} - The generated ESLint command.
+ */
+function buildEslintCommand(filenames) {
+  return \`next lint --fix --max-warnings 0 --file \${filenames.map((file) => relative(import.meta.dirname, file)).
+    join(" --file ")}\`;
+}
+
+/**
+ * @see https://www.npmjs.com/package/lint-staged
+ * @type {import('lint-staged').Configuration}
+ */
+const config = {
+  "*.{js,mjs,jsx,ts,tsx}": [buildEslintCommand, "prettier --list-different --write"],
+  "*.{json,css,md,mdx}": ["prettier --list-different --write"],
+};
+
+export default config;
+`,
+            description: "Configure lint-staged for pre-commit checks"
+        }
+    ],
+    styles: [
+        {
+            path: "src/lib/fonts.ts",
+            content: `import { cn } from "@codefast/ui";
+import { Geist, Geist_Mono as GeistMono } from "next/font/google";
+
+const fontGeistSans = Geist({
+  subsets: ["latin"],
+  variable: "--font-geist-sans",
+});
+
+const fontGeistMono = GeistMono({
+  subsets: ["latin"],
+  variable: "--font-geist-mono",
+});
+
+export const fontVariables = cn(fontGeistSans.variable, fontGeistMono.variable);
+`,
+            description: "Font configuration for the application"
+        },
+        {
+            path: "src/app/globals.css",
+            content: `@import "tailwindcss";
+
+@import "@codefast/ui/styles.css";
+
+@source '../../node_modules/@codefast/ui';
+
+@custom-variant dark (&:where(.dark, .dark *));
+
+@layer base {
+  :root {
+    --font-sans: var(--font-geist-sans);
+    --font-mono: var(--font-geist-mono);
+    --input: var(--color-neutral-200);
+    --border: var(--color-neutral-200);
+    --ring: var(--color-neutral-400);
+    --background: var(--color-white);
+    --foreground: var(--color-neutral-950);
+    --primary: var(--color-sky-500);
+    --primary-foreground: var(--color-neutral-50);
+    --secondary: var(--color-neutral-100);
+    --secondary-foreground: var(--color-neutral-900);
+    --destructive: var(--color-red-600);
+    --accent: var(--color-neutral-100);
+    --accent-foreground: var(--color-neutral-900);
+    --muted: var(--color-neutral-100);
+    --muted-foreground: var(--color-neutral-500);
+    --popover: var(--color-white);
+    --popover-foreground: var(--color-neutral-950);
+    --popover-overlay: --alpha(var(--color-neutral-900) / 20%);
+    --card: var(--color-white);
+    --card-foreground: var(--color-neutral-950);
+    --sidebar: var(--color-neutral-50);
+    --sidebar-foreground: var(--color-neutral-950);
+    --sidebar-primary: var(--color-sky-500);
+    --sidebar-primary-foreground: var(--color-neutral-50);
+    --sidebar-accent: var(--color-neutral-100);
+    --sidebar-accent-foreground: var(--color-neutral-900);
+    --sidebar-border: var(--color-neutral-200);
+    --sidebar-ring: var(--color-neutral-400);
+    --chart-1: var(--color-orange-600);
+    --chart-2: var(--color-teal-600);
+    --chart-3: var(--color-cyan-600);
+    --chart-4: var(--color-amber-600);
+    --chart-5: var(--color-amber-500);
+  }
+  .dark {
+    --input: var(--color-neutral-700);
+    --border: --alpha(var(--color-neutral-700) / 50%);
+    --ring: var(--color-neutral-500);
+    --background: var(--color-neutral-950);
+    --foreground: var(--color-neutral-50);
+    --primary: var(--color-sky-700);
+    --primary-foreground: var(--color-neutral-50);
+    --secondary: var(--color-neutral-800);
+    --secondary-foreground: var(--color-neutral-50);
+    --destructive: var(--color-red-400);
+    --accent: var(--color-neutral-700);
+    --accent-foreground: var(--color-neutral-50);
+    --muted: var(--color-neutral-800);
+    --muted-foreground: var(--color-neutral-400);
+    --popover: var(--color-neutral-800);
+    --popover-foreground: var(--color-neutral-50);
+    --popover-overlay: --alpha(var(--color-neutral-900) / 80%);
+    --card: var(--color-neutral-900);
+    --card-foreground: var(--color-neutral-50);
+    --sidebar: var(--color-neutral-900);
+    --sidebar-foreground: var(--color-neutral-50);
+    --sidebar-primary: var(--color-sky-700);
+    --sidebar-primary-foreground: var(--color-neutral-50);
+    --sidebar-accent: var(--color-neutral-800);
+    --sidebar-accent-foreground: var(--color-neutral-50);
+    --sidebar-border: var(--color-neutral-800);
+    --sidebar-ring: var(--color-neutral-600);
+    --chart-1: var(--color-blue-700);
+    --chart-2: var(--color-emerald-500);
+    --chart-3: var(--color-amber-500);
+    --chart-4: var(--color-purple-500);
+    --chart-5: var(--color-rose-500);
+  }
+}
+`,
+            description: "Global CSS variables for the application"
+        }
+    ]
+};
+function updatePostcssConfig(projectDir) {
+    const postcssConfigPath = external_node_path_default().join(projectDir, "postcss.config.mjs");
+    if (!external_node_fs_default().existsSync(postcssConfigPath)) return void console.warn(`⚠️ postcss.config.mjs not found, skipping update.`);
+    let content = external_node_fs_default().readFileSync(postcssConfigPath, "utf8");
+    const typeComment = `/** @type {import('postcss-load-config').Config} */\n`;
+    if (content.includes(typeComment)) console.log(`📝 postcss.config.mjs already contains type comment, no changes made.`);
+    else {
+        content = content.replace("const config = {", `${typeComment}const config = {`);
+        external_node_fs_default().writeFileSync(postcssConfigPath, content);
+        console.log(`📝 Updated postcss.config.mjs with type comment.`);
+    }
+}
+function updateLayoutFile(projectDir) {
+    const layoutPath = external_node_path_default().join(projectDir, "src/app/layout.tsx");
+    if (!external_node_fs_default().existsSync(layoutPath)) return void console.warn(`⚠️ src/app/layout.tsx not found, skipping update.`);
+    let content = external_node_fs_default().readFileSync(layoutPath, "utf8");
+    if (content.includes('<html className={cn(fontVariables, "antialiased")} lang="en">')) return void console.log(`📝 src/app/layout.tsx already uses fontVariables in html tag, no changes made.`);
+    const newImports = `import type { Metadata } from "next";
+
+import { cn } from "@codefast/ui";
+
+import { fontVariables } from "@/lib/fonts";
+import "@/app/globals.css";`;
+    content = content.replaceAll(/import\s+{[^}]+}\s+from\s+["']next\/font\/google["'];\s*/g, "");
+    content = content.replace(/const\s+geistSans\s*=[^;]+;\s*const\s+geistMono\s*=[^;]+;\s*/, "");
+    content = content.replace(/import\s+type\s+{[^}]+}\s+from\s+["']next["'];\s*import\s+["']\.\/globals\.css["'];\s*/, newImports);
+    const htmlRegex = /<html\s+lang="en"\s*>/;
+    const newHtml = '<html className={cn(fontVariables, "antialiased")} lang="en">';
+    content = content.replace(htmlRegex, newHtml);
+    const bodyRegex = /<body\s+className={`[^`]*`}\s*>/;
+    const newBody = "<body>";
+    content = content.replace(bodyRegex, newBody);
+    try {
+        external_node_fs_default().writeFileSync(layoutPath, content);
+        console.log(`📝 Updated src/app/layout.tsx to use fontVariables in html tag and removed className from body`);
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+        console.warn(`⚠️ Failed to update src/app/layout.tsx: ${errorMessage}`);
+    }
+}
+function updatePackageJson(projectDir) {
+    const packageJsonPath = external_node_path_default().join(projectDir, "package.json");
+    const packageJson = JSON.parse(external_node_fs_default().readFileSync(packageJsonPath, "utf8"));
+    packageJson.scripts = {
+        ...packageJson.scripts,
+        "deploy:preview": "vercel deploy --archive=tgz",
+        "deploy:prod": "vercel deploy --archive=tgz --prod",
+        format: "prettier --write --ignore-unknown .",
+        "format:check": "prettier --check --ignore-unknown .",
+        lint: "next lint --fix --max-warnings 0",
+        "lint:check": "next lint --max-warnings 0",
+        "package:install": "pnpm install",
+        "package:outdated": "pnpm outdated",
+        "package:upgrade": "pnpm update --latest",
+        preview: "pnpm build && pnpm start"
+    };
+    packageJson["simple-git-hooks"] = {
+        "pre-commit": "pnpm lint-staged",
+        "commit-msg": "pnpm commitlint --edit"
+    };
+    external_node_fs_default().writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    console.log(`📝 Updated package.json`);
+}
+function updateNextConfig(projectDir) {
+    const nextConfigPath = external_node_path_default().join(projectDir, "next.config.ts");
+    if (!external_node_fs_default().existsSync(nextConfigPath)) return void console.warn(`⚠️ next.config.ts not found, skipping update.`);
+    let content = external_node_fs_default().readFileSync(nextConfigPath, "utf8");
+    if (content.includes('optimizePackageImports: ["@codefast/ui"]')) return void console.log(`📝 next.config.ts already contains optimizePackageImports configuration, no changes made.`);
+    const configPattern = /const nextConfig: NextConfig = \{/;
+    const experimentalConfig = `const nextConfig: NextConfig = {
+  experimental: {
+    optimizePackageImports: ["@codefast/ui"],
+  },`;
+    content = content.replace(configPattern, experimentalConfig);
+    try {
+        external_node_fs_default().writeFileSync(nextConfigPath, content);
+        console.log(`📝 Updated next.config.ts with optimizePackageImports configuration.`);
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+        console.warn(`⚠️ Failed to update next.config.ts: ${errorMessage}`);
+    }
+}
+function createConfigFiles(projectDir) {
+    console.log(`\n📝 Creating configuration files...`);
+    for (const [category, configs] of Object.entries(configGroups)){
+        console.log(`\n📂 Setting up ${category} configurations:`);
+        for (const { path: filePath, content, description } of configs){
+            const fullPath = external_node_path_default().join(projectDir, filePath);
+            const dir = external_node_path_default().dirname(fullPath);
+            if (!external_node_fs_default().existsSync(dir)) external_node_fs_default().mkdirSync(dir, {
+                recursive: true
+            });
+            writeConfigFile(fullPath, content);
+            if (description) console.log(`  ℹ️ ${filePath}: ${description}`);
+        }
+    }
+}
+function installDependencies() {
+    console.log(`\n📚 Installing dependencies...`);
+    if (MAIN_DEPENDENCIES.length > 0) runCommand(`pnpm add ${MAIN_DEPENDENCIES.join(" ")}`);
+    const allDevDependencies = Object.values(DEV_DEPENDENCIES).flat().join(" ");
+    if (allDevDependencies) runCommand(`pnpm add -D ${allDevDependencies}`);
+}
+function cleanupPackages() {
+    console.log(`\n🧹 Cleaning up unnecessary packages...`);
+    const packageJsonPath = external_node_path_namespaceObject.join(process.cwd(), "package.json");
+    if (!external_node_fs_namespaceObject.existsSync(packageJsonPath)) return void console.warn(`⚠️ package.json not found, skipping cleanup.`);
+    let packageJson;
+    try {
+        packageJson = JSON.parse(external_node_fs_namespaceObject.readFileSync(packageJsonPath, "utf8"));
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+        console.warn(`⚠️ Error reading package.json: ${errorMessage}, skipping cleanup.`);
+        return;
+    }
+    const dependencies = packageJson.dependencies ?? {};
+    const devDependencies = packageJson.devDependencies ?? {};
+    const packagesToRemove = PACKAGES_TO_REMOVE.filter((pkg)=>pkg in dependencies || pkg in devDependencies);
+    if (packagesToRemove.length > 0) runCommand(`pnpm remove ${packagesToRemove.join(" ")}`);
+    else console.log(`ℹ️ No unnecessary packages found in package.json to remove.`);
+}
+function checkEnvironment() {
+    try {
+        (0, external_node_child_process_namespaceObject.execSync)("pnpm --version", {
+            stdio: "ignore"
+        });
+    } catch  {
+        console.error(`❌ PNPM chưa được cài đặt. Vui lòng cài đặt PNPM trước.`);
+        process.exit(1);
+    }
+}
+function createNextProject(projectName) {
+    console.log(`📦 Creating Next.js project...`);
+    const flags = '--ts --tailwind --eslint --app --turbo --use-pnpm --src-dir --turbopack --import-alias "@/*"';
+    runCommand(`npx create-next-app@latest ${projectName} ${flags}`);
+}
+function createProjectCommand(program) {
+    program.command("create-project [name]").description("Create a new Next.js project with recommended setup").action(async (projectNameArg)=>{
+        try {
+            checkEnvironment();
+            const { projectName, packageJsonExists } = await checkExistingProject(projectNameArg);
+            if (!packageJsonExists) {
+                console.log(`\n🚀 Starting project creation for ${projectName}...\n`);
+                createNextProject(projectName);
+                process.chdir(projectName);
+                console.log(`📂 Moved to ${projectName}`);
+            }
+            updateLayoutFile(process.cwd());
+            updatePostcssConfig(process.cwd());
+            installDependencies();
+            cleanupPackages();
+            createConfigFiles(process.cwd());
+            updateNextConfig(process.cwd());
+            updatePackageJson(process.cwd());
+            console.log(`\n🔄 Activating git hooks...`);
+            runCommand("pnpm simple-git-hooks");
+            console.log(`\n📝 Formatting files with Prettier...`);
+            runCommand("pnpm format");
+            console.log(`\n✅ Project ${packageJsonExists ? "configured" : "created"} successfully!`);
+            console.log(`- Project: ${projectName}`);
+            console.log("- Next.js with TypeScript");
+            console.log("- TailwindCSS and @codefast/ui");
+            console.log("- ESLint, Prettier, Commitlint, and Git Hooks");
+            console.log("- Lint-staged for pre-commit checks");
+            console.log(`\n📁 Project directory: ${process.cwd()}`);
+            console.log(`\n🚀 To start development:`);
+            console.log(`cd ${projectName} && pnpm dev`);
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            console.error(`\n❌ An error occurred: ${errorMessage}`);
+            process.exit(1);
+        } finally{
+            rl.close();
+        }
+    });
+}
+const external_glob_namespaceObject = require("glob");
+const external_ts_morph_namespaceObject = require("ts-morph");
+function makeRegexPrefixesToRemove(prefixes) {
+    const prefixPattern = prefixes.join("|");
+    return new RegExp(`^.?\\/?(?:${prefixPattern})\\/(.*)$`);
+}
+function processExportPath(modulePath, regexPattern) {
+    let processedPath = modulePath;
+    const match = processedPath.match(regexPattern);
+    if (match) {
+        const remainingPath = match[1];
+        processedPath = remainingPath.startsWith("./") ? remainingPath : `./${remainingPath}`;
+    }
+    return processedPath;
+}
+function analyzeImports(indexFilePath, packageConfig) {
+    const project = new external_ts_morph_namespaceObject.Project();
+    let sourceFile;
+    try {
+        sourceFile = project.addSourceFileAtPath(indexFilePath);
+    } catch (error) {
+        console.error(`Error loading source file at ${indexFilePath}:`, error);
+        return {
+            imports: []
+        };
+    }
+    const imports = [];
+    const prefixesToRemove = packageConfig.exportPathPrefixesToRemove ?? [];
+    const regexPattern = makeRegexPrefixesToRemove(prefixesToRemove);
+    for (const exportDecl of sourceFile.getExportDeclarations()){
+        let moduleSpecifier = exportDecl.getModuleSpecifierValue();
+        if (!moduleSpecifier) continue;
+        if (moduleSpecifier.startsWith("@/")) moduleSpecifier = `./${moduleSpecifier.slice(2)}`;
+        const isExternal = !moduleSpecifier.startsWith(".");
+        if (isExternal) continue;
+        const parts = moduleSpecifier.split("/").filter(Boolean);
+        if (parts.length < 2) continue;
+        let directory;
+        if (parts.length <= 1) directory = ".";
+        else {
+            directory = parts.slice(0, -1).join("/");
+            if (directory.startsWith("./")) directory = directory.slice(2);
+        }
+        const name = parts.at(-1) ?? "";
+        const importPath = {
+            originalPath: moduleSpecifier,
+            directory,
+            name,
+            exportPath: processExportPath(moduleSpecifier, regexPattern)
+        };
+        imports.push(importPath);
+    }
+    return {
+        imports
+    };
+}
+const external_lodash_es_namespaceObject = require("lodash-es");
+const external_zod_namespaceObject = require("zod");
+const PackageConfigSchema = external_zod_namespaceObject.z["interface"]({
+    cjsOutputPattern: external_zod_namespaceObject.z.string(),
+    esmOutputPattern: external_zod_namespaceObject.z.string(),
+    packageJsonPath: external_zod_namespaceObject.z.string(),
+    srcIndexPath: external_zod_namespaceObject.z.string(),
+    typesOutputCjsPattern: external_zod_namespaceObject.z.string(),
+    typesOutputPattern: external_zod_namespaceObject.z.string(),
+    "exportPathPrefixesToRemove?": external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string())
+});
+const ScriptConfigSchema = external_zod_namespaceObject.z["interface"]({
+    customPackageConfigs: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), PackageConfigSchema.partial()),
+    defaultPackageConfig: PackageConfigSchema,
+    packagesGlob: external_zod_namespaceObject.z.string()
+});
+let cachedConfig = null;
+function loadConfigFile(configPath) {
+    if (!configPath) return {};
+    try {
+        const fullPath = external_node_path_default().resolve(configPath);
+        if (!external_node_fs_default().existsSync(fullPath)) {
+            console.warn(`Configuration file not found at ${fullPath}`);
+            return {};
+        }
+        const configContent = external_node_fs_default().readFileSync(fullPath, "utf8");
+        const config = JSON.parse(configContent);
+        return ScriptConfigSchema.parse(config);
+    } catch (error) {
+        console.error("Error reading configuration file:", error);
+        return {};
+    }
+}
+function getConfig(configPath) {
+    if (cachedConfig && !configPath) return cachedConfig;
+    const userConfig = loadConfigFile(configPath);
+    const config = (0, external_lodash_es_namespaceObject.merge)({}, defaultConfig, userConfig);
+    if (!configPath) cachedConfig = config;
+    return config;
+}
+function getPackageConfig(packageName, config) {
+    const configObj = config ?? getConfig();
+    const customConfig = configObj.customPackageConfigs[packageName] ?? {};
+    return {
+        ...configObj.defaultPackageConfig,
+        ...customConfig
+    };
+}
+const defaultConfig = {
+    packagesGlob: "./packages/**/package.json",
+    defaultPackageConfig: {
+        cjsOutputPattern: "./dist/cjs/{dir}/{name}.cjs",
+        esmOutputPattern: "./dist/esm/{dir}/{name}.js",
+        packageJsonPath: "package.json",
+        srcIndexPath: "src/index.ts",
+        typesOutputCjsPattern: "./dist/types/{dir}/{name}.d.ts",
+        typesOutputPattern: "./dist/types/{dir}/{name}.d.ts"
+    },
+    customPackageConfigs: {
+        "@codefast/ui": {
+            exportPathPrefixesToRemove: [
+                "components"
+            ]
+        },
+        "@codefast/style-guide": {
+            exportPathPrefixesToRemove: [
+                "configs"
+            ]
+        }
+    }
+};
+const EXPORTS_ANALYSIS_DIR = ".exports-analysis";
+const EXPORTS_PREVIEW_FILE = "exports-preview.json";
+const EXPORTS_ANALYSIS_FILE = "exports-analysis.json";
+const ENCODING = "utf8";
+const JSON_INDENT = 2;
+const FileUtils = {
+    exists (filePath) {
+        return external_node_fs_default().existsSync(filePath);
+    },
+    ensureDirectoryExists (dirPath) {
+        if (!external_node_fs_default().existsSync(dirPath)) external_node_fs_default().mkdirSync(dirPath, {
+            recursive: true
+        });
+    },
+    readJsonFile (filePath) {
+        try {
+            const content = external_node_fs_default().readFileSync(filePath, ENCODING);
+            return JSON.parse(content);
+        } catch (error) {
+            console.error(`Error reading JSON file at ${filePath}:`, error);
+            return null;
+        }
+    },
+    writeJsonFile (filePath, content) {
+        try {
+            external_node_fs_default().writeFileSync(filePath, `${JSON.stringify(content, null, JSON_INDENT)}\n`, ENCODING);
+            return true;
+        } catch (error) {
+            console.error(`Error writing JSON file at ${filePath}:`, error);
+            return false;
+        }
+    },
+    getAnalysisDir (packageDir) {
+        const outputDir = external_node_path_default().join(packageDir, EXPORTS_ANALYSIS_DIR);
+        this.ensureDirectoryExists(outputDir);
+        return outputDir;
+    },
+    createBackupFilename (baseFilename) {
+        const timestamp = new Date().toISOString().replaceAll(/[:.]/g, "-");
+        return `${baseFilename}.backup.${timestamp}`;
+    }
+};
+function fileExists(filePath) {
+    return FileUtils.exists(filePath);
+}
+function readPackageJson(filePath) {
+    return FileUtils.readJsonFile(filePath);
+}
+function backupPackageJson(filePath) {
+    try {
+        const content = external_node_fs_default().readFileSync(filePath, ENCODING);
+        const dir = external_node_path_default().dirname(filePath);
+        const backupDir = external_node_path_default().join(dir, EXPORTS_ANALYSIS_DIR);
+        FileUtils.ensureDirectoryExists(backupDir);
+        const baseName = external_node_path_default().basename(filePath);
+        const backupPath = external_node_path_default().join(backupDir, FileUtils.createBackupFilename(baseName));
+        external_node_fs_default().writeFileSync(backupPath, content, ENCODING);
+        return true;
+    } catch (error) {
+        console.error(`Error backing up package.json at ${filePath}:`, error);
+        return false;
+    }
+}
+function savePackageJson(filePath, content) {
+    return FileUtils.writeJsonFile(filePath, content);
+}
+function saveJsonToFile(packageDir, fileName, content) {
+    const outputDir = FileUtils.getAnalysisDir(packageDir);
+    FileUtils.writeJsonFile(external_node_path_default().join(outputDir, fileName), content);
+}
+function saveExportsAnalysis(packageDir, analysis) {
+    saveJsonToFile(packageDir, EXPORTS_ANALYSIS_FILE, analysis);
+}
+function saveExportsPreview(packageDir, exports1) {
+    saveJsonToFile(packageDir, EXPORTS_PREVIEW_FILE, exports1);
+}
+function formatOutputPath(pattern, directory, name) {
+    const dirPart = "." === directory ? "" : `${directory}/`;
+    return pattern.replace("{dir}/", dirPart).replace("{dir}", directory).replace("{name}", name);
+}
+function generateExports(packageName, imports, existingExports = {}, config) {
+    const packageConfig = getPackageConfig(packageName, config);
+    const exports1 = {
+        ".": existingExports["."] ?? {
+            import: {
+                types: "./dist/types/index.d.ts",
+                default: "./dist/esm/index.js"
+            },
+            require: {
+                types: "./dist/types/index.d.cts",
+                default: "./dist/cjs/index.cjs"
+            }
+        }
+    };
+    if (existingExports["./styles.css"]) exports1["./styles.css"] = existingExports["./styles.css"];
+    for (const importPath of imports){
+        const { directory, name, exportPath } = importPath;
+        const esmOutput = formatOutputPath(packageConfig.esmOutputPattern, directory, name);
+        const cjsOutput = formatOutputPath(packageConfig.cjsOutputPattern, directory, name);
+        const typesOutput = formatOutputPath(packageConfig.typesOutputPattern, directory, name);
+        const typesCjsOutput = formatOutputPath(packageConfig.typesOutputCjsPattern, directory, name);
+        exports1[exportPath] = {
+            import: {
+                types: typesOutput,
+                default: esmOutput
+            },
+            require: {
+                types: typesCjsOutput,
+                default: cjsOutput
+            }
+        };
+    }
+    return exports1;
+}
+const DEFAULT_IGNORE_PATTERN = [
+    "**/node_modules/**"
+];
+async function findAllPackages(config) {
+    const configObj = config ?? getConfig();
+    return await (0, external_glob_namespaceObject.glob)(configObj.packagesGlob, {
+        ignore: DEFAULT_IGNORE_PATTERN
+    });
+}
+function processPackage(packageJsonPath, options) {
+    const packageDir = external_node_path_default().dirname(packageJsonPath);
+    const packageJson = readPackageJson(packageJsonPath);
+    if (!packageJson) {
+        console.error(`Failed to read ${packageJsonPath}`);
+        return false;
+    }
+    const packageName = packageJson.name;
+    if (options.packageFilter && packageName !== options.packageFilter) {
+        console.debug(`Skipping ${packageName} (does not match filter)`);
+        return false;
+    }
+    console.info(`Processing package: ${packageName}`);
+    const config = getConfig(options.configPath);
+    const packageConfig = getPackageConfig(packageName, config);
+    const srcIndexPath = external_node_path_default().join(packageDir, packageConfig.srcIndexPath);
+    if (!fileExists(srcIndexPath)) {
+        console.error(`Source file not found at ${srcIndexPath}`);
+        return false;
+    }
+    console.info(`Analyzing imports from ${srcIndexPath}...`);
+    const { imports } = analyzeImports(srcIndexPath, packageConfig);
+    if (0 === imports.length) {
+        console.warn(`No imports found to analyze in ${packageName}`);
+        return false;
+    }
+    console.log(`Analysis complete. Found ${imports.length} subpath exports.`);
+    saveExportsAnalysis(packageDir, {
+        imports
+    });
+    const newExports = generateExports(packageName, imports, packageJson.exports, config);
+    const currentExportsCount = packageJson.exports ? Object.keys(packageJson.exports).length : 0;
+    const newExportsCount = Object.keys(newExports).length;
+    console.info(`Exports: ${currentExportsCount} -> ${newExportsCount}`);
+    if (options.dryRun) {
+        saveExportsPreview(packageDir, newExports);
+        console.warn("Saved exports preview to .exports-analysis");
+        console.warn(`Dry run: no changes saved for ${packageName}`);
+        return true;
+    }
+    if (backupPackageJson(packageJsonPath)) console.log(`Backed up ${packageJsonPath}`);
+    const updatedPackageJson = {
+        ...packageJson,
+        exports: newExports
+    };
+    if (savePackageJson(packageJsonPath, updatedPackageJson)) {
+        console.log(`Updated exports for ${packageName}`);
+        return true;
+    }
+    console.error(`Failed to update ${packageJsonPath}`);
+    return false;
+}
+async function processAllPackages(options) {
+    try {
+        console.info("Searching for packages...");
+        const config = getConfig(options.configPath);
+        const packageJsonPaths = await findAllPackages(config);
+        if (0 === packageJsonPaths.length) return void console.warn("No packages found.");
+        console.log(`Found ${packageJsonPaths.length} packages.`);
+        let successCount = 0;
+        let skipCount = 0;
+        let errorCount = 0;
+        for (const packageJsonPath of packageJsonPaths){
+            const result = processPackage(packageJsonPath, options);
+            if (result) successCount++;
+            else if (options.packageFilter) skipCount++;
+            else errorCount++;
+        }
+        console.log("Completed exports update.");
+        console.info(`Stats: ${successCount} succeeded, ${skipCount} skipped, ${errorCount} failed`);
+    } catch (error) {
+        console.error("Error processing packages:", error);
+        throw error;
+    }
+}
+function createUpdateExportsCommand(program) {
+    program.command("update-exports").description("Updates exports for all packages").option("-p, --package <package>", "Filter by package name").option("-d, --dry-run", "Run without making changes").option("-c, --config <path>", "Path to configuration file").action(async (options)=>{
+        const processorOptions = {
+            packageFilter: options.package,
+            dryRun: Boolean(options.dryRun),
+            configPath: options.config
+        };
+        try {
+            await processAllPackages(processorOptions);
+        } catch (error) {
+            console.error("Error processing packages:", error);
+            process.exit(1);
+        }
+    });
+}
+const external_node_url_namespaceObject = require("node:url");
+function getPackageInfo() {
+    const __filename1 = (0, external_node_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__);
+    const __dirname = (0, external_node_path_namespaceObject.dirname)(__filename1);
+    const packageJsonPath = (0, external_node_path_namespaceObject.resolve)(__dirname, "../package.json");
+    return JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(packageJsonPath, "utf8"));
+}
+function getPackageVersion() {
+    return getPackageInfo().version;
+}
+function main() {
+    const program = new external_commander_namespaceObject.Command();
+    program.name("codefast").description("CodeFast CLI - A development toolkit for CodeFast.").version(getPackageVersion(), "-v, --version", "display CLI version");
+    createUpdateExportsCommand(program);
+    createProjectCommand(program);
+    program.action(()=>{
+        console.log('Use "codefast create-project" to create a new Next.js project.');
+        console.log('Use "codefast update-exports" to update exports.');
+        console.log('Run "codefast --help" to see all available commands.');
+        program.help();
+    });
+    program.parse(process.argv);
+}
+main();
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+//# sourceMappingURL=index.cjs.map