@codefast/cli 0.3.1-canary.9 → 0.3.2-canary.0

package/dist/index.cjs

@@ -25,137 +25,118 @@ var __webpack_require__ = {};
     __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
 })();
 var __webpack_exports__ = {};
+const external_inversify_namespaceObject = require("inversify");
 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"
-    });
+const external_node_process_namespaceObject = require("node:process");
+var external_node_process_default = /*#__PURE__*/ __webpack_require__.n(external_node_process_namespaceObject);
+const TYPES = {
+    ProjectRepository: Symbol.for("ProjectRepository"),
+    PackageRepository: Symbol.for("PackageRepository"),
+    FileSystemPort: Symbol.for("FileSystemPort"),
+    CommandExecutorPort: Symbol.for("CommandExecutorPort"),
+    PromptPort: Symbol.for("PromptPort"),
+    AnalysisPort: Symbol.for("AnalysisPort"),
+    PackageInfoService: Symbol.for("PackageInfoService"),
+    DependencyConfigService: Symbol.for("DependencyConfigService"),
+    ConfigService: Symbol.for("ConfigService"),
+    FileSystemUtility: Symbol.for("FileSystemUtility"),
+    CreateProjectUseCase: Symbol.for("CreateProjectUseCase"),
+    UpdateExportsUseCase: Symbol.for("UpdateExportsUseCase"),
+    CreateProjectCommand: Symbol.for("CreateProjectCommand"),
+    UpdateExportsCommand: Symbol.for("UpdateExportsCommand"),
+    CLIAdapter: Symbol.for("CLIAdapter")
+};
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-function writeConfigFile(filePath, content) {
-    external_node_fs_default().writeFileSync(filePath, content);
-    console.log(`📝 Created ${filePath}`);
+function _ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
 }
-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)."
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
     };
-    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."
-        };
+}
+class CreateProjectCommand {
+    constructor(createProjectUseCase){
+        this.createProjectUseCase = createProjectUseCase;
+    }
+    getCommand() {
+        return new external_commander_namespaceObject.Command().name("create-project").description("Create a new Next.js project with TypeScript, TailwindCSS, and linting setup").argument("[project-name]", "Name of the project to create").action(async (projectName)=>{
+            await this.createProjectUseCase.execute(projectName);
+            external_node_process_default().exit(0);
+        });
     }
-    return {
-        valid: true
+}
+CreateProjectCommand = _ts_decorate([
+    (0, external_inversify_namespaceObject.injectable)(),
+    _ts_param(0, (0, external_inversify_namespaceObject.inject)(TYPES.CreateProjectUseCase)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        "undefined" == typeof CreateProjectUseCase ? Object : CreateProjectUseCase
+    ])
+], CreateProjectCommand);
+function update_exports_command_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function update_exports_command_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+function update_exports_command_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
     };
 }
-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.");
+class UpdateExportsCommand {
+    constructor(updateExportsUseCase){
+        this.updateExportsUseCase = updateExportsUseCase;
+    }
+    getCommand() {
+        return new external_commander_namespaceObject.Command().name("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)=>{
+            await this.updateExportsUseCase.execute({
+                packageFilter: options.package,
+                dryRun: Boolean(options.dryRun),
+                configPath: options.config
+            });
+            external_node_process_namespaceObject.exit(0);
+        });
     }
-    const projectName = await getValidProjectName(projectNameArg);
-    return {
-        projectName,
-        packageJsonExists
-    };
 }
-const MAIN_DEPENDENCIES = [
-    "@codefast/ui",
-    "@codefast/hooks"
-];
-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: `#-------------------------------------------------------------------------------
+UpdateExportsCommand = update_exports_command_ts_decorate([
+    (0, external_inversify_namespaceObject.injectable)(),
+    update_exports_command_ts_param(0, (0, external_inversify_namespaceObject.inject)(TYPES.UpdateExportsUseCase)),
+    update_exports_command_ts_metadata("design:type", Function),
+    update_exports_command_ts_metadata("design:paramtypes", [
+        "undefined" == typeof UpdateExportsUseCase ? Object : UpdateExportsUseCase
+    ])
+], UpdateExportsCommand);
+function handleError(error, defaultMessage) {
+    const message = error instanceof Error ? error.message : defaultMessage;
+    console.error(`
+\u{274C} ${message}`);
+}
+function config_service_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+class ConfigService {
+    getConfigGroups() {
+        return this.configGroups;
+    }
+    constructor(){
+        this.configGroups = {
+            deployment: [
+                {
+                    path: ".vercelignore",
+                    content: `#-------------------------------------------------------------------------------
 # Dependencies and package managers
 #-------------------------------------------------------------------------------
 
@@ -221,13 +202,13 @@ Thumbs.db
 # Vercel deployment configuration
 .vercel
 `,
-            description: "Ignore files that should not be deployed to Vercel"
-        }
-    ],
-    formatting: [
-        {
-            path: "prettier.config.mjs",
-            content: `/**
+                    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}
  */
@@ -240,11 +221,11 @@ const config = {
 
 export default config;
 `,
-            description: "Prettier configuration for source code formatting"
-        },
-        {
-            path: ".editorconfig",
-            content: `# https://editorconfig.org
+                    description: "Prettier configuration for source code formatting"
+                },
+                {
+                    path: ".editorconfig",
+                    content: `# https://editorconfig.org
 root = true
 
 [*]
@@ -268,13 +249,31 @@ indent_style = tab
 # Keep in sync with rustfmt
 indent_size = 4
 `,
-            description: "Editor configuration for source code formatting"
-        }
-    ],
-    linting: [
-        {
-            path: "commitlint.config.mjs",
-            content: `/**
+                    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
+`,
+                    description: ""
+                }
+            ],
+            linting: [
+                {
+                    path: "commitlint.config.mjs",
+                    content: `/**
  * @see https://commitlint.js.org/reference/configuration.html
  * @type {import('@commitlint/types').UserConfig}
  */
@@ -282,16 +281,18 @@ const config = {
   extends: ["@commitlint/config-conventional"],
   rules: {
     "body-max-line-length": [2, "always", 350],
+    "header-max-length": [2, "always", 150],
   },
 };
 
 export default config;
 `,
-            description: "Commitlint configuration"
-        },
-        {
-            path: "eslint.config.mjs",
-            content: `import { config } from "@codefast/eslint-config/next";
+                    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[]}
@@ -300,11 +301,11 @@ const eslintConfig = [...config];
 
 export default eslintConfig;
 `,
-            description: "ESLint configuration for the project"
-        },
-        {
-            path: "lint-staged.config.mjs",
-            content: `import { relative } from "node:path";
+                    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.
@@ -329,13 +330,13 @@ const config = {
 
 export default config;
 `,
-            description: "Configure lint-staged for pre-commit checks"
-        }
-    ],
-    styles: [
-        {
-            path: "src/lib/fonts.ts",
-            content: `import { cn } from "@codefast/ui";
+                    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({
@@ -350,11 +351,11 @@ const fontGeistMono = GeistMono({
 
 export const fontVariables = cn(fontGeistSans.variable, fontGeistMono.variable);
 `,
-            description: "Font configuration for the application"
-        },
-        {
-            path: "src/app/globals.css",
-            content: `@import "tailwindcss";
+                    description: "Font configuration for the application"
+                },
+                {
+                    path: "src/app/globals.css",
+                    content: `@import "tailwindcss";
 
 @import "@codefast/ui/styles.css";
 
@@ -366,6 +367,7 @@ export const fontVariables = cn(fontGeistSans.variable, fontGeistMono.variable);
   :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);
@@ -399,7 +401,8 @@ export const fontVariables = cn(fontGeistSans.variable, fontGeistMono.variable);
     --chart-4: var(--color-amber-600);
     --chart-5: var(--color-amber-500);
   }
-  @variant dark {
+
+  .dark {
     --input: var(--color-neutral-700);
     --border: --alpha(var(--color-neutral-700) / 50%);
     --ring: var(--color-neutral-500);
@@ -435,528 +438,998 @@ export const fontVariables = cn(fontGeistSans.variable, fontGeistMono.variable);
   }
 }
 `,
-            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 "**/*.{js,mjs,jsx,ts,tsx,json,css,md,mdx}"',
-        "format:check": 'prettier --check "**/*.{js,mjs,jsx,ts,tsx,json,css,md,mdx}"',
-        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 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}`);
-        }
+                    description: "Global CSS variables for the application"
+                }
+            ]
+        };
     }
 }
-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);
-    }
+ConfigService = config_service_ts_decorate([
+    (0, external_inversify_namespaceObject.injectable)()
+], ConfigService);
+function create_project_use_case_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function create_project_use_case_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
 }
-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 create_project_use_case_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
 }
-function createProjectCommand(program) {
-    program.command("create-project [name]").description("Create a new Next.js project with recommended setup").action(async (projectNameArg)=>{
+class create_project_use_case_CreateProjectUseCase {
+    constructor(projectRepository, fileSystemPort, commandExecutorPort, promptPort, configService){
+        this.projectRepository = projectRepository;
+        this.fileSystemPort = fileSystemPort;
+        this.commandExecutorPort = commandExecutorPort;
+        this.promptPort = promptPort;
+        this.configService = configService;
+    }
+    async execute(projectName) {
         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());
-            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`);
+            this.commandExecutorPort.checkEnvironment();
+            const project = await this.checkExistingProject(projectName);
+            const configGroups = this.configService.getConfigGroups();
+            this.createOrConfigureProject(project, configGroups);
+            this.displaySuccessMessage(project);
+            return project;
         } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-            console.error(`\n❌ An error occurred: ${errorMessage}`);
-            process.exit(1);
+            handleError(error, "Failed to create or configure project");
+            throw error;
         } finally{
-            rl.close();
+            this.promptPort.close();
+        }
+    }
+    async checkExistingProject(projectNameArg) {
+        return await this.projectRepository.checkExistingProject(projectNameArg);
+    }
+    createOrConfigureProject(project, configGroups) {
+        if (!project.packageJsonExists) {
+            console.log(`
+\u{1F680} Starting project creation for ${project.name}...\n`);
+            this.projectRepository.createNextProject(project.name);
+            process.chdir(project.name);
+            console.log(`\u{1F4C2} Moved to ${project.name}`);
         }
-    });
+        this.updateProjectFiles(project.directory);
+        this.commandExecutorPort.installDependencies();
+        this.commandExecutorPort.cleanupPackages();
+        this.fileSystemPort.createConfigFiles(project.directory, configGroups);
+        this.projectRepository.updateNextConfig(project.directory);
+        this.projectRepository.updatePackageJson(project.directory);
+        this.commandExecutorPort.enableGitHooks();
+        this.commandExecutorPort.runFormatter();
+        this.commandExecutorPort.runLinter();
+    }
+    updateProjectFiles(projectDir) {
+        this.projectRepository.updateLayoutFile(projectDir);
+        this.projectRepository.updatePageFile(projectDir);
+        this.projectRepository.updatePostcssConfig(projectDir);
+    }
+    displaySuccessMessage(project) {
+        console.log(`
+\u{2705} Project ${project.packageJsonExists ? "configured" : "created"} successfully!`);
+        console.log(`- Project: ${project.name}`);
+        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(`
+\u{1F4C1} Project directory: ${process.cwd()}`);
+        console.log(`
+\u{1F680} To start development:`);
+        console.log(`${project.packageJsonExists ? `cd ${project.name} && ` : ""}pnpm dev`);
+    }
 }
-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: []
-        };
+create_project_use_case_CreateProjectUseCase = create_project_use_case_ts_decorate([
+    (0, external_inversify_namespaceObject.injectable)(),
+    create_project_use_case_ts_param(0, (0, external_inversify_namespaceObject.inject)(TYPES.ProjectRepository)),
+    create_project_use_case_ts_param(1, (0, external_inversify_namespaceObject.inject)(TYPES.FileSystemPort)),
+    create_project_use_case_ts_param(2, (0, external_inversify_namespaceObject.inject)(TYPES.CommandExecutorPort)),
+    create_project_use_case_ts_param(3, (0, external_inversify_namespaceObject.inject)(TYPES.PromptPort)),
+    create_project_use_case_ts_param(4, (0, external_inversify_namespaceObject.inject)(TYPES.ConfigService)),
+    create_project_use_case_ts_metadata("design:type", Function),
+    create_project_use_case_ts_metadata("design:paramtypes", [
+        "undefined" == typeof ProjectRepositoryInterface ? Object : ProjectRepositoryInterface,
+        "undefined" == typeof FileSystemPort ? Object : FileSystemPort,
+        "undefined" == typeof CommandExecutorPort ? Object : CommandExecutorPort,
+        "undefined" == typeof PromptPort ? Object : PromptPort,
+        void 0 === ConfigService ? Object : ConfigService
+    ])
+], create_project_use_case_CreateProjectUseCase);
+function update_exports_use_case_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function update_exports_use_case_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+function update_exports_use_case_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+class update_exports_use_case_UpdateExportsUseCase {
+    constructor(packageRepository){
+        this.packageRepository = packageRepository;
     }
-    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);
+    async execute(options) {
+        try {
+            console.info("\u2662\u2012 Searching for packages...");
+            const packageJsonPaths = await this.packageRepository.findAllPackages(options.configPath);
+            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 = this.packageRepository.processPackage(packageJsonPath, options);
+                if (result) successCount++;
+                else if (options.packageFilter) skipCount++;
+                else errorCount++;
+            }
+            console.log("\u2662\u2012 Completed exports update.\n");
+            console.info(`Stats: ${successCount} succeeded, ${skipCount} skipped, ${errorCount} failed`);
+        } catch (error) {
+            handleError(error, "Error processing packages");
+            throw error;
         }
-        const name = parts.at(-1) ?? "";
-        const importPath = {
-            originalPath: moduleSpecifier,
-            directory,
-            name,
-            exportPath: processExportPath(moduleSpecifier, regexPattern)
-        };
-        imports.push(importPath);
     }
-    return {
-        imports
+}
+update_exports_use_case_UpdateExportsUseCase = update_exports_use_case_ts_decorate([
+    (0, external_inversify_namespaceObject.injectable)(),
+    update_exports_use_case_ts_param(0, (0, external_inversify_namespaceObject.inject)(TYPES.PackageRepository)),
+    update_exports_use_case_ts_metadata("design:type", Function),
+    update_exports_use_case_ts_metadata("design:paramtypes", [
+        "undefined" == typeof PackageRepository ? Object : PackageRepository
+    ])
+], update_exports_use_case_UpdateExportsUseCase);
+function cli_adapter_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function cli_adapter_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+function cli_adapter_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
     };
 }
-const external_lodash_es_namespaceObject = require("lodash-es");
+class CLIAdapter {
+    constructor(createProjectCommand, updateExportsCommand, packageInfoService){
+        this.createProjectCommand = createProjectCommand;
+        this.updateExportsCommand = updateExportsCommand;
+        this.packageInfoService = packageInfoService;
+    }
+    initialize() {
+        const program = new external_commander_namespaceObject.Command();
+        program.name("codefast").description("CodeFast CLI - A development toolkit for CodeFast.").version(this.packageInfoService.getPackageVersion(), "-v, --version", "display CLI version").addCommand(this.createProjectCommand.getCommand()).addCommand(this.updateExportsCommand.getCommand()).parse(process.argv);
+    }
+}
+CLIAdapter = cli_adapter_ts_decorate([
+    (0, external_inversify_namespaceObject.injectable)(),
+    cli_adapter_ts_param(0, (0, external_inversify_namespaceObject.inject)(TYPES.CreateProjectCommand)),
+    cli_adapter_ts_param(1, (0, external_inversify_namespaceObject.inject)(TYPES.UpdateExportsCommand)),
+    cli_adapter_ts_param(2, (0, external_inversify_namespaceObject.inject)(TYPES.PackageInfoService)),
+    cli_adapter_ts_metadata("design:type", Function),
+    cli_adapter_ts_metadata("design:paramtypes", [
+        void 0 === CreateProjectCommand ? Object : CreateProjectCommand,
+        void 0 === UpdateExportsCommand ? Object : UpdateExportsCommand,
+        "undefined" == typeof PackageInfoServiceInterface ? Object : PackageInfoServiceInterface
+    ])
+], CLIAdapter);
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 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 packageConfigSchema = external_zod_namespaceObject.z.object({
+    cjsOutputPattern: external_zod_namespaceObject.z.string().describe("Output pattern for CommonJS format, e.g., './dist/cjs/{dir}/{name}.cjs'"),
+    esmOutputPattern: external_zod_namespaceObject.z.string().describe("Output pattern for ESM format, e.g., './dist/esm/{dir}/{name}.js'"),
+    packageJsonPath: external_zod_namespaceObject.z.string().describe("Path to the package.json file, e.g., 'package.json'"),
+    srcIndexPath: external_zod_namespaceObject.z.string().describe("Path to the source index file, e.g., 'src/index.ts'"),
+    typesOutputCjsPattern: external_zod_namespaceObject.z.string().describe("Output pattern for CommonJS type declarations, e.g., './dist/types/{dir}/{name}.d.cts'"),
+    typesOutputPattern: external_zod_namespaceObject.z.string().describe("Output pattern for type declarations, e.g., './dist/types/{dir}/{name}.d.ts'"),
+    exportPathPrefixesToRemove: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional().describe("Prefixes to remove from export paths, e.g., ['components']")
 });
-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()
+const scriptConfigSchema = external_zod_namespaceObject.z.object({
+    customPackageConfigs: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), packageConfigSchema.partial()).describe("Custom configurations for specific packages"),
+    defaultPackageConfig: packageConfigSchema.describe("Default configuration applied to all packages unless overridden"),
+    packagesGlob: external_zod_namespaceObject.z.string().describe("Glob pattern to find package.json files, e.g., './packages/**/package.json'")
 });
-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
+external_zod_namespaceObject.z.object({
+    directory: external_zod_namespaceObject.z.string().describe("Directory containing the import, e.g., 'components'"),
+    exportPath: external_zod_namespaceObject.z.string().describe("Resolved export path from the directory, e.g., './button'"),
+    name: external_zod_namespaceObject.z.string().describe("Name of the import, e.g., 'Button'"),
+    originalPath: external_zod_namespaceObject.z.string().describe("Original unresolved path, e.g., './components/button'")
+});
+const exportConfigSchema = external_zod_namespaceObject.z.object({
+    import: external_zod_namespaceObject.z.object({
+        default: external_zod_namespaceObject.z.string().describe("ESM default export path"),
+        types: external_zod_namespaceObject.z.string().describe("ESM types export path")
+    }),
+    require: external_zod_namespaceObject.z.object({
+        default: external_zod_namespaceObject.z.string().describe("CommonJS default export path"),
+        types: external_zod_namespaceObject.z.string().describe("CommonJS types export path")
+    })
+});
+const PackageExportsSchema = external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.union([
+    exportConfigSchema,
+    external_zod_namespaceObject.z.string()
+]));
+const packageJsonSchema = external_zod_namespaceObject.z.object({
+    dependencies: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.string()).optional().describe("List of runtime dependencies with their versions"),
+    devDependencies: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.string()).optional().describe("List of development dependencies with their versions"),
+    exports: PackageExportsSchema.optional().describe("Export mappings for the package"),
+    name: external_zod_namespaceObject.z.string().describe("Name of the package"),
+    scripts: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.string()).describe("Script commands defined for the package"),
+    "simple-git-hooks": external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.string()).optional().describe("Git hooks configuration for the package"),
+    version: external_zod_namespaceObject.z.string().optional().describe("Version of the package")
+}).catchall(external_zod_namespaceObject.z.unknown());
+function node_command_executor_adapter_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function node_command_executor_adapter_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+function node_command_executor_adapter_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
     };
 }
-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"
-            ]
+class NodeCommandExecutorAdapter {
+    constructor(fileSystemPort, dependencyConfigService){
+        this.fileSystemPort = fileSystemPort;
+        this.dependencyConfigService = dependencyConfigService;
+    }
+    runCommand(command) {
+        (0, external_node_child_process_namespaceObject.execSync)(command, {
+            stdio: "inherit"
+        });
+    }
+    checkEnvironment() {
+        try {
+            this.runCommand("pnpm --version");
+        } catch  {
+            throw new Error("PNPM is not installed. Please install PNPM first.");
         }
     }
-};
-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) {
+    installDependencies() {
+        console.log(`
+\u{1F4DA} Installing dependencies...`);
+        const mainDependencies = this.dependencyConfigService.getMainDependencies();
+        if (mainDependencies.length > 0) this.runCommand(`pnpm add ${mainDependencies.join(" ")}`);
+        const devDependencies = this.dependencyConfigService.getDevDependencies();
+        const allDevDependencies = Object.values(devDependencies).flat().join(" ");
+        if (allDevDependencies) this.runCommand(`pnpm add -D ${allDevDependencies}`);
+    }
+    cleanupPackages() {
+        console.log(`
+\u{1F9F9} Cleaning up unnecessary packages...`);
+        const packageJsonPath = external_node_path_default().join(process.cwd(), "package.json");
+        if (!this.fileSystemPort.exists(packageJsonPath)) return void console.warn(`\u{26A0}\u{FE0F} package.json not found, skipping cleanup.`);
+        let packageJson;
+        try {
+            packageJson = packageJsonSchema.parse(JSON.parse(this.fileSystemPort.readFile(packageJsonPath)));
+        } catch (error) {
+            console.warn(`\u{26A0}\u{FE0F} Error reading package.json: ${error instanceof Error ? error.message : "Unknown error"}, skipping cleanup.`);
+            return;
+        }
+        const dependencies = packageJson.dependencies ?? {};
+        const devDependencies = packageJson.devDependencies ?? {};
+        const packagesToRemove = this.dependencyConfigService.getPackagesToRemove().filter((pkg)=>pkg in dependencies || pkg in devDependencies);
+        if (packagesToRemove.length > 0) this.runCommand(`pnpm remove ${packagesToRemove.join(" ")}`);
+        else console.log(`\u{2139}\u{FE0F} No unnecessary packages found in package.json to remove.`);
+    }
+    enableGitHooks() {
+        console.log(`
+\u{1F504} Activating git hooks...`);
+        this.runCommand("pnpm simple-git-hooks");
+    }
+    runFormatter() {
+        console.log(`
+\u{1F4DD} Formatting files with Prettier...`);
+        this.runCommand("pnpm format");
+    }
+    runLinter() {
+        console.log(`
+\u{1F50D} Running ESLint to check code style...`);
+        this.runCommand("pnpm lint");
+    }
+}
+NodeCommandExecutorAdapter = node_command_executor_adapter_ts_decorate([
+    (0, external_inversify_namespaceObject.injectable)(),
+    node_command_executor_adapter_ts_param(0, (0, external_inversify_namespaceObject.inject)(TYPES.FileSystemPort)),
+    node_command_executor_adapter_ts_param(1, (0, external_inversify_namespaceObject.inject)(TYPES.DependencyConfigService)),
+    node_command_executor_adapter_ts_metadata("design:type", Function),
+    node_command_executor_adapter_ts_metadata("design:paramtypes", [
+        "undefined" == typeof FileSystemPort ? Object : FileSystemPort,
+        "undefined" == typeof DependencyConfigServiceInterface ? Object : DependencyConfigServiceInterface
+    ])
+], NodeCommandExecutorAdapter);
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+function node_file_system_adapter_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+class NodeFileSystemAdapter {
+    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) {
+    }
+    access(filePath) {
+        external_node_fs_default().accessSync(filePath, external_node_fs_default().constants.W_OK);
+    }
+    readFile(filePath) {
         try {
-            const content = external_node_fs_default().readFileSync(filePath, ENCODING);
-            return JSON.parse(content);
+            return external_node_fs_default().readFileSync(filePath, "utf8");
         } catch (error) {
-            console.error(`Error reading JSON file at ${filePath}:`, error);
-            return null;
+            throw new Error(`Failed to read file ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
         }
-    },
-    writeJsonFile (filePath, content) {
+    }
+    writeFile(filePath, content) {
         try {
-            external_node_fs_default().writeFileSync(filePath, `${JSON.stringify(content, null, JSON_INDENT)}\n`, ENCODING);
-            return true;
+            const dir = external_node_path_default().dirname(filePath);
+            this.createDirectory(dir);
+            external_node_fs_default().writeFileSync(filePath, content);
         } catch (error) {
-            console.error(`Error writing JSON file at ${filePath}:`, error);
-            return false;
+            throw new Error(`Failed to write to file ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
         }
-    },
-    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;
+    createDirectory(dirPath) {
+        if (!this.exists(dirPath)) external_node_fs_default().mkdirSync(dirPath, {
+            recursive: true
+        });
+    }
+    writeConfigFile(filePath, content) {
+        this.writeFile(filePath, content);
+        console.log(`\u{1F4DD} Created ${filePath}`);
+    }
+    createConfigFiles(projectDir, configGroups) {
+        console.log(`
+\u{1F4DD} Creating configuration files...`);
+        for (const [category, configs] of Object.entries(configGroups)){
+            console.log(`
+\u{1F4C2} Setting up ${category} configurations:`);
+            for (const config of configs){
+                const fullPath = external_node_path_default().join(projectDir, config.path);
+                this.writeConfigFile(fullPath, config.content);
+                if (config.description) console.log(`\u{2139}\u{FE0F} ${config.path}: ${config.description}`);
+            }
+        }
     }
 }
-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);
+NodeFileSystemAdapter = node_file_system_adapter_ts_decorate([
+    (0, external_inversify_namespaceObject.injectable)()
+], NodeFileSystemAdapter);
+const external_node_readline_namespaceObject = require("node:readline");
+var external_node_readline_default = /*#__PURE__*/ __webpack_require__.n(external_node_readline_namespaceObject);
+function node_prompt_adapter_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-function saveExportsAnalysis(packageDir, analysis) {
-    saveJsonToFile(packageDir, EXPORTS_ANALYSIS_FILE, analysis);
+function node_prompt_adapter_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
 }
-function saveExportsPreview(packageDir, exports1) {
-    saveJsonToFile(packageDir, EXPORTS_PREVIEW_FILE, exports1);
+class NodePromptAdapter {
+    constructor(){
+        this.rl = external_node_readline_default().createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+    }
+    async prompt(message) {
+        return new Promise((resolve)=>{
+            this.rl.question(message, (answer)=>{
+                resolve(answer.trim());
+            });
+        });
+    }
+    close() {
+        this.rl.close();
+    }
 }
-function formatOutputPath(pattern, directory, name) {
-    const dirPart = "." === directory ? "" : `${directory}/`;
-    return pattern.replace("{dir}/", dirPart).replace("{dir}", directory).replace("{name}", name);
+NodePromptAdapter = node_prompt_adapter_ts_decorate([
+    (0, external_inversify_namespaceObject.injectable)(),
+    node_prompt_adapter_ts_metadata("design:type", Function),
+    node_prompt_adapter_ts_metadata("design:paramtypes", [])
+], NodePromptAdapter);
+const external_ts_morph_namespaceObject = require("ts-morph");
+function ts_morph_analysis_adapter_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-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"
-            }
+class TsMorphAnalysisAdapter {
+    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 instanceof Error ? error.message : "Unknown error"}`);
+            return {
+                imports: []
+            };
+        }
+        const imports = [];
+        const prefixesToRemove = packageConfig.exportPathPrefixesToRemove ?? [];
+        const regexPattern = new RegExp(`^.?\\/?(?:${prefixesToRemove.join("|")})\\/(.*)$`);
+        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 = parts.length <= 1 ? "." : parts.slice(0, -1).join("/");
+            if (directory.startsWith("./")) directory = directory.slice(2);
+            const name = parts.at(-1) ?? "";
+            const exportPath = this.processExportPath(moduleSpecifier, regexPattern);
+            imports.push({
+                originalPath: moduleSpecifier,
+                directory,
+                name,
+                exportPath
+            });
+        }
+        return {
+            imports
+        };
+    }
+    processExportPath(modulePath, regexPattern) {
+        const match = modulePath.match(regexPattern);
+        if (match) {
+            const remainingPath = match[1];
+            return remainingPath.startsWith("./") ? remainingPath : `./${remainingPath}`;
         }
+        return modulePath;
+    }
+}
+TsMorphAnalysisAdapter = ts_morph_analysis_adapter_ts_decorate([
+    (0, external_inversify_namespaceObject.injectable)()
+], TsMorphAnalysisAdapter);
+const external_glob_namespaceObject = require("glob");
+const external_lodash_es_namespaceObject = require("lodash-es");
+function file_system_package_repository_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function file_system_package_repository_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+function file_system_package_repository_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
     };
-    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
+}
+class FileSystemPackageRepository {
+    constructor(fileSystemPort, analysisPort, fileSystemUtility){
+        this.fileSystemPort = fileSystemPort;
+        this.analysisPort = analysisPort;
+        this.fileSystemUtility = fileSystemUtility;
+        this.DEFAULT_IGNORE_PATTERN = [
+            "**/node_modules/**"
+        ];
+        this.cachedConfig = null;
+        this.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"
             },
-            require: {
-                types: typesCjsOutput,
-                default: cjsOutput
+            customPackageConfigs: {
+                "@codefast/ui": {
+                    exportPathPrefixesToRemove: [
+                        "components"
+                    ]
+                },
+                "@codefast/style-guide": {
+                    exportPathPrefixesToRemove: [
+                        "configs"
+                    ]
+                }
             }
         };
     }
-    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}`);
+    async findAllPackages(configPath) {
+        const config = this.getConfig(configPath);
+        return await (0, external_glob_namespaceObject.glob)(config.packagesGlob, {
+            ignore: this.DEFAULT_IGNORE_PATTERN
+        });
+    }
+    processPackage(packageJsonPath, options) {
+        const packageDir = external_node_path_default().dirname(packageJsonPath);
+        let packageJson;
+        try {
+            packageJson = JSON.parse(this.fileSystemPort.readFile(packageJsonPath));
+        } catch (error) {
+            console.error(`Failed to parse ${packageJsonPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+            return false;
+        }
+        const packageName = packageJson.name;
+        if (options.packageFilter && packageName !== options.packageFilter) {
+            console.debug(`Skipping ${packageName} (does not match filter)`);
+            return false;
+        }
+        console.info(`\u{2662}\u{2012} Processing package: ${packageName}`);
+        const config = this.getConfig(options.configPath);
+        const packageConfig = this.getPackageConfig(packageName, config);
+        const srcIndexPath = external_node_path_default().join(packageDir, packageConfig.srcIndexPath);
+        if (!this.fileSystemPort.exists(srcIndexPath)) {
+            console.error(`\u{23B9}  \u{26D4}\u{FE0E} Source file not found at ${srcIndexPath}`);
+            return false;
+        }
+        console.info(`\u{23B9}  Analyzing imports from ${srcIndexPath}...`);
+        const analysis = this.analyzeImports(srcIndexPath, packageConfig);
+        if (0 === analysis.imports.length) {
+            console.warn(`\u{23B9}  \u{26D4}\u{FE0E} No imports found to analyze in ${packageName}`);
+            return false;
+        }
+        console.log(`\u{23B9}  Analysis complete. Found ${analysis.imports.length} subpath exports.`);
+        this.saveExportsAnalysis(packageDir, analysis);
+        const newExports = this.generateExports(packageName, analysis.imports, packageJson.exports ?? {}, config);
+        const currentExportsCount = packageJson.exports ? Object.keys(packageJson.exports).length : 0;
+        const newExportsCount = Object.keys(newExports).length;
+        console.info(`\u{23B9}  Exports: ${currentExportsCount} -> ${newExportsCount}`);
+        if (options.dryRun) {
+            this.saveExportsPreview(packageDir, newExports);
+            console.warn(`\u{23B9}  Saved exports preview to .exports-analysis`);
+            console.warn(`\u{23B9}  Dry run: no changes saved for ${packageName}`);
+            return true;
+        }
+        this.fileSystemUtility.backupFile(packageJsonPath, ".exports-analysis");
+        console.log(`\u{23B9}  Backed up ${packageJsonPath}`);
+        const updatedPackageJson = {
+            ...packageJson,
+            exports: newExports
+        };
+        this.fileSystemPort.writeFile(packageJsonPath, `${JSON.stringify(updatedPackageJson, null, 2)}\n`);
+        console.log(`\u{23B9}  Updated exports for ${packageName}`);
         return true;
     }
-    if (backupPackageJson(packageJsonPath)) console.log(`Backed up ${packageJsonPath}`);
-    const updatedPackageJson = {
-        ...packageJson,
-        exports: newExports
+    analyzeImports(indexFilePath, packageConfig) {
+        return this.analysisPort.analyzeImports(indexFilePath, packageConfig);
+    }
+    generateExports(packageName, imports, existingExports, config) {
+        const packageConfig = this.getPackageConfig(packageName, config);
+        const exports1 = {
+            ".": existingExports["."] ?? {
+                import: {
+                    default: "./dist/esm/index.js",
+                    types: "./dist/types/index.d.ts"
+                },
+                require: {
+                    default: "./dist/cjs/index.cjs",
+                    types: "./dist/types/index.d.cts"
+                }
+            }
+        };
+        if (existingExports["./styles.css"]) exports1["./styles.css"] = existingExports["./styles.css"];
+        for (const importPath of imports){
+            const { directory, name, exportPath } = importPath;
+            const esmOutput = this.formatOutputPath(packageConfig.esmOutputPattern, directory, name);
+            const cjsOutput = this.formatOutputPath(packageConfig.cjsOutputPattern, directory, name);
+            const typesOutput = this.formatOutputPath(packageConfig.typesOutputPattern, directory, name);
+            const typesCjsOutput = this.formatOutputPath(packageConfig.typesOutputCjsPattern, directory, name);
+            exports1[exportPath] = {
+                import: {
+                    default: esmOutput,
+                    types: typesOutput
+                },
+                require: {
+                    default: cjsOutput,
+                    types: typesCjsOutput
+                }
+            };
+        }
+        return exports1;
+    }
+    getConfig(configPath) {
+        if (this.cachedConfig && !configPath) return this.cachedConfig;
+        const userConfig = this.loadConfigFile(configPath);
+        const config = (0, external_lodash_es_namespaceObject.merge)({}, this.defaultConfig, userConfig);
+        if (!configPath) this.cachedConfig = config;
+        return config;
+    }
+    loadConfigFile(configPath) {
+        if (!configPath) return {};
+        try {
+            const fullPath = external_node_path_default().resolve(configPath);
+            if (!this.fileSystemPort.exists(fullPath)) {
+                console.warn(`Configuration file not found at ${fullPath}`);
+                return {};
+            }
+            const configContent = this.fileSystemPort.readFile(fullPath);
+            return scriptConfigSchema.parse(JSON.parse(configContent));
+        } catch (error) {
+            console.error(`Error reading configuration file: ${error instanceof Error ? error.message : "Unknown error"}`);
+            return {};
+        }
+    }
+    getPackageConfig(packageName, config) {
+        const customConfig = config.customPackageConfigs[packageName] ?? {};
+        return {
+            ...config.defaultPackageConfig,
+            ...customConfig
+        };
+    }
+    formatOutputPath(pattern, directory, name) {
+        const dirPart = "." === directory ? "" : `${directory}/`;
+        return pattern.replace("{dir}/", dirPart).replace("{dir}", directory).replace("{name}", name);
+    }
+    saveExportsAnalysis(packageDir, analysis) {
+        const outputDir = external_node_path_default().join(packageDir, ".exports-analysis");
+        this.fileSystemPort.createDirectory(outputDir);
+        this.fileSystemPort.writeFile(external_node_path_default().join(outputDir, "exports-analysis.json"), JSON.stringify(analysis, null, 2));
+    }
+    saveExportsPreview(packageDir, exports1) {
+        const outputDir = external_node_path_default().join(packageDir, ".exports-analysis");
+        this.fileSystemPort.createDirectory(outputDir);
+        this.fileSystemPort.writeFile(external_node_path_default().join(outputDir, "exports-preview.json"), JSON.stringify(exports1, null, 2));
+    }
+}
+FileSystemPackageRepository = file_system_package_repository_ts_decorate([
+    (0, external_inversify_namespaceObject.injectable)(),
+    file_system_package_repository_ts_param(0, (0, external_inversify_namespaceObject.inject)(TYPES.FileSystemPort)),
+    file_system_package_repository_ts_param(1, (0, external_inversify_namespaceObject.inject)(TYPES.AnalysisPort)),
+    file_system_package_repository_ts_param(2, (0, external_inversify_namespaceObject.inject)(TYPES.FileSystemUtility)),
+    file_system_package_repository_ts_metadata("design:type", Function),
+    file_system_package_repository_ts_metadata("design:paramtypes", [
+        "undefined" == typeof FileSystemPort ? Object : FileSystemPort,
+        "undefined" == typeof AnalysisPort ? Object : AnalysisPort,
+        "undefined" == typeof FileSystemUtility ? Object : FileSystemUtility
+    ])
+], FileSystemPackageRepository);
+const projectSchema = external_zod_namespaceObject.z.object({
+    name: external_zod_namespaceObject.z.string().min(1, "Project name cannot be empty").max(100, "Project name is too long (maximum 100 characters)").regex(/^[a-z0-9-~][a-z0-9-._~]*$/, {
+        message: "Project name must be URL-friendly (letters, numbers, hyphens, underscores, dots; no @ or scoped packages)"
+    }).refine((name)=>"." !== name && ".." !== name, {
+        message: "Project name cannot be '.' or '..'"
+    }).refine((name)=>!/^(?<reserved>CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i.test(name), {
+        message: "Project name is a reserved system name"
+    }),
+    directory: external_zod_namespaceObject.z.string().describe("Project directory path"),
+    packageJsonExists: external_zod_namespaceObject.z.boolean().describe("Whether package.json exists in the project directory")
+});
+function file_system_project_repository_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function file_system_project_repository_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+function file_system_project_repository_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
     };
-    if (savePackageJson(packageJsonPath, updatedPackageJson)) {
-        console.log(`Updated exports for ${packageName}`);
-        return true;
+}
+class FileSystemProjectRepository {
+    constructor(fileSystemPort, commandExecutorPort, promptPort, fileSystemUtility){
+        this.fileSystemPort = fileSystemPort;
+        this.commandExecutorPort = commandExecutorPort;
+        this.promptPort = promptPort;
+        this.fileSystemUtility = fileSystemUtility;
     }
-    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++;
+    async checkExistingProject(projectName) {
+        let fullPath = process.cwd();
+        let name = "";
+        const packageJsonPath = external_node_path_default().join(process.cwd(), "package.json");
+        const packageJsonExists = this.fileSystemPort.exists(packageJsonPath);
+        if (packageJsonExists) {
+            const result = packageJsonSchema.safeParse(JSON.parse(this.fileSystemPort.readFile(packageJsonPath)));
+            if (result.success) name = result.data.name;
+        } else {
+            name = await this.getValidProjectName(projectName);
+            fullPath = external_node_path_default().resolve(process.cwd(), name);
         }
-        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
+        return {
+            name,
+            directory: fullPath,
+            packageJsonExists
         };
+    }
+    createNextProject(projectName) {
+        const flags = '--ts --tailwind --eslint --app --turbo --use-pnpm --src-dir --turbopack --import-alias "@/*"';
+        this.commandExecutorPort.runCommand(`npx create-next-app@latest ${projectName} ${flags}`);
+    }
+    updateLayoutFile(projectDir) {
+        const layoutPath = external_node_path_default().join(projectDir, "src", "app", "layout.tsx");
+        const htmlTarget = '<html className={cn(fontVariables, "antialiased")} lang="en">';
+        this.fileSystemUtility.updateFileIfNeeded(layoutPath, (content)=>content.includes(htmlTarget), (content)=>{
+            const newImports = `import type { Metadata } from "next";
+import type { JSX, ReactNode } from "react";
+import { cn } from "@codefast/ui";
+import { fontVariables } from "@/lib/fonts";
+import "@/app/globals.css";`;
+            let result = content;
+            result = result.replaceAll(/import\s+{[^}]+}\s+from\s+["']next\/font\/google["'];\s*/g, "");
+            result = result.replace(/const\s+geistSans\s*=[^;]+;\s*const\s+geistMono\s*=[^;]+;\s*/, "");
+            result = result.replace(/import\s+type\s+{[^}]+}\s+from\s+["']next["'];\s*import\s+["']\.\/globals\.css["'];\s*/, newImports);
+            result = result.replace(/export default function RootLayout\({\s*children,\s*}\s*:\s*Readonly<{\s*children:\s*React\.ReactNode;\s*}>\)\s*{/, "export default function RootLayout({ children }: Readonly<{ children: ReactNode }>): JSX.Element {");
+            result = result.replace(/<html\s+lang="en"\s*>/, htmlTarget);
+            result = result.replace(/<body\s+className={`[^`]*`}\s*>/, "<body>");
+            return result;
+        });
+    }
+    updatePageFile(projectDir) {
+        const pagePath = external_node_path_default().join(projectDir, "src", "app", "page.tsx");
+        this.fileSystemUtility.updateFileIfNeeded(pagePath, (content)=>content.includes("): JSX.Element"), (content)=>{
+            let result = content;
+            if (!result.includes("import type { JSX }")) result = result.includes("import type {") ? result.replace(/import type {(?<types>[^}]+)} from "react";/, 'import type {$1, JSX } from "react";') : result.includes("import {") ? result.replace(/import {/, 'import type { JSX } from "react";\n\nimport {') : `import type { JSX } from "react";\n\n${result}`;
+            result = result.replace(/export default function Home\(\) {/, "export default function Home(): JSX.Element {");
+            return result;
+        });
+    }
+    updatePostcssConfig(projectDir) {
+        const postcssConfigPath = external_node_path_default().join(projectDir, "postcss.config.mjs");
+        const typeComment = `/** @type {import('postcss-load-config').Config} */\n`;
+        this.fileSystemUtility.updateFileIfNeeded(postcssConfigPath, (content)=>content.includes(typeComment), (content)=>content.replace("const config = {", `${typeComment}const config = {`));
+    }
+    updateNextConfig(projectDir) {
+        const nextConfigPath = external_node_path_default().join(projectDir, "next.config.ts");
+        const optimizePackagesConfig = 'optimizePackageImports: ["@codefast/ui"]';
+        this.fileSystemUtility.updateFileIfNeeded(nextConfigPath, (content)=>content.includes(optimizePackagesConfig), (content)=>content.replace(/const nextConfig: NextConfig = \{/, `const nextConfig: NextConfig = {
+  experimental: {
+    optimizePackageImports: ["@codefast/ui"],
+  },`));
+    }
+    updatePackageJson(projectDir) {
+        const packageJsonPath = external_node_path_default().join(projectDir, "package.json");
+        if (!this.fileSystemPort.exists(packageJsonPath)) return void console.warn(`\u{26A0}\u{FE0F} package.json not found, skipping update.`);
+        let packageJson;
         try {
-            await processAllPackages(processorOptions);
-        } catch (error) {
-            console.error("Error processing packages:", error);
-            process.exit(1);
+            packageJson = packageJsonSchema.parse(JSON.parse(this.fileSystemPort.readFile(packageJsonPath)));
+        } catch  {
+            console.warn(`Failed to parse ${packageJsonPath}, skipping update.`);
+            return;
+        }
+        packageJson.scripts = {
+            ...packageJson.scripts,
+            "check-types": "tsc --noEmit",
+            "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"
+        };
+        this.fileSystemPort.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        console.log(`\u{1F4DD} Updated ${packageJsonPath}`);
+    }
+    async getValidProjectName(initialName, attempts = 0, maxAttempts = 3) {
+        const projectName = initialName ?? await this.promptPort.prompt("Enter project name: ");
+        const result = projectSchema.safeParse({
+            name: projectName,
+            directory: "",
+            packageJsonExists: false
+        });
+        if (result.success) {
+            const fullPath = external_node_path_default().resolve(process.cwd(), projectName);
+            if (this.fileSystemPort.exists(fullPath)) throw new Error(`A directory named "${projectName}" already exists.`);
+            try {
+                this.fileSystemPort.access(process.cwd());
+            } catch  {
+                throw new Error("Cannot create project: No write permission in current directory.");
+            }
+            return projectName;
         }
-    });
+        if (attempts >= maxAttempts - 1) throw new Error("Exceeded maximum attempts to enter a valid project name.");
+        console.error(`\u{274C} ${result.error.message} (${maxAttempts - attempts - 1} attempts remaining)`);
+        return this.getValidProjectName(void 0, attempts + 1, maxAttempts);
+    }
+}
+FileSystemProjectRepository = file_system_project_repository_ts_decorate([
+    (0, external_inversify_namespaceObject.injectable)(),
+    file_system_project_repository_ts_param(0, (0, external_inversify_namespaceObject.inject)(TYPES.FileSystemPort)),
+    file_system_project_repository_ts_param(1, (0, external_inversify_namespaceObject.inject)(TYPES.CommandExecutorPort)),
+    file_system_project_repository_ts_param(2, (0, external_inversify_namespaceObject.inject)(TYPES.PromptPort)),
+    file_system_project_repository_ts_param(3, (0, external_inversify_namespaceObject.inject)(TYPES.FileSystemUtility)),
+    file_system_project_repository_ts_metadata("design:type", Function),
+    file_system_project_repository_ts_metadata("design:paramtypes", [
+        "undefined" == typeof FileSystemPort ? Object : FileSystemPort,
+        "undefined" == typeof CommandExecutorPort ? Object : CommandExecutorPort,
+        "undefined" == typeof PromptPort ? Object : PromptPort,
+        "undefined" == typeof FileSystemUtility ? Object : FileSystemUtility
+    ])
+], FileSystemProjectRepository);
+function dependency_config_service_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+class DependencyConfigService {
+    getMainDependencies() {
+        return this.MAIN_DEPENDENCIES;
+    }
+    getDevDependencies() {
+        return this.DEV_DEPENDENCIES;
+    }
+    getPackagesToRemove() {
+        return this.PACKAGES_TO_REMOVE;
+    }
+    constructor(){
+        this.MAIN_DEPENDENCIES = [
+            "@codefast/ui",
+            "@codefast/hooks",
+            "recharts",
+            "react-hook-form",
+            "next-themes",
+            "date-fns",
+            "lucide-react"
+        ];
+        this.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"
+            ]
+        };
+        this.PACKAGES_TO_REMOVE = [
+            "@eslint/eslintrc",
+            "eslint-config-next"
+        ];
+    }
 }
+DependencyConfigService = dependency_config_service_ts_decorate([
+    (0, external_inversify_namespaceObject.injectable)()
+], DependencyConfigService);
 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 node_package_info_service_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function node_package_info_service_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+function node_package_info_service_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+class NodePackageInfoService {
+    constructor(fileSystemPort){
+        this.fileSystemPort = fileSystemPort;
+    }
+    getPackageVersion() {
+        try {
+            const __filename1 = (0, external_node_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__);
+            const __dirname = external_node_path_default().dirname(__filename1);
+            const packageJsonPath = external_node_path_default().resolve(__dirname, "..", "package.json");
+            const packageJsonResult = packageJsonSchema.parse(JSON.parse(this.fileSystemPort.readFile(packageJsonPath)));
+            return packageJsonResult.version ?? "0.0.0";
+        } catch (error) {
+            console.warn(`Failed to read package version: ${error instanceof Error ? error.message : "Unknown error"}`);
+            return "unknown";
+        }
+    }
+}
+NodePackageInfoService = node_package_info_service_ts_decorate([
+    (0, external_inversify_namespaceObject.injectable)(),
+    node_package_info_service_ts_param(0, (0, external_inversify_namespaceObject.inject)(TYPES.FileSystemPort)),
+    node_package_info_service_ts_metadata("design:type", Function),
+    node_package_info_service_ts_metadata("design:paramtypes", [
+        "undefined" == typeof FileSystemPort ? Object : FileSystemPort
+    ])
+], NodePackageInfoService);
+function file_system_utility_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-function getPackageVersion() {
-    return getPackageInfo().version;
+function file_system_utility_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+function file_system_utility_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+class file_system_utility_FileSystemUtility {
+    constructor(fileSystemPort){
+        this.fileSystemPort = fileSystemPort;
+    }
+    updateFileIfNeeded(filePath, checkFn, updateFn) {
+        if (!this.fileSystemPort.exists(filePath)) return;
+        const currentContent = this.fileSystemPort.readFile(filePath);
+        if (checkFn(currentContent)) return void console.log(`\u{2139}\u{FE0F} ${filePath} is already up to date`);
+        try {
+            const updatedContent = updateFn(currentContent);
+            this.fileSystemPort.writeFile(filePath, updatedContent);
+            console.log(`\u{1F4DD} Updated ${filePath}`);
+        } catch (error) {
+            console.warn(`\u{26A0}\u{FE0F} Failed to update ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    backupFile(filePath, backupDir) {
+        try {
+            const content = this.fileSystemPort.readFile(filePath);
+            const baseName = external_node_path_default().basename(filePath);
+            const timestamp = new Date().toISOString().replaceAll(/[:.]/g, "-");
+            const backupPath = external_node_path_default().join(external_node_path_default().dirname(filePath), backupDir, `${baseName}.backup.${timestamp}`);
+            this.fileSystemPort.createDirectory(external_node_path_default().dirname(backupPath));
+            this.fileSystemPort.writeFile(backupPath, content);
+        } catch (error) {
+            console.error(`Error backing up ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
 }
+file_system_utility_FileSystemUtility = file_system_utility_ts_decorate([
+    (0, external_inversify_namespaceObject.injectable)(),
+    file_system_utility_ts_param(0, (0, external_inversify_namespaceObject.inject)(TYPES.FileSystemPort)),
+    file_system_utility_ts_metadata("design:type", Function),
+    file_system_utility_ts_metadata("design:paramtypes", [
+        "undefined" == typeof FileSystemPort ? Object : FileSystemPort
+    ])
+], file_system_utility_FileSystemUtility);
+const container = new external_inversify_namespaceObject.Container();
+container.bind(TYPES.ProjectRepository).to(FileSystemProjectRepository).inSingletonScope();
+container.bind(TYPES.PackageRepository).to(FileSystemPackageRepository).inSingletonScope();
+container.bind(TYPES.PackageInfoService).to(NodePackageInfoService).inSingletonScope();
+container.bind(TYPES.DependencyConfigService).to(DependencyConfigService).inSingletonScope();
+container.bind(TYPES.ConfigService).to(ConfigService).inSingletonScope();
+container.bind(TYPES.FileSystemPort).to(NodeFileSystemAdapter).inSingletonScope();
+container.bind(TYPES.CommandExecutorPort).to(NodeCommandExecutorAdapter).inSingletonScope();
+container.bind(TYPES.PromptPort).to(NodePromptAdapter).inSingletonScope();
+container.bind(TYPES.AnalysisPort).to(TsMorphAnalysisAdapter).inSingletonScope();
+container.bind(TYPES.CreateProjectUseCase).to(create_project_use_case_CreateProjectUseCase).inSingletonScope();
+container.bind(TYPES.UpdateExportsUseCase).to(update_exports_use_case_UpdateExportsUseCase).inSingletonScope();
+container.bind(TYPES.CreateProjectCommand).to(CreateProjectCommand).inSingletonScope();
+container.bind(TYPES.UpdateExportsCommand).to(UpdateExportsCommand).inSingletonScope();
+container.bind(TYPES.CLIAdapter).to(CLIAdapter).inSingletonScope();
+container.bind(TYPES.FileSystemUtility).to(file_system_utility_FileSystemUtility).inSingletonScope();
 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);
+    const cliAdapter = container.get(TYPES.CLIAdapter);
+    cliAdapter.initialize();
 }
 main();
 for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];