@codefast/cli 0.3.1-canary.9 → 0.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/CHANGELOG.md +150 -0
  2. package/dist/index.cjs +1105 -632
  3. package/dist/index.cjs.map +1 -1
  4. package/dist/index.js +1098 -626
  5. package/dist/index.js.map +1 -1
  6. package/package.json +9 -7
package/dist/index.js CHANGED
@@ -1,137 +1,124 @@
1
1
  #!/usr/bin/env node
2
+ import * as __WEBPACK_EXTERNAL_MODULE_inversify__ from "inversify";
2
3
  import * as __WEBPACK_EXTERNAL_MODULE_commander__ from "commander";
3
- import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
4
- import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
4
+ import * as __WEBPACK_EXTERNAL_MODULE_node_process_786449bf__ from "node:process";
5
5
  import * as __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__ from "node:child_process";
6
+ import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
7
+ import * as __WEBPACK_EXTERNAL_MODULE_zod__ from "zod";
8
+ import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
6
9
  import * as __WEBPACK_EXTERNAL_MODULE_node_readline_91c31510__ from "node:readline";
7
- import * as __WEBPACK_EXTERNAL_MODULE_glob__ from "glob";
8
10
  import * as __WEBPACK_EXTERNAL_MODULE_ts_morph_07c7ce60__ from "ts-morph";
11
+ import * as __WEBPACK_EXTERNAL_MODULE_glob__ from "glob";
9
12
  import * as __WEBPACK_EXTERNAL_MODULE_lodash_es_18c59938__ from "lodash-es";
10
- import * as __WEBPACK_EXTERNAL_MODULE_zod__ from "zod";
11
13
  import * as __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__ from "node:url";
12
- const rl = __WEBPACK_EXTERNAL_MODULE_node_readline_91c31510__["default"].createInterface({
13
- input: process.stdin,
14
- output: process.stdout
15
- });
16
- function utils_prompt(question) {
17
- return new Promise((resolve)=>{
18
- rl.question(question, (answer)=>{
19
- resolve(answer.trim());
20
- });
21
- });
22
- }
23
- function runCommand(command) {
24
- (0, __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__.execSync)(command, {
25
- stdio: "inherit"
26
- });
14
+ const TYPES = {
15
+ ProjectRepository: Symbol.for("ProjectRepository"),
16
+ PackageRepository: Symbol.for("PackageRepository"),
17
+ FileSystemPort: Symbol.for("FileSystemPort"),
18
+ CommandExecutorPort: Symbol.for("CommandExecutorPort"),
19
+ PromptPort: Symbol.for("PromptPort"),
20
+ AnalysisPort: Symbol.for("AnalysisPort"),
21
+ PackageInfoService: Symbol.for("PackageInfoService"),
22
+ DependencyConfigService: Symbol.for("DependencyConfigService"),
23
+ ConfigService: Symbol.for("ConfigService"),
24
+ FileSystemUtility: Symbol.for("FileSystemUtility"),
25
+ CreateProjectUseCase: Symbol.for("CreateProjectUseCase"),
26
+ UpdateExportsUseCase: Symbol.for("UpdateExportsUseCase"),
27
+ CreateProjectCommand: Symbol.for("CreateProjectCommand"),
28
+ UpdateExportsCommand: Symbol.for("UpdateExportsCommand"),
29
+ CLIAdapter: Symbol.for("CLIAdapter")
30
+ };
31
+ function _ts_decorate(decorators, target, key, desc) {
32
+ var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
33
+ if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
34
+ 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;
35
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
27
36
  }
28
- function writeConfigFile(filePath, content) {
29
- __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].writeFileSync(filePath, content);
30
- console.log(`📝 Created ${filePath}`);
37
+ function _ts_metadata(k, v) {
38
+ if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
31
39
  }
32
- function validateProjectName(name) {
33
- if (!name || /^\s*$/.test(name)) return {
34
- valid: false,
35
- error: "Project name cannot be empty or contain only whitespace."
36
- };
37
- if (name.length > 100) return {
38
- valid: false,
39
- error: "Project name is too long (maximum 100 characters)."
40
- };
41
- const npmNameRegex = /^[a-z0-9-~][a-z0-9-._~]*$/;
42
- if (!npmNameRegex.test(name)) return {
43
- valid: false,
44
- error: "Project name must be URL-friendly (letters, numbers, hyphens, underscores, dots; no @ or scoped packages)."
45
- };
46
- if ("." === name || ".." === name) return {
47
- valid: false,
48
- error: "Project name cannot be '.' or '..'."
49
- };
50
- const reservedNames = /^(?<reserved>CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i;
51
- if (reservedNames.test(name)) return {
52
- valid: false,
53
- error: `Project name "${name}" is a reserved system name.`
40
+ function _ts_param(paramIndex, decorator) {
41
+ return function(target, key) {
42
+ decorator(target, key, paramIndex);
54
43
  };
55
- const fullPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(process.cwd(), name);
56
- if (__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(fullPath)) return {
57
- valid: false,
58
- error: `A directory named "${name}" already exists.`
59
- };
60
- try {
61
- __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].accessSync(process.cwd(), __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].constants.W_OK);
62
- } catch {
63
- return {
64
- valid: false,
65
- error: "Cannot create project: No write permission in current directory."
66
- };
44
+ }
45
+ class CreateProjectCommand {
46
+ constructor(createProjectUseCase){
47
+ this.createProjectUseCase = createProjectUseCase;
67
48
  }
68
- return {
69
- valid: true
49
+ getCommand() {
50
+ return new __WEBPACK_EXTERNAL_MODULE_commander__.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)=>{
51
+ await this.createProjectUseCase.execute(projectName);
52
+ __WEBPACK_EXTERNAL_MODULE_node_process_786449bf__["default"].exit(0);
53
+ });
54
+ }
55
+ }
56
+ CreateProjectCommand = _ts_decorate([
57
+ (0, __WEBPACK_EXTERNAL_MODULE_inversify__.injectable)(),
58
+ _ts_param(0, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.CreateProjectUseCase)),
59
+ _ts_metadata("design:type", Function),
60
+ _ts_metadata("design:paramtypes", [
61
+ "undefined" == typeof CreateProjectUseCase ? Object : CreateProjectUseCase
62
+ ])
63
+ ], CreateProjectCommand);
64
+ function update_exports_command_ts_decorate(decorators, target, key, desc) {
65
+ var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
66
+ if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
67
+ 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;
68
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
69
+ }
70
+ function update_exports_command_ts_metadata(k, v) {
71
+ if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
72
+ }
73
+ function update_exports_command_ts_param(paramIndex, decorator) {
74
+ return function(target, key) {
75
+ decorator(target, key, paramIndex);
70
76
  };
71
77
  }
72
- async function getValidProjectName(initialName, attempts = 0, maxAttempts = 3) {
73
- const projectName = initialName ?? await utils_prompt("Enter project name: ");
74
- const validation = validateProjectName(projectName);
75
- if (validation.valid) return projectName;
76
- if (attempts >= maxAttempts - 1) throw new Error(`❌ Exceeded maximum attempts to enter a valid project name.`);
77
- console.error(`❌ ${validation.error} (${maxAttempts - attempts - 1} attempts remaining)`);
78
- return getValidProjectName(void 0, attempts + 1, maxAttempts);
79
- }
80
- async function checkExistingProject(projectNameArg) {
81
- const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(process.cwd(), "package.json");
82
- const packageJsonExists = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(packageJsonPath);
83
- if (packageJsonExists) {
84
- console.log(`⚠️ A package.json file has been detected in the current directory.`);
85
- const confirm = await utils_prompt("Do you want to continue configuring this existing project? [Y/n]: ");
86
- if ("" === confirm || "y" === confirm.toLowerCase()) {
87
- const packageJson = JSON.parse(__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(packageJsonPath, "utf8"));
88
- const projectName = packageJson.name ?? await getValidProjectName(projectNameArg);
89
- return {
90
- projectName,
91
- packageJsonExists
92
- };
93
- }
94
- console.log("Aborting...");
95
- throw new Error("User aborted the operation.");
78
+ class UpdateExportsCommand {
79
+ constructor(updateExportsUseCase){
80
+ this.updateExportsUseCase = updateExportsUseCase;
81
+ }
82
+ getCommand() {
83
+ return new __WEBPACK_EXTERNAL_MODULE_commander__.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)=>{
84
+ await this.updateExportsUseCase.execute({
85
+ packageFilter: options.package,
86
+ dryRun: Boolean(options.dryRun),
87
+ configPath: options.config
88
+ });
89
+ __WEBPACK_EXTERNAL_MODULE_node_process_786449bf__.exit(0);
90
+ });
96
91
  }
97
- const projectName = await getValidProjectName(projectNameArg);
98
- return {
99
- projectName,
100
- packageJsonExists
101
- };
102
92
  }
103
- const MAIN_DEPENDENCIES = [
104
- "@codefast/ui",
105
- "@codefast/hooks"
106
- ];
107
- const DEV_DEPENDENCIES = {
108
- commitLint: [
109
- "@commitlint/cli",
110
- "@commitlint/config-conventional",
111
- "@commitlint/types"
112
- ],
113
- gitTools: [
114
- "simple-git-hooks"
115
- ],
116
- formatting: [
117
- "prettier",
118
- "prettier-plugin-packagejson",
119
- "prettier-plugin-tailwindcss",
120
- "lint-staged"
121
- ],
122
- linting: [
123
- "@codefast/eslint-config"
124
- ]
125
- };
126
- const PACKAGES_TO_REMOVE = [
127
- "@eslint/eslintrc",
128
- "eslint-config-next"
129
- ];
130
- const configGroups = {
131
- deployment: [
132
- {
133
- path: ".vercelignore",
134
- content: `#-------------------------------------------------------------------------------
93
+ UpdateExportsCommand = update_exports_command_ts_decorate([
94
+ (0, __WEBPACK_EXTERNAL_MODULE_inversify__.injectable)(),
95
+ update_exports_command_ts_param(0, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.UpdateExportsUseCase)),
96
+ update_exports_command_ts_metadata("design:type", Function),
97
+ update_exports_command_ts_metadata("design:paramtypes", [
98
+ "undefined" == typeof UpdateExportsUseCase ? Object : UpdateExportsUseCase
99
+ ])
100
+ ], UpdateExportsCommand);
101
+ function handleError(error, defaultMessage) {
102
+ const message = error instanceof Error ? error.message : defaultMessage;
103
+ console.error(`
104
+ \u{274C} ${message}`);
105
+ }
106
+ function config_service_ts_decorate(decorators, target, key, desc) {
107
+ var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
108
+ if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
109
+ 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;
110
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
111
+ }
112
+ class ConfigService {
113
+ getConfigGroups() {
114
+ return this.configGroups;
115
+ }
116
+ constructor(){
117
+ this.configGroups = {
118
+ deployment: [
119
+ {
120
+ path: ".vercelignore",
121
+ content: `#-------------------------------------------------------------------------------
135
122
  # Dependencies and package managers
136
123
  #-------------------------------------------------------------------------------
137
124
 
@@ -197,13 +184,13 @@ Thumbs.db
197
184
  # Vercel deployment configuration
198
185
  .vercel
199
186
  `,
200
- description: "Ignore files that should not be deployed to Vercel"
201
- }
202
- ],
203
- formatting: [
204
- {
205
- path: "prettier.config.mjs",
206
- content: `/**
187
+ description: "Ignore files that should not be deployed to Vercel"
188
+ }
189
+ ],
190
+ formatting: [
191
+ {
192
+ path: "prettier.config.mjs",
193
+ content: `/**
207
194
  * @see https://prettier.io/docs/en/configuration.html
208
195
  * @type {import('prettier').Config}
209
196
  */
@@ -216,11 +203,11 @@ const config = {
216
203
 
217
204
  export default config;
218
205
  `,
219
- description: "Prettier configuration for source code formatting"
220
- },
221
- {
222
- path: ".editorconfig",
223
- content: `# https://editorconfig.org
206
+ description: "Prettier configuration for source code formatting"
207
+ },
208
+ {
209
+ path: ".editorconfig",
210
+ content: `# https://editorconfig.org
224
211
  root = true
225
212
 
226
213
  [*]
@@ -244,13 +231,31 @@ indent_style = tab
244
231
  # Keep in sync with rustfmt
245
232
  indent_size = 4
246
233
  `,
247
- description: "Editor configuration for source code formatting"
248
- }
249
- ],
250
- linting: [
251
- {
252
- path: "commitlint.config.mjs",
253
- content: `/**
234
+ description: "Editor configuration for source code formatting"
235
+ },
236
+ {
237
+ path: ".prettierignore",
238
+ content: `# changesets
239
+ .changeset
240
+
241
+ # debug
242
+ npm-debug.log*
243
+ yarn-debug.log*
244
+ yarn-error.log*
245
+ .pnpm-debug.log*
246
+
247
+ # lock files
248
+ package-lock.json
249
+ yarn.lock
250
+ pnpm-lock.yaml
251
+ `,
252
+ description: ""
253
+ }
254
+ ],
255
+ linting: [
256
+ {
257
+ path: "commitlint.config.mjs",
258
+ content: `/**
254
259
  * @see https://commitlint.js.org/reference/configuration.html
255
260
  * @type {import('@commitlint/types').UserConfig}
256
261
  */
@@ -258,16 +263,18 @@ const config = {
258
263
  extends: ["@commitlint/config-conventional"],
259
264
  rules: {
260
265
  "body-max-line-length": [2, "always", 350],
266
+ "header-max-length": [2, "always", 150],
261
267
  },
262
268
  };
263
269
 
264
270
  export default config;
265
271
  `,
266
- description: "Commitlint configuration"
267
- },
268
- {
269
- path: "eslint.config.mjs",
270
- content: `import { config } from "@codefast/eslint-config/next";
272
+ description: "Commitlint configuration"
273
+ },
274
+ {
275
+ path: "eslint.config.mjs",
276
+ content: `import { config } from "@codefast/eslint-config/next";
277
+
271
278
  /**
272
279
  * @see https://eslint.org/docs/latest/use/configure/configuration-files
273
280
  * @type {import('eslint').Linter.Config[]}
@@ -276,11 +283,11 @@ const eslintConfig = [...config];
276
283
 
277
284
  export default eslintConfig;
278
285
  `,
279
- description: "ESLint configuration for the project"
280
- },
281
- {
282
- path: "lint-staged.config.mjs",
283
- content: `import { relative } from "node:path";
286
+ description: "ESLint configuration for the project"
287
+ },
288
+ {
289
+ path: "lint-staged.config.mjs",
290
+ content: `import { relative } from "node:path";
284
291
 
285
292
  /**
286
293
  * Builds an ESLint command with the given filenames.
@@ -305,13 +312,13 @@ const config = {
305
312
 
306
313
  export default config;
307
314
  `,
308
- description: "Configure lint-staged for pre-commit checks"
309
- }
310
- ],
311
- styles: [
312
- {
313
- path: "src/lib/fonts.ts",
314
- content: `import { cn } from "@codefast/ui";
315
+ description: "Configure lint-staged for pre-commit checks"
316
+ }
317
+ ],
318
+ styles: [
319
+ {
320
+ path: "src/lib/fonts.ts",
321
+ content: `import { cn } from "@codefast/ui";
315
322
  import { Geist, Geist_Mono as GeistMono } from "next/font/google";
316
323
 
317
324
  const fontGeistSans = Geist({
@@ -326,11 +333,11 @@ const fontGeistMono = GeistMono({
326
333
 
327
334
  export const fontVariables = cn(fontGeistSans.variable, fontGeistMono.variable);
328
335
  `,
329
- description: "Font configuration for the application"
330
- },
331
- {
332
- path: "src/app/globals.css",
333
- content: `@import "tailwindcss";
336
+ description: "Font configuration for the application"
337
+ },
338
+ {
339
+ path: "src/app/globals.css",
340
+ content: `@import "tailwindcss";
334
341
 
335
342
  @import "@codefast/ui/styles.css";
336
343
 
@@ -342,6 +349,7 @@ export const fontVariables = cn(fontGeistSans.variable, fontGeistMono.variable);
342
349
  :root {
343
350
  --font-sans: var(--font-geist-sans);
344
351
  --font-mono: var(--font-geist-mono);
352
+
345
353
  --input: var(--color-neutral-200);
346
354
  --border: var(--color-neutral-200);
347
355
  --ring: var(--color-neutral-400);
@@ -375,7 +383,8 @@ export const fontVariables = cn(fontGeistSans.variable, fontGeistMono.variable);
375
383
  --chart-4: var(--color-amber-600);
376
384
  --chart-5: var(--color-amber-500);
377
385
  }
378
- @variant dark {
386
+
387
+ .dark {
379
388
  --input: var(--color-neutral-700);
380
389
  --border: --alpha(var(--color-neutral-700) / 50%);
381
390
  --ring: var(--color-neutral-500);
@@ -411,523 +420,986 @@ export const fontVariables = cn(fontGeistSans.variable, fontGeistMono.variable);
411
420
  }
412
421
  }
413
422
  `,
414
- description: "Global CSS variables for the application"
415
- }
416
- ]
417
- };
418
- function updatePostcssConfig(projectDir) {
419
- const postcssConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectDir, "postcss.config.mjs");
420
- if (!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(postcssConfigPath)) return void console.warn(`⚠️ postcss.config.mjs not found, skipping update.`);
421
- let content = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(postcssConfigPath, "utf8");
422
- const typeComment = `/** @type {import('postcss-load-config').Config} */\n`;
423
- if (content.includes(typeComment)) console.log(`📝 postcss.config.mjs already contains type comment, no changes made.`);
424
- else {
425
- content = content.replace("const config = {", `${typeComment}const config = {`);
426
- __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].writeFileSync(postcssConfigPath, content);
427
- console.log(`📝 Updated postcss.config.mjs with type comment.`);
428
- }
429
- }
430
- function updateLayoutFile(projectDir) {
431
- const layoutPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectDir, "src/app/layout.tsx");
432
- if (!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(layoutPath)) return void console.warn(`⚠️ src/app/layout.tsx not found, skipping update.`);
433
- let content = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(layoutPath, "utf8");
434
- 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.`);
435
- const newImports = `import type { Metadata } from "next";
436
-
437
- import { cn } from "@codefast/ui";
438
-
439
- import { fontVariables } from "@/lib/fonts";
440
- import "@/app/globals.css";`;
441
- content = content.replaceAll(/import\s+{[^}]+}\s+from\s+["']next\/font\/google["'];\s*/g, "");
442
- content = content.replace(/const\s+geistSans\s*=[^;]+;\s*const\s+geistMono\s*=[^;]+;\s*/, "");
443
- content = content.replace(/import\s+type\s+{[^}]+}\s+from\s+["']next["'];\s*import\s+["']\.\/globals\.css["'];\s*/, newImports);
444
- const htmlRegex = /<html\s+lang="en"\s*>/;
445
- const newHtml = '<html className={cn(fontVariables, "antialiased")} lang="en">';
446
- content = content.replace(htmlRegex, newHtml);
447
- const bodyRegex = /<body\s+className={`[^`]*`}\s*>/;
448
- const newBody = "<body>";
449
- content = content.replace(bodyRegex, newBody);
450
- try {
451
- __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].writeFileSync(layoutPath, content);
452
- console.log(`📝 Updated src/app/layout.tsx to use fontVariables in html tag and removed className from body`);
453
- } catch (error) {
454
- const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
455
- console.warn(`⚠️ Failed to update src/app/layout.tsx: ${errorMessage}`);
456
- }
457
- }
458
- function updatePackageJson(projectDir) {
459
- const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectDir, "package.json");
460
- const packageJson = JSON.parse(__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(packageJsonPath, "utf8"));
461
- packageJson.scripts = {
462
- ...packageJson.scripts,
463
- "deploy:preview": "vercel deploy --archive=tgz",
464
- "deploy:prod": "vercel deploy --archive=tgz --prod",
465
- format: 'prettier --write "**/*.{js,mjs,jsx,ts,tsx,json,css,md,mdx}"',
466
- "format:check": 'prettier --check "**/*.{js,mjs,jsx,ts,tsx,json,css,md,mdx}"',
467
- lint: "next lint --fix --max-warnings 0",
468
- "lint:check": "next lint --max-warnings 0",
469
- "package:install": "pnpm install",
470
- "package:outdated": "pnpm outdated",
471
- "package:upgrade": "pnpm update --latest",
472
- preview: "pnpm build && pnpm start"
473
- };
474
- packageJson["simple-git-hooks"] = {
475
- "pre-commit": "pnpm lint-staged",
476
- "commit-msg": "pnpm commitlint --edit"
477
- };
478
- __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
479
- console.log(`📝 Updated package.json`);
480
- }
481
- function createConfigFiles(projectDir) {
482
- console.log(`\n📝 Creating configuration files...`);
483
- for (const [category, configs] of Object.entries(configGroups)){
484
- console.log(`\n📂 Setting up ${category} configurations:`);
485
- for (const { path: filePath, content, description } of configs){
486
- const fullPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectDir, filePath);
487
- const dir = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(fullPath);
488
- if (!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(dir)) __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].mkdirSync(dir, {
489
- recursive: true
490
- });
491
- writeConfigFile(fullPath, content);
492
- if (description) console.log(` ℹ️ ${filePath}: ${description}`);
493
- }
423
+ description: "Global CSS variables for the application"
424
+ }
425
+ ]
426
+ };
494
427
  }
495
428
  }
496
- function installDependencies() {
497
- console.log(`\n📚 Installing dependencies...`);
498
- if (MAIN_DEPENDENCIES.length > 0) runCommand(`pnpm add ${MAIN_DEPENDENCIES.join(" ")}`);
499
- const allDevDependencies = Object.values(DEV_DEPENDENCIES).flat().join(" ");
500
- if (allDevDependencies) runCommand(`pnpm add -D ${allDevDependencies}`);
501
- }
502
- function cleanupPackages() {
503
- console.log(`\n🧹 Cleaning up unnecessary packages...`);
504
- const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.join(process.cwd(), "package.json");
505
- if (!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync(packageJsonPath)) return void console.warn(`⚠️ package.json not found, skipping cleanup.`);
506
- let packageJson;
507
- try {
508
- packageJson = JSON.parse(__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.readFileSync(packageJsonPath, "utf8"));
509
- } catch (error) {
510
- const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
511
- console.warn(`⚠️ Error reading package.json: ${errorMessage}, skipping cleanup.`);
512
- return;
513
- }
514
- const dependencies = packageJson.dependencies ?? {};
515
- const devDependencies = packageJson.devDependencies ?? {};
516
- const packagesToRemove = PACKAGES_TO_REMOVE.filter((pkg)=>pkg in dependencies || pkg in devDependencies);
517
- if (packagesToRemove.length > 0) runCommand(`pnpm remove ${packagesToRemove.join(" ")}`);
518
- else console.log(`ℹ️ No unnecessary packages found in package.json to remove.`);
519
- }
520
- function checkEnvironment() {
521
- try {
522
- (0, __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__.execSync)("pnpm --version", {
523
- stdio: "ignore"
524
- });
525
- } catch {
526
- console.error(`❌ PNPM chưa được cài đặt. Vui lòng cài đặt PNPM trước.`);
527
- process.exit(1);
528
- }
429
+ ConfigService = config_service_ts_decorate([
430
+ (0, __WEBPACK_EXTERNAL_MODULE_inversify__.injectable)()
431
+ ], ConfigService);
432
+ function create_project_use_case_ts_decorate(decorators, target, key, desc) {
433
+ var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
434
+ if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
435
+ 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;
436
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
529
437
  }
530
- function createNextProject(projectName) {
531
- console.log(`📦 Creating Next.js project...`);
532
- const flags = '--ts --tailwind --eslint --app --turbo --use-pnpm --src-dir --turbopack --import-alias "@/*"';
533
- runCommand(`npx create-next-app@latest ${projectName} ${flags}`);
438
+ function create_project_use_case_ts_metadata(k, v) {
439
+ if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
440
+ }
441
+ function create_project_use_case_ts_param(paramIndex, decorator) {
442
+ return function(target, key) {
443
+ decorator(target, key, paramIndex);
444
+ };
534
445
  }
535
- function createProjectCommand(program) {
536
- program.command("create-project [name]").description("Create a new Next.js project with recommended setup").action(async (projectNameArg)=>{
446
+ class create_project_use_case_CreateProjectUseCase {
447
+ constructor(projectRepository, fileSystemPort, commandExecutorPort, promptPort, configService){
448
+ this.projectRepository = projectRepository;
449
+ this.fileSystemPort = fileSystemPort;
450
+ this.commandExecutorPort = commandExecutorPort;
451
+ this.promptPort = promptPort;
452
+ this.configService = configService;
453
+ }
454
+ async execute(projectName) {
537
455
  try {
538
- checkEnvironment();
539
- const { projectName, packageJsonExists } = await checkExistingProject(projectNameArg);
540
- if (!packageJsonExists) {
541
- console.log(`\n🚀 Starting project creation for ${projectName}...\n`);
542
- createNextProject(projectName);
543
- process.chdir(projectName);
544
- console.log(`📂 Moved to ${projectName}`);
545
- }
546
- updateLayoutFile(process.cwd());
547
- updatePostcssConfig(process.cwd());
548
- installDependencies();
549
- cleanupPackages();
550
- createConfigFiles(process.cwd());
551
- updatePackageJson(process.cwd());
552
- console.log(`\n🔄 Activating git hooks...`);
553
- runCommand("pnpm simple-git-hooks");
554
- console.log(`\n📝 Formatting files with Prettier...`);
555
- runCommand("pnpm format");
556
- console.log(`\n✅ Project ${packageJsonExists ? "configured" : "created"} successfully!`);
557
- console.log(`- Project: ${projectName}`);
558
- console.log("- Next.js with TypeScript");
559
- console.log("- TailwindCSS and @codefast/ui");
560
- console.log("- ESLint, Prettier, Commitlint, and Git Hooks");
561
- console.log("- Lint-staged for pre-commit checks");
562
- console.log(`\n📁 Project directory: ${process.cwd()}`);
563
- console.log(`\n🚀 To start development:`);
564
- console.log(`cd ${projectName} && pnpm dev`);
456
+ this.commandExecutorPort.checkEnvironment();
457
+ const project = await this.checkExistingProject(projectName);
458
+ const configGroups = this.configService.getConfigGroups();
459
+ this.createOrConfigureProject(project, configGroups);
460
+ this.displaySuccessMessage(project);
461
+ return project;
565
462
  } catch (error) {
566
- const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
567
- console.error(`\n❌ An error occurred: ${errorMessage}`);
568
- process.exit(1);
463
+ handleError(error, "Failed to create or configure project");
464
+ throw error;
569
465
  } finally{
570
- rl.close();
466
+ this.promptPort.close();
571
467
  }
572
- });
573
- }
574
- function makeRegexPrefixesToRemove(prefixes) {
575
- const prefixPattern = prefixes.join("|");
576
- return new RegExp(`^.?\\/?(?:${prefixPattern})\\/(.*)$`);
577
- }
578
- function processExportPath(modulePath, regexPattern) {
579
- let processedPath = modulePath;
580
- const match = processedPath.match(regexPattern);
581
- if (match) {
582
- const remainingPath = match[1];
583
- processedPath = remainingPath.startsWith("./") ? remainingPath : `./${remainingPath}`;
584
- }
585
- return processedPath;
586
- }
587
- function analyzeImports(indexFilePath, packageConfig) {
588
- const project = new __WEBPACK_EXTERNAL_MODULE_ts_morph_07c7ce60__.Project();
589
- let sourceFile;
590
- try {
591
- sourceFile = project.addSourceFileAtPath(indexFilePath);
592
- } catch (error) {
593
- console.error(`Error loading source file at ${indexFilePath}:`, error);
594
- return {
595
- imports: []
596
- };
597
468
  }
598
- const imports = [];
599
- const prefixesToRemove = packageConfig.exportPathPrefixesToRemove ?? [];
600
- const regexPattern = makeRegexPrefixesToRemove(prefixesToRemove);
601
- for (const exportDecl of sourceFile.getExportDeclarations()){
602
- let moduleSpecifier = exportDecl.getModuleSpecifierValue();
603
- if (!moduleSpecifier) continue;
604
- if (moduleSpecifier.startsWith("@/")) moduleSpecifier = `./${moduleSpecifier.slice(2)}`;
605
- const isExternal = !moduleSpecifier.startsWith(".");
606
- if (isExternal) continue;
607
- const parts = moduleSpecifier.split("/").filter(Boolean);
608
- if (parts.length < 2) continue;
609
- let directory;
610
- if (parts.length <= 1) directory = ".";
611
- else {
612
- directory = parts.slice(0, -1).join("/");
613
- if (directory.startsWith("./")) directory = directory.slice(2);
469
+ async checkExistingProject(projectNameArg) {
470
+ return await this.projectRepository.checkExistingProject(projectNameArg);
471
+ }
472
+ createOrConfigureProject(project, configGroups) {
473
+ if (!project.packageJsonExists) {
474
+ console.log(`
475
+ \u{1F680} Starting project creation for ${project.name}...\n`);
476
+ this.projectRepository.createNextProject(project.name);
477
+ process.chdir(project.name);
478
+ console.log(`\u{1F4C2} Moved to ${project.name}`);
614
479
  }
615
- const name = parts.at(-1) ?? "";
616
- const importPath = {
617
- originalPath: moduleSpecifier,
618
- directory,
619
- name,
620
- exportPath: processExportPath(moduleSpecifier, regexPattern)
621
- };
622
- imports.push(importPath);
480
+ this.updateProjectFiles(project.directory);
481
+ this.commandExecutorPort.installDependencies();
482
+ this.commandExecutorPort.cleanupPackages();
483
+ this.fileSystemPort.createConfigFiles(project.directory, configGroups);
484
+ this.projectRepository.updateNextConfig(project.directory);
485
+ this.projectRepository.updatePackageJson(project.directory);
486
+ this.commandExecutorPort.enableGitHooks();
487
+ this.commandExecutorPort.runFormatter();
488
+ this.commandExecutorPort.runLinter();
623
489
  }
624
- return {
625
- imports
490
+ updateProjectFiles(projectDir) {
491
+ this.projectRepository.updateLayoutFile(projectDir);
492
+ this.projectRepository.updatePageFile(projectDir);
493
+ this.projectRepository.updatePostcssConfig(projectDir);
494
+ }
495
+ displaySuccessMessage(project) {
496
+ console.log(`
497
+ \u{2705} Project ${project.packageJsonExists ? "configured" : "created"} successfully!`);
498
+ console.log(`- Project: ${project.name}`);
499
+ console.log("- Next.js with TypeScript");
500
+ console.log("- TailwindCSS and @codefast/ui");
501
+ console.log("- ESLint, Prettier, Commitlint, and Git Hooks");
502
+ console.log("- Lint-staged for pre-commit checks");
503
+ console.log(`
504
+ \u{1F4C1} Project directory: ${process.cwd()}`);
505
+ console.log(`
506
+ \u{1F680} To start development:`);
507
+ console.log(`${project.packageJsonExists ? `cd ${project.name} && ` : ""}pnpm dev`);
508
+ }
509
+ }
510
+ create_project_use_case_CreateProjectUseCase = create_project_use_case_ts_decorate([
511
+ (0, __WEBPACK_EXTERNAL_MODULE_inversify__.injectable)(),
512
+ create_project_use_case_ts_param(0, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.ProjectRepository)),
513
+ create_project_use_case_ts_param(1, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.FileSystemPort)),
514
+ create_project_use_case_ts_param(2, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.CommandExecutorPort)),
515
+ create_project_use_case_ts_param(3, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.PromptPort)),
516
+ create_project_use_case_ts_param(4, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.ConfigService)),
517
+ create_project_use_case_ts_metadata("design:type", Function),
518
+ create_project_use_case_ts_metadata("design:paramtypes", [
519
+ "undefined" == typeof ProjectRepositoryInterface ? Object : ProjectRepositoryInterface,
520
+ "undefined" == typeof FileSystemPort ? Object : FileSystemPort,
521
+ "undefined" == typeof CommandExecutorPort ? Object : CommandExecutorPort,
522
+ "undefined" == typeof PromptPort ? Object : PromptPort,
523
+ void 0 === ConfigService ? Object : ConfigService
524
+ ])
525
+ ], create_project_use_case_CreateProjectUseCase);
526
+ function update_exports_use_case_ts_decorate(decorators, target, key, desc) {
527
+ var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
528
+ if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
529
+ 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;
530
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
531
+ }
532
+ function update_exports_use_case_ts_metadata(k, v) {
533
+ if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
534
+ }
535
+ function update_exports_use_case_ts_param(paramIndex, decorator) {
536
+ return function(target, key) {
537
+ decorator(target, key, paramIndex);
626
538
  };
627
539
  }
628
- const PackageConfigSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z["interface"]({
629
- cjsOutputPattern: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
630
- esmOutputPattern: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
631
- packageJsonPath: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
632
- srcIndexPath: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
633
- typesOutputCjsPattern: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
634
- typesOutputPattern: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
635
- "exportPathPrefixesToRemove?": __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string())
540
+ class update_exports_use_case_UpdateExportsUseCase {
541
+ constructor(packageRepository){
542
+ this.packageRepository = packageRepository;
543
+ }
544
+ async execute(options) {
545
+ try {
546
+ console.info("\u2662\u2012 Searching for packages...");
547
+ const packageJsonPaths = await this.packageRepository.findAllPackages(options.configPath);
548
+ if (0 === packageJsonPaths.length) return void console.warn("No packages found.");
549
+ console.log(` Found ${packageJsonPaths.length} packages.`);
550
+ let successCount = 0;
551
+ let skipCount = 0;
552
+ let errorCount = 0;
553
+ for (const packageJsonPath of packageJsonPaths){
554
+ const result = this.packageRepository.processPackage(packageJsonPath, options);
555
+ if (result) successCount++;
556
+ else if (options.packageFilter) skipCount++;
557
+ else errorCount++;
558
+ }
559
+ console.log("\u2662\u2012 Completed exports update.\n");
560
+ console.info(`Stats: ${successCount} succeeded, ${skipCount} skipped, ${errorCount} failed`);
561
+ } catch (error) {
562
+ handleError(error, "Error processing packages");
563
+ throw error;
564
+ }
565
+ }
566
+ }
567
+ update_exports_use_case_UpdateExportsUseCase = update_exports_use_case_ts_decorate([
568
+ (0, __WEBPACK_EXTERNAL_MODULE_inversify__.injectable)(),
569
+ update_exports_use_case_ts_param(0, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.PackageRepository)),
570
+ update_exports_use_case_ts_metadata("design:type", Function),
571
+ update_exports_use_case_ts_metadata("design:paramtypes", [
572
+ "undefined" == typeof PackageRepository ? Object : PackageRepository
573
+ ])
574
+ ], update_exports_use_case_UpdateExportsUseCase);
575
+ function cli_adapter_ts_decorate(decorators, target, key, desc) {
576
+ var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
577
+ if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
578
+ 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;
579
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
580
+ }
581
+ function cli_adapter_ts_metadata(k, v) {
582
+ if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
583
+ }
584
+ function cli_adapter_ts_param(paramIndex, decorator) {
585
+ return function(target, key) {
586
+ decorator(target, key, paramIndex);
587
+ };
588
+ }
589
+ class CLIAdapter {
590
+ constructor(createProjectCommand, updateExportsCommand, packageInfoService){
591
+ this.createProjectCommand = createProjectCommand;
592
+ this.updateExportsCommand = updateExportsCommand;
593
+ this.packageInfoService = packageInfoService;
594
+ }
595
+ initialize() {
596
+ const program = new __WEBPACK_EXTERNAL_MODULE_commander__.Command();
597
+ 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);
598
+ }
599
+ }
600
+ CLIAdapter = cli_adapter_ts_decorate([
601
+ (0, __WEBPACK_EXTERNAL_MODULE_inversify__.injectable)(),
602
+ cli_adapter_ts_param(0, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.CreateProjectCommand)),
603
+ cli_adapter_ts_param(1, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.UpdateExportsCommand)),
604
+ cli_adapter_ts_param(2, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.PackageInfoService)),
605
+ cli_adapter_ts_metadata("design:type", Function),
606
+ cli_adapter_ts_metadata("design:paramtypes", [
607
+ void 0 === CreateProjectCommand ? Object : CreateProjectCommand,
608
+ void 0 === UpdateExportsCommand ? Object : UpdateExportsCommand,
609
+ "undefined" == typeof PackageInfoServiceInterface ? Object : PackageInfoServiceInterface
610
+ ])
611
+ ], CLIAdapter);
612
+ const packageConfigSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
613
+ cjsOutputPattern: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("Output pattern for CommonJS format, e.g., './dist/cjs/{dir}/{name}.cjs'"),
614
+ esmOutputPattern: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("Output pattern for ESM format, e.g., './dist/esm/{dir}/{name}.js'"),
615
+ packageJsonPath: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("Path to the package.json file, e.g., 'package.json'"),
616
+ srcIndexPath: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("Path to the source index file, e.g., 'src/index.ts'"),
617
+ typesOutputCjsPattern: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("Output pattern for CommonJS type declarations, e.g., './dist/types/{dir}/{name}.d.cts'"),
618
+ typesOutputPattern: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("Output pattern for type declarations, e.g., './dist/types/{dir}/{name}.d.ts'"),
619
+ exportPathPrefixesToRemove: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()).optional().describe("Prefixes to remove from export paths, e.g., ['components']")
636
620
  });
637
- const ScriptConfigSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z["interface"]({
638
- customPackageConfigs: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), PackageConfigSchema.partial()),
639
- defaultPackageConfig: PackageConfigSchema,
640
- packagesGlob: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
621
+ const scriptConfigSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
622
+ customPackageConfigs: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), packageConfigSchema.partial()).describe("Custom configurations for specific packages"),
623
+ defaultPackageConfig: packageConfigSchema.describe("Default configuration applied to all packages unless overridden"),
624
+ packagesGlob: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("Glob pattern to find package.json files, e.g., './packages/**/package.json'")
641
625
  });
642
- let cachedConfig = null;
643
- function loadConfigFile(configPath) {
644
- if (!configPath) return {};
645
- try {
646
- const fullPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(configPath);
647
- if (!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(fullPath)) {
648
- console.warn(`Configuration file not found at ${fullPath}`);
649
- return {};
650
- }
651
- const configContent = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(fullPath, "utf8");
652
- const config = JSON.parse(configContent);
653
- return ScriptConfigSchema.parse(config);
654
- } catch (error) {
655
- console.error("Error reading configuration file:", error);
656
- return {};
657
- }
658
- }
659
- function getConfig(configPath) {
660
- if (cachedConfig && !configPath) return cachedConfig;
661
- const userConfig = loadConfigFile(configPath);
662
- const config = (0, __WEBPACK_EXTERNAL_MODULE_lodash_es_18c59938__.merge)({}, defaultConfig, userConfig);
663
- if (!configPath) cachedConfig = config;
664
- return config;
665
- }
666
- function getPackageConfig(packageName, config) {
667
- const configObj = config ?? getConfig();
668
- const customConfig = configObj.customPackageConfigs[packageName] ?? {};
669
- return {
670
- ...configObj.defaultPackageConfig,
671
- ...customConfig
626
+ __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
627
+ directory: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("Directory containing the import, e.g., 'components'"),
628
+ exportPath: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("Resolved export path from the directory, e.g., './button'"),
629
+ name: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("Name of the import, e.g., 'Button'"),
630
+ originalPath: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("Original unresolved path, e.g., './components/button'")
631
+ });
632
+ const exportConfigSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
633
+ import: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
634
+ default: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("ESM default export path"),
635
+ types: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("ESM types export path")
636
+ }),
637
+ require: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
638
+ default: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("CommonJS default export path"),
639
+ types: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("CommonJS types export path")
640
+ })
641
+ });
642
+ const PackageExportsSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
643
+ exportConfigSchema,
644
+ __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
645
+ ]));
646
+ const packageJsonSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
647
+ dependencies: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.string()).optional().describe("List of runtime dependencies with their versions"),
648
+ devDependencies: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.string()).optional().describe("List of development dependencies with their versions"),
649
+ exports: PackageExportsSchema.optional().describe("Export mappings for the package"),
650
+ name: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("Name of the package"),
651
+ scripts: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.string()).describe("Script commands defined for the package"),
652
+ "simple-git-hooks": __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.string()).optional().describe("Git hooks configuration for the package"),
653
+ version: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional().describe("Version of the package")
654
+ }).catchall(__WEBPACK_EXTERNAL_MODULE_zod__.z.unknown());
655
+ function node_command_executor_adapter_ts_decorate(decorators, target, key, desc) {
656
+ var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
657
+ if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
658
+ 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;
659
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
660
+ }
661
+ function node_command_executor_adapter_ts_metadata(k, v) {
662
+ if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
663
+ }
664
+ function node_command_executor_adapter_ts_param(paramIndex, decorator) {
665
+ return function(target, key) {
666
+ decorator(target, key, paramIndex);
672
667
  };
673
668
  }
674
- const defaultConfig = {
675
- packagesGlob: "./packages/**/package.json",
676
- defaultPackageConfig: {
677
- cjsOutputPattern: "./dist/cjs/{dir}/{name}.cjs",
678
- esmOutputPattern: "./dist/esm/{dir}/{name}.js",
679
- packageJsonPath: "package.json",
680
- srcIndexPath: "src/index.ts",
681
- typesOutputCjsPattern: "./dist/types/{dir}/{name}.d.ts",
682
- typesOutputPattern: "./dist/types/{dir}/{name}.d.ts"
683
- },
684
- customPackageConfigs: {
685
- "@codefast/ui": {
686
- exportPathPrefixesToRemove: [
687
- "components"
688
- ]
689
- },
690
- "@codefast/style-guide": {
691
- exportPathPrefixesToRemove: [
692
- "configs"
693
- ]
669
+ class NodeCommandExecutorAdapter {
670
+ constructor(fileSystemPort, dependencyConfigService){
671
+ this.fileSystemPort = fileSystemPort;
672
+ this.dependencyConfigService = dependencyConfigService;
673
+ }
674
+ runCommand(command) {
675
+ (0, __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__.execSync)(command, {
676
+ stdio: "inherit"
677
+ });
678
+ }
679
+ checkEnvironment() {
680
+ try {
681
+ this.runCommand("pnpm --version");
682
+ } catch {
683
+ throw new Error("PNPM is not installed. Please install PNPM first.");
694
684
  }
695
685
  }
696
- };
697
- const EXPORTS_ANALYSIS_DIR = ".exports-analysis";
698
- const EXPORTS_PREVIEW_FILE = "exports-preview.json";
699
- const EXPORTS_ANALYSIS_FILE = "exports-analysis.json";
700
- const ENCODING = "utf8";
701
- const JSON_INDENT = 2;
702
- const FileUtils = {
703
- exists (filePath) {
686
+ installDependencies() {
687
+ console.log(`
688
+ \u{1F4DA} Installing dependencies...`);
689
+ const mainDependencies = this.dependencyConfigService.getMainDependencies();
690
+ if (mainDependencies.length > 0) this.runCommand(`pnpm add ${mainDependencies.join(" ")}`);
691
+ const devDependencies = this.dependencyConfigService.getDevDependencies();
692
+ const allDevDependencies = Object.values(devDependencies).flat().join(" ");
693
+ if (allDevDependencies) this.runCommand(`pnpm add -D ${allDevDependencies}`);
694
+ }
695
+ cleanupPackages() {
696
+ console.log(`
697
+ \u{1F9F9} Cleaning up unnecessary packages...`);
698
+ const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(process.cwd(), "package.json");
699
+ if (!this.fileSystemPort.exists(packageJsonPath)) return void console.warn(`\u{26A0}\u{FE0F} package.json not found, skipping cleanup.`);
700
+ let packageJson;
701
+ try {
702
+ packageJson = packageJsonSchema.parse(JSON.parse(this.fileSystemPort.readFile(packageJsonPath)));
703
+ } catch (error) {
704
+ console.warn(`\u{26A0}\u{FE0F} Error reading package.json: ${error instanceof Error ? error.message : "Unknown error"}, skipping cleanup.`);
705
+ return;
706
+ }
707
+ const dependencies = packageJson.dependencies ?? {};
708
+ const devDependencies = packageJson.devDependencies ?? {};
709
+ const packagesToRemove = this.dependencyConfigService.getPackagesToRemove().filter((pkg)=>pkg in dependencies || pkg in devDependencies);
710
+ if (packagesToRemove.length > 0) this.runCommand(`pnpm remove ${packagesToRemove.join(" ")}`);
711
+ else console.log(`\u{2139}\u{FE0F} No unnecessary packages found in package.json to remove.`);
712
+ }
713
+ enableGitHooks() {
714
+ console.log(`
715
+ \u{1F504} Activating git hooks...`);
716
+ this.runCommand("pnpm simple-git-hooks");
717
+ }
718
+ runFormatter() {
719
+ console.log(`
720
+ \u{1F4DD} Formatting files with Prettier...`);
721
+ this.runCommand("pnpm format");
722
+ }
723
+ runLinter() {
724
+ console.log(`
725
+ \u{1F50D} Running ESLint to check code style...`);
726
+ this.runCommand("pnpm lint");
727
+ }
728
+ }
729
+ NodeCommandExecutorAdapter = node_command_executor_adapter_ts_decorate([
730
+ (0, __WEBPACK_EXTERNAL_MODULE_inversify__.injectable)(),
731
+ node_command_executor_adapter_ts_param(0, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.FileSystemPort)),
732
+ node_command_executor_adapter_ts_param(1, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.DependencyConfigService)),
733
+ node_command_executor_adapter_ts_metadata("design:type", Function),
734
+ node_command_executor_adapter_ts_metadata("design:paramtypes", [
735
+ "undefined" == typeof FileSystemPort ? Object : FileSystemPort,
736
+ "undefined" == typeof DependencyConfigServiceInterface ? Object : DependencyConfigServiceInterface
737
+ ])
738
+ ], NodeCommandExecutorAdapter);
739
+ function node_file_system_adapter_ts_decorate(decorators, target, key, desc) {
740
+ var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
741
+ if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
742
+ 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;
743
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
744
+ }
745
+ class NodeFileSystemAdapter {
746
+ exists(filePath) {
704
747
  return __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(filePath);
705
- },
706
- ensureDirectoryExists (dirPath) {
707
- if (!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(dirPath)) __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].mkdirSync(dirPath, {
708
- recursive: true
709
- });
710
- },
711
- readJsonFile (filePath) {
748
+ }
749
+ access(filePath) {
750
+ __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].accessSync(filePath, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].constants.W_OK);
751
+ }
752
+ readFile(filePath) {
712
753
  try {
713
- const content = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(filePath, ENCODING);
714
- return JSON.parse(content);
754
+ return __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(filePath, "utf8");
715
755
  } catch (error) {
716
- console.error(`Error reading JSON file at ${filePath}:`, error);
717
- return null;
756
+ throw new Error(`Failed to read file ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
718
757
  }
719
- },
720
- writeJsonFile (filePath, content) {
758
+ }
759
+ writeFile(filePath, content) {
721
760
  try {
722
- __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].writeFileSync(filePath, `${JSON.stringify(content, null, JSON_INDENT)}\n`, ENCODING);
723
- return true;
761
+ const dir = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(filePath);
762
+ this.createDirectory(dir);
763
+ __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].writeFileSync(filePath, content);
724
764
  } catch (error) {
725
- console.error(`Error writing JSON file at ${filePath}:`, error);
726
- return false;
765
+ throw new Error(`Failed to write to file ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
727
766
  }
728
- },
729
- getAnalysisDir (packageDir) {
730
- const outputDir = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(packageDir, EXPORTS_ANALYSIS_DIR);
731
- this.ensureDirectoryExists(outputDir);
732
- return outputDir;
733
- },
734
- createBackupFilename (baseFilename) {
735
- const timestamp = new Date().toISOString().replaceAll(/[:.]/g, "-");
736
- return `${baseFilename}.backup.${timestamp}`;
737
767
  }
738
- };
739
- function fileExists(filePath) {
740
- return FileUtils.exists(filePath);
741
- }
742
- function readPackageJson(filePath) {
743
- return FileUtils.readJsonFile(filePath);
744
- }
745
- function backupPackageJson(filePath) {
746
- try {
747
- const content = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(filePath, ENCODING);
748
- const dir = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(filePath);
749
- const backupDir = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(dir, EXPORTS_ANALYSIS_DIR);
750
- FileUtils.ensureDirectoryExists(backupDir);
751
- const baseName = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].basename(filePath);
752
- const backupPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(backupDir, FileUtils.createBackupFilename(baseName));
753
- __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].writeFileSync(backupPath, content, ENCODING);
754
- return true;
755
- } catch (error) {
756
- console.error(`Error backing up package.json at ${filePath}:`, error);
757
- return false;
768
+ createDirectory(dirPath) {
769
+ if (!this.exists(dirPath)) __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].mkdirSync(dirPath, {
770
+ recursive: true
771
+ });
772
+ }
773
+ writeConfigFile(filePath, content) {
774
+ this.writeFile(filePath, content);
775
+ console.log(`\u{1F4DD} Created ${filePath}`);
776
+ }
777
+ createConfigFiles(projectDir, configGroups) {
778
+ console.log(`
779
+ \u{1F4DD} Creating configuration files...`);
780
+ for (const [category, configs] of Object.entries(configGroups)){
781
+ console.log(`
782
+ \u{1F4C2} Setting up ${category} configurations:`);
783
+ for (const config of configs){
784
+ const fullPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectDir, config.path);
785
+ this.writeConfigFile(fullPath, config.content);
786
+ if (config.description) console.log(`\u{2139}\u{FE0F} ${config.path}: ${config.description}`);
787
+ }
788
+ }
758
789
  }
759
790
  }
760
- function savePackageJson(filePath, content) {
761
- return FileUtils.writeJsonFile(filePath, content);
762
- }
763
- function saveJsonToFile(packageDir, fileName, content) {
764
- const outputDir = FileUtils.getAnalysisDir(packageDir);
765
- FileUtils.writeJsonFile(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(outputDir, fileName), content);
791
+ NodeFileSystemAdapter = node_file_system_adapter_ts_decorate([
792
+ (0, __WEBPACK_EXTERNAL_MODULE_inversify__.injectable)()
793
+ ], NodeFileSystemAdapter);
794
+ function node_prompt_adapter_ts_decorate(decorators, target, key, desc) {
795
+ var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
796
+ if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
797
+ 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;
798
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
766
799
  }
767
- function saveExportsAnalysis(packageDir, analysis) {
768
- saveJsonToFile(packageDir, EXPORTS_ANALYSIS_FILE, analysis);
800
+ function node_prompt_adapter_ts_metadata(k, v) {
801
+ if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
769
802
  }
770
- function saveExportsPreview(packageDir, exports) {
771
- saveJsonToFile(packageDir, EXPORTS_PREVIEW_FILE, exports);
803
+ class NodePromptAdapter {
804
+ constructor(){
805
+ this.rl = __WEBPACK_EXTERNAL_MODULE_node_readline_91c31510__["default"].createInterface({
806
+ input: process.stdin,
807
+ output: process.stdout
808
+ });
809
+ }
810
+ async prompt(message) {
811
+ return new Promise((resolve)=>{
812
+ this.rl.question(message, (answer)=>{
813
+ resolve(answer.trim());
814
+ });
815
+ });
816
+ }
817
+ close() {
818
+ this.rl.close();
819
+ }
772
820
  }
773
- function formatOutputPath(pattern, directory, name) {
774
- const dirPart = "." === directory ? "" : `${directory}/`;
775
- return pattern.replace("{dir}/", dirPart).replace("{dir}", directory).replace("{name}", name);
821
+ NodePromptAdapter = node_prompt_adapter_ts_decorate([
822
+ (0, __WEBPACK_EXTERNAL_MODULE_inversify__.injectable)(),
823
+ node_prompt_adapter_ts_metadata("design:type", Function),
824
+ node_prompt_adapter_ts_metadata("design:paramtypes", [])
825
+ ], NodePromptAdapter);
826
+ function ts_morph_analysis_adapter_ts_decorate(decorators, target, key, desc) {
827
+ var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
828
+ if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
829
+ 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;
830
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
776
831
  }
777
- function generateExports(packageName, imports, existingExports = {}, config) {
778
- const packageConfig = getPackageConfig(packageName, config);
779
- const exports = {
780
- ".": existingExports["."] ?? {
781
- import: {
782
- types: "./dist/types/index.d.ts",
783
- default: "./dist/esm/index.js"
784
- },
785
- require: {
786
- types: "./dist/types/index.d.cts",
787
- default: "./dist/cjs/index.cjs"
788
- }
832
+ class TsMorphAnalysisAdapter {
833
+ analyzeImports(indexFilePath, packageConfig) {
834
+ const project = new __WEBPACK_EXTERNAL_MODULE_ts_morph_07c7ce60__.Project();
835
+ let sourceFile;
836
+ try {
837
+ sourceFile = project.addSourceFileAtPath(indexFilePath);
838
+ } catch (error) {
839
+ console.error(`Error loading source file at ${indexFilePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
840
+ return {
841
+ imports: []
842
+ };
843
+ }
844
+ const imports = [];
845
+ const prefixesToRemove = packageConfig.exportPathPrefixesToRemove ?? [];
846
+ const regexPattern = new RegExp(`^.?\\/?(?:${prefixesToRemove.join("|")})\\/(.*)$`);
847
+ for (const exportDecl of sourceFile.getExportDeclarations()){
848
+ let moduleSpecifier = exportDecl.getModuleSpecifierValue();
849
+ if (!moduleSpecifier) continue;
850
+ if (moduleSpecifier.startsWith("@/")) moduleSpecifier = `./${moduleSpecifier.slice(2)}`;
851
+ const isExternal = !moduleSpecifier.startsWith(".");
852
+ if (isExternal) continue;
853
+ const parts = moduleSpecifier.split("/").filter(Boolean);
854
+ if (parts.length < 2) continue;
855
+ let directory = parts.length <= 1 ? "." : parts.slice(0, -1).join("/");
856
+ if (directory.startsWith("./")) directory = directory.slice(2);
857
+ const name = parts.at(-1) ?? "";
858
+ const exportPath = this.processExportPath(moduleSpecifier, regexPattern);
859
+ imports.push({
860
+ originalPath: moduleSpecifier,
861
+ directory,
862
+ name,
863
+ exportPath
864
+ });
789
865
  }
866
+ return {
867
+ imports
868
+ };
869
+ }
870
+ processExportPath(modulePath, regexPattern) {
871
+ const match = modulePath.match(regexPattern);
872
+ if (match) {
873
+ const remainingPath = match[1];
874
+ return remainingPath.startsWith("./") ? remainingPath : `./${remainingPath}`;
875
+ }
876
+ return modulePath;
877
+ }
878
+ }
879
+ TsMorphAnalysisAdapter = ts_morph_analysis_adapter_ts_decorate([
880
+ (0, __WEBPACK_EXTERNAL_MODULE_inversify__.injectable)()
881
+ ], TsMorphAnalysisAdapter);
882
+ function file_system_package_repository_ts_decorate(decorators, target, key, desc) {
883
+ var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
884
+ if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
885
+ 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;
886
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
887
+ }
888
+ function file_system_package_repository_ts_metadata(k, v) {
889
+ if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
890
+ }
891
+ function file_system_package_repository_ts_param(paramIndex, decorator) {
892
+ return function(target, key) {
893
+ decorator(target, key, paramIndex);
790
894
  };
791
- if (existingExports["./styles.css"]) exports["./styles.css"] = existingExports["./styles.css"];
792
- for (const importPath of imports){
793
- const { directory, name, exportPath } = importPath;
794
- const esmOutput = formatOutputPath(packageConfig.esmOutputPattern, directory, name);
795
- const cjsOutput = formatOutputPath(packageConfig.cjsOutputPattern, directory, name);
796
- const typesOutput = formatOutputPath(packageConfig.typesOutputPattern, directory, name);
797
- const typesCjsOutput = formatOutputPath(packageConfig.typesOutputCjsPattern, directory, name);
798
- exports[exportPath] = {
799
- import: {
800
- types: typesOutput,
801
- default: esmOutput
895
+ }
896
+ class FileSystemPackageRepository {
897
+ constructor(fileSystemPort, analysisPort, fileSystemUtility){
898
+ this.fileSystemPort = fileSystemPort;
899
+ this.analysisPort = analysisPort;
900
+ this.fileSystemUtility = fileSystemUtility;
901
+ this.DEFAULT_IGNORE_PATTERN = [
902
+ "**/node_modules/**"
903
+ ];
904
+ this.cachedConfig = null;
905
+ this.defaultConfig = {
906
+ packagesGlob: "./packages/**/package.json",
907
+ defaultPackageConfig: {
908
+ cjsOutputPattern: "./dist/cjs/{dir}/{name}.cjs",
909
+ esmOutputPattern: "./dist/esm/{dir}/{name}.js",
910
+ packageJsonPath: "package.json",
911
+ srcIndexPath: "src/index.ts",
912
+ typesOutputCjsPattern: "./dist/types/{dir}/{name}.d.ts",
913
+ typesOutputPattern: "./dist/types/{dir}/{name}.d.ts"
802
914
  },
803
- require: {
804
- types: typesCjsOutput,
805
- default: cjsOutput
915
+ customPackageConfigs: {
916
+ "@codefast/ui": {
917
+ exportPathPrefixesToRemove: [
918
+ "components"
919
+ ]
920
+ },
921
+ "@codefast/style-guide": {
922
+ exportPathPrefixesToRemove: [
923
+ "configs"
924
+ ]
925
+ }
806
926
  }
807
927
  };
808
928
  }
809
- return exports;
810
- }
811
- const DEFAULT_IGNORE_PATTERN = [
812
- "**/node_modules/**"
813
- ];
814
- async function findAllPackages(config) {
815
- const configObj = config ?? getConfig();
816
- return await (0, __WEBPACK_EXTERNAL_MODULE_glob__.glob)(configObj.packagesGlob, {
817
- ignore: DEFAULT_IGNORE_PATTERN
818
- });
819
- }
820
- function processPackage(packageJsonPath, options) {
821
- const packageDir = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(packageJsonPath);
822
- const packageJson = readPackageJson(packageJsonPath);
823
- if (!packageJson) {
824
- console.error(`Failed to read ${packageJsonPath}`);
825
- return false;
826
- }
827
- const packageName = packageJson.name;
828
- if (options.packageFilter && packageName !== options.packageFilter) {
829
- console.debug(`Skipping ${packageName} (does not match filter)`);
830
- return false;
831
- }
832
- console.info(`Processing package: ${packageName}`);
833
- const config = getConfig(options.configPath);
834
- const packageConfig = getPackageConfig(packageName, config);
835
- const srcIndexPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(packageDir, packageConfig.srcIndexPath);
836
- if (!fileExists(srcIndexPath)) {
837
- console.error(`Source file not found at ${srcIndexPath}`);
838
- return false;
839
- }
840
- console.info(`Analyzing imports from ${srcIndexPath}...`);
841
- const { imports } = analyzeImports(srcIndexPath, packageConfig);
842
- if (0 === imports.length) {
843
- console.warn(`No imports found to analyze in ${packageName}`);
844
- return false;
845
- }
846
- console.log(`Analysis complete. Found ${imports.length} subpath exports.`);
847
- saveExportsAnalysis(packageDir, {
848
- imports
849
- });
850
- const newExports = generateExports(packageName, imports, packageJson.exports, config);
851
- const currentExportsCount = packageJson.exports ? Object.keys(packageJson.exports).length : 0;
852
- const newExportsCount = Object.keys(newExports).length;
853
- console.info(`Exports: ${currentExportsCount} -> ${newExportsCount}`);
854
- if (options.dryRun) {
855
- saveExportsPreview(packageDir, newExports);
856
- console.warn("Saved exports preview to .exports-analysis");
857
- console.warn(`Dry run: no changes saved for ${packageName}`);
929
+ async findAllPackages(configPath) {
930
+ const config = this.getConfig(configPath);
931
+ return await (0, __WEBPACK_EXTERNAL_MODULE_glob__.glob)(config.packagesGlob, {
932
+ ignore: this.DEFAULT_IGNORE_PATTERN
933
+ });
934
+ }
935
+ processPackage(packageJsonPath, options) {
936
+ const packageDir = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(packageJsonPath);
937
+ let packageJson;
938
+ try {
939
+ packageJson = JSON.parse(this.fileSystemPort.readFile(packageJsonPath));
940
+ } catch (error) {
941
+ console.error(`Failed to parse ${packageJsonPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
942
+ return false;
943
+ }
944
+ const packageName = packageJson.name;
945
+ if (options.packageFilter && packageName !== options.packageFilter) {
946
+ console.debug(`Skipping ${packageName} (does not match filter)`);
947
+ return false;
948
+ }
949
+ console.info(`\u{2662}\u{2012} Processing package: ${packageName}`);
950
+ const config = this.getConfig(options.configPath);
951
+ const packageConfig = this.getPackageConfig(packageName, config);
952
+ const srcIndexPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(packageDir, packageConfig.srcIndexPath);
953
+ if (!this.fileSystemPort.exists(srcIndexPath)) {
954
+ console.error(`\u{23B9} \u{26D4}\u{FE0E} Source file not found at ${srcIndexPath}`);
955
+ return false;
956
+ }
957
+ console.info(`\u{23B9} Analyzing imports from ${srcIndexPath}...`);
958
+ const analysis = this.analyzeImports(srcIndexPath, packageConfig);
959
+ if (0 === analysis.imports.length) {
960
+ console.warn(`\u{23B9} \u{26D4}\u{FE0E} No imports found to analyze in ${packageName}`);
961
+ return false;
962
+ }
963
+ console.log(`\u{23B9} Analysis complete. Found ${analysis.imports.length} subpath exports.`);
964
+ this.saveExportsAnalysis(packageDir, analysis);
965
+ const newExports = this.generateExports(packageName, analysis.imports, packageJson.exports ?? {}, config);
966
+ const currentExportsCount = packageJson.exports ? Object.keys(packageJson.exports).length : 0;
967
+ const newExportsCount = Object.keys(newExports).length;
968
+ console.info(`\u{23B9} Exports: ${currentExportsCount} -> ${newExportsCount}`);
969
+ if (options.dryRun) {
970
+ this.saveExportsPreview(packageDir, newExports);
971
+ console.warn(`\u{23B9} Saved exports preview to .exports-analysis`);
972
+ console.warn(`\u{23B9} Dry run: no changes saved for ${packageName}`);
973
+ return true;
974
+ }
975
+ this.fileSystemUtility.backupFile(packageJsonPath, ".exports-analysis");
976
+ console.log(`\u{23B9} Backed up ${packageJsonPath}`);
977
+ const updatedPackageJson = {
978
+ ...packageJson,
979
+ exports: newExports
980
+ };
981
+ this.fileSystemPort.writeFile(packageJsonPath, `${JSON.stringify(updatedPackageJson, null, 2)}\n`);
982
+ console.log(`\u{23B9} Updated exports for ${packageName}`);
858
983
  return true;
859
984
  }
860
- if (backupPackageJson(packageJsonPath)) console.log(`Backed up ${packageJsonPath}`);
861
- const updatedPackageJson = {
862
- ...packageJson,
863
- exports: newExports
985
+ analyzeImports(indexFilePath, packageConfig) {
986
+ return this.analysisPort.analyzeImports(indexFilePath, packageConfig);
987
+ }
988
+ generateExports(packageName, imports, existingExports, config) {
989
+ const packageConfig = this.getPackageConfig(packageName, config);
990
+ const exports = {
991
+ ".": existingExports["."] ?? {
992
+ import: {
993
+ default: "./dist/esm/index.js",
994
+ types: "./dist/types/index.d.ts"
995
+ },
996
+ require: {
997
+ default: "./dist/cjs/index.cjs",
998
+ types: "./dist/types/index.d.cts"
999
+ }
1000
+ }
1001
+ };
1002
+ if (existingExports["./styles.css"]) exports["./styles.css"] = existingExports["./styles.css"];
1003
+ for (const importPath of imports){
1004
+ const { directory, name, exportPath } = importPath;
1005
+ const esmOutput = this.formatOutputPath(packageConfig.esmOutputPattern, directory, name);
1006
+ const cjsOutput = this.formatOutputPath(packageConfig.cjsOutputPattern, directory, name);
1007
+ const typesOutput = this.formatOutputPath(packageConfig.typesOutputPattern, directory, name);
1008
+ const typesCjsOutput = this.formatOutputPath(packageConfig.typesOutputCjsPattern, directory, name);
1009
+ exports[exportPath] = {
1010
+ import: {
1011
+ default: esmOutput,
1012
+ types: typesOutput
1013
+ },
1014
+ require: {
1015
+ default: cjsOutput,
1016
+ types: typesCjsOutput
1017
+ }
1018
+ };
1019
+ }
1020
+ return exports;
1021
+ }
1022
+ getConfig(configPath) {
1023
+ if (this.cachedConfig && !configPath) return this.cachedConfig;
1024
+ const userConfig = this.loadConfigFile(configPath);
1025
+ const config = (0, __WEBPACK_EXTERNAL_MODULE_lodash_es_18c59938__.merge)({}, this.defaultConfig, userConfig);
1026
+ if (!configPath) this.cachedConfig = config;
1027
+ return config;
1028
+ }
1029
+ loadConfigFile(configPath) {
1030
+ if (!configPath) return {};
1031
+ try {
1032
+ const fullPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(configPath);
1033
+ if (!this.fileSystemPort.exists(fullPath)) {
1034
+ console.warn(`Configuration file not found at ${fullPath}`);
1035
+ return {};
1036
+ }
1037
+ const configContent = this.fileSystemPort.readFile(fullPath);
1038
+ return scriptConfigSchema.parse(JSON.parse(configContent));
1039
+ } catch (error) {
1040
+ console.error(`Error reading configuration file: ${error instanceof Error ? error.message : "Unknown error"}`);
1041
+ return {};
1042
+ }
1043
+ }
1044
+ getPackageConfig(packageName, config) {
1045
+ const customConfig = config.customPackageConfigs[packageName] ?? {};
1046
+ return {
1047
+ ...config.defaultPackageConfig,
1048
+ ...customConfig
1049
+ };
1050
+ }
1051
+ formatOutputPath(pattern, directory, name) {
1052
+ const dirPart = "." === directory ? "" : `${directory}/`;
1053
+ return pattern.replace("{dir}/", dirPart).replace("{dir}", directory).replace("{name}", name);
1054
+ }
1055
+ saveExportsAnalysis(packageDir, analysis) {
1056
+ const outputDir = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(packageDir, ".exports-analysis");
1057
+ this.fileSystemPort.createDirectory(outputDir);
1058
+ this.fileSystemPort.writeFile(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(outputDir, "exports-analysis.json"), JSON.stringify(analysis, null, 2));
1059
+ }
1060
+ saveExportsPreview(packageDir, exports) {
1061
+ const outputDir = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(packageDir, ".exports-analysis");
1062
+ this.fileSystemPort.createDirectory(outputDir);
1063
+ this.fileSystemPort.writeFile(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(outputDir, "exports-preview.json"), JSON.stringify(exports, null, 2));
1064
+ }
1065
+ }
1066
+ FileSystemPackageRepository = file_system_package_repository_ts_decorate([
1067
+ (0, __WEBPACK_EXTERNAL_MODULE_inversify__.injectable)(),
1068
+ file_system_package_repository_ts_param(0, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.FileSystemPort)),
1069
+ file_system_package_repository_ts_param(1, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.AnalysisPort)),
1070
+ file_system_package_repository_ts_param(2, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.FileSystemUtility)),
1071
+ file_system_package_repository_ts_metadata("design:type", Function),
1072
+ file_system_package_repository_ts_metadata("design:paramtypes", [
1073
+ "undefined" == typeof FileSystemPort ? Object : FileSystemPort,
1074
+ "undefined" == typeof AnalysisPort ? Object : AnalysisPort,
1075
+ "undefined" == typeof FileSystemUtility ? Object : FileSystemUtility
1076
+ ])
1077
+ ], FileSystemPackageRepository);
1078
+ const projectSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
1079
+ name: __WEBPACK_EXTERNAL_MODULE_zod__.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-._~]*$/, {
1080
+ message: "Project name must be URL-friendly (letters, numbers, hyphens, underscores, dots; no @ or scoped packages)"
1081
+ }).refine((name)=>"." !== name && ".." !== name, {
1082
+ message: "Project name cannot be '.' or '..'"
1083
+ }).refine((name)=>!/^(?<reserved>CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i.test(name), {
1084
+ message: "Project name is a reserved system name"
1085
+ }),
1086
+ directory: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().describe("Project directory path"),
1087
+ packageJsonExists: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().describe("Whether package.json exists in the project directory")
1088
+ });
1089
+ function file_system_project_repository_ts_decorate(decorators, target, key, desc) {
1090
+ var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
1091
+ if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
1092
+ 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;
1093
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
1094
+ }
1095
+ function file_system_project_repository_ts_metadata(k, v) {
1096
+ if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
1097
+ }
1098
+ function file_system_project_repository_ts_param(paramIndex, decorator) {
1099
+ return function(target, key) {
1100
+ decorator(target, key, paramIndex);
864
1101
  };
865
- if (savePackageJson(packageJsonPath, updatedPackageJson)) {
866
- console.log(`Updated exports for ${packageName}`);
867
- return true;
1102
+ }
1103
+ class FileSystemProjectRepository {
1104
+ constructor(fileSystemPort, commandExecutorPort, promptPort, fileSystemUtility){
1105
+ this.fileSystemPort = fileSystemPort;
1106
+ this.commandExecutorPort = commandExecutorPort;
1107
+ this.promptPort = promptPort;
1108
+ this.fileSystemUtility = fileSystemUtility;
868
1109
  }
869
- console.error(`Failed to update ${packageJsonPath}`);
870
- return false;
871
- }
872
- async function processAllPackages(options) {
873
- try {
874
- console.info("Searching for packages...");
875
- const config = getConfig(options.configPath);
876
- const packageJsonPaths = await findAllPackages(config);
877
- if (0 === packageJsonPaths.length) return void console.warn("No packages found.");
878
- console.log(`Found ${packageJsonPaths.length} packages.`);
879
- let successCount = 0;
880
- let skipCount = 0;
881
- let errorCount = 0;
882
- for (const packageJsonPath of packageJsonPaths){
883
- const result = processPackage(packageJsonPath, options);
884
- if (result) successCount++;
885
- else if (options.packageFilter) skipCount++;
886
- else errorCount++;
1110
+ async checkExistingProject(projectName) {
1111
+ let fullPath = process.cwd();
1112
+ let name = "";
1113
+ const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(process.cwd(), "package.json");
1114
+ const packageJsonExists = this.fileSystemPort.exists(packageJsonPath);
1115
+ if (packageJsonExists) {
1116
+ const result = packageJsonSchema.safeParse(JSON.parse(this.fileSystemPort.readFile(packageJsonPath)));
1117
+ if (result.success) name = result.data.name;
1118
+ } else {
1119
+ name = await this.getValidProjectName(projectName);
1120
+ fullPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(process.cwd(), name);
887
1121
  }
888
- console.log("Completed exports update.");
889
- console.info(`Stats: ${successCount} succeeded, ${skipCount} skipped, ${errorCount} failed`);
890
- } catch (error) {
891
- console.error("Error processing packages:", error);
892
- throw error;
893
- }
894
- }
895
- function createUpdateExportsCommand(program) {
896
- 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)=>{
897
- const processorOptions = {
898
- packageFilter: options.package,
899
- dryRun: Boolean(options.dryRun),
900
- configPath: options.config
1122
+ return {
1123
+ name,
1124
+ directory: fullPath,
1125
+ packageJsonExists
901
1126
  };
1127
+ }
1128
+ createNextProject(projectName) {
1129
+ const flags = '--ts --tailwind --eslint --app --turbo --use-pnpm --src-dir --turbopack --import-alias "@/*"';
1130
+ this.commandExecutorPort.runCommand(`npx create-next-app@latest ${projectName} ${flags}`);
1131
+ }
1132
+ updateLayoutFile(projectDir) {
1133
+ const layoutPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectDir, "src", "app", "layout.tsx");
1134
+ const htmlTarget = '<html className={cn(fontVariables, "antialiased")} lang="en">';
1135
+ this.fileSystemUtility.updateFileIfNeeded(layoutPath, (content)=>content.includes(htmlTarget), (content)=>{
1136
+ const newImports = `import type { Metadata } from "next";
1137
+ import type { JSX, ReactNode } from "react";
1138
+ import { cn } from "@codefast/ui";
1139
+ import { fontVariables } from "@/lib/fonts";
1140
+ import "@/app/globals.css";`;
1141
+ let result = content;
1142
+ result = result.replaceAll(/import\s+{[^}]+}\s+from\s+["']next\/font\/google["'];\s*/g, "");
1143
+ result = result.replace(/const\s+geistSans\s*=[^;]+;\s*const\s+geistMono\s*=[^;]+;\s*/, "");
1144
+ result = result.replace(/import\s+type\s+{[^}]+}\s+from\s+["']next["'];\s*import\s+["']\.\/globals\.css["'];\s*/, newImports);
1145
+ 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 {");
1146
+ result = result.replace(/<html\s+lang="en"\s*>/, htmlTarget);
1147
+ result = result.replace(/<body\s+className={`[^`]*`}\s*>/, "<body>");
1148
+ return result;
1149
+ });
1150
+ }
1151
+ updatePageFile(projectDir) {
1152
+ const pagePath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectDir, "src", "app", "page.tsx");
1153
+ this.fileSystemUtility.updateFileIfNeeded(pagePath, (content)=>content.includes("): JSX.Element"), (content)=>{
1154
+ let result = content;
1155
+ 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}`;
1156
+ result = result.replace(/export default function Home\(\) {/, "export default function Home(): JSX.Element {");
1157
+ return result;
1158
+ });
1159
+ }
1160
+ updatePostcssConfig(projectDir) {
1161
+ const postcssConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectDir, "postcss.config.mjs");
1162
+ const typeComment = `/** @type {import('postcss-load-config').Config} */\n`;
1163
+ this.fileSystemUtility.updateFileIfNeeded(postcssConfigPath, (content)=>content.includes(typeComment), (content)=>content.replace("const config = {", `${typeComment}const config = {`));
1164
+ }
1165
+ updateNextConfig(projectDir) {
1166
+ const nextConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectDir, "next.config.ts");
1167
+ const optimizePackagesConfig = 'optimizePackageImports: ["@codefast/ui"]';
1168
+ this.fileSystemUtility.updateFileIfNeeded(nextConfigPath, (content)=>content.includes(optimizePackagesConfig), (content)=>content.replace(/const nextConfig: NextConfig = \{/, `const nextConfig: NextConfig = {
1169
+ experimental: {
1170
+ optimizePackageImports: ["@codefast/ui"],
1171
+ },`));
1172
+ }
1173
+ updatePackageJson(projectDir) {
1174
+ const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectDir, "package.json");
1175
+ if (!this.fileSystemPort.exists(packageJsonPath)) return void console.warn(`\u{26A0}\u{FE0F} package.json not found, skipping update.`);
1176
+ let packageJson;
902
1177
  try {
903
- await processAllPackages(processorOptions);
1178
+ packageJson = packageJsonSchema.parse(JSON.parse(this.fileSystemPort.readFile(packageJsonPath)));
1179
+ } catch {
1180
+ console.warn(`Failed to parse ${packageJsonPath}, skipping update.`);
1181
+ return;
1182
+ }
1183
+ packageJson.scripts = {
1184
+ ...packageJson.scripts,
1185
+ "check-types": "tsc --noEmit",
1186
+ "deploy:preview": "vercel deploy --archive=tgz",
1187
+ "deploy:prod": "vercel deploy --archive=tgz --prod",
1188
+ format: "prettier --write --ignore-unknown .",
1189
+ "format:check": "prettier --check --ignore-unknown .",
1190
+ lint: "next lint --fix --max-warnings 0",
1191
+ "lint:check": "next lint --max-warnings 0",
1192
+ "package:install": "pnpm install",
1193
+ "package:outdated": "pnpm outdated",
1194
+ "package:upgrade": "pnpm update --latest",
1195
+ preview: "pnpm build && pnpm start"
1196
+ };
1197
+ packageJson["simple-git-hooks"] = {
1198
+ "pre-commit": "pnpm lint-staged",
1199
+ "commit-msg": "pnpm commitlint --edit"
1200
+ };
1201
+ this.fileSystemPort.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
1202
+ console.log(`\u{1F4DD} Updated ${packageJsonPath}`);
1203
+ }
1204
+ async getValidProjectName(initialName, attempts = 0, maxAttempts = 3) {
1205
+ const projectName = initialName ?? await this.promptPort.prompt("Enter project name: ");
1206
+ const result = projectSchema.safeParse({
1207
+ name: projectName,
1208
+ directory: "",
1209
+ packageJsonExists: false
1210
+ });
1211
+ if (result.success) {
1212
+ const fullPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(process.cwd(), projectName);
1213
+ if (this.fileSystemPort.exists(fullPath)) throw new Error(`A directory named "${projectName}" already exists.`);
1214
+ try {
1215
+ this.fileSystemPort.access(process.cwd());
1216
+ } catch {
1217
+ throw new Error("Cannot create project: No write permission in current directory.");
1218
+ }
1219
+ return projectName;
1220
+ }
1221
+ if (attempts >= maxAttempts - 1) throw new Error("Exceeded maximum attempts to enter a valid project name.");
1222
+ console.error(`\u{274C} ${result.error.message} (${maxAttempts - attempts - 1} attempts remaining)`);
1223
+ return this.getValidProjectName(void 0, attempts + 1, maxAttempts);
1224
+ }
1225
+ }
1226
+ FileSystemProjectRepository = file_system_project_repository_ts_decorate([
1227
+ (0, __WEBPACK_EXTERNAL_MODULE_inversify__.injectable)(),
1228
+ file_system_project_repository_ts_param(0, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.FileSystemPort)),
1229
+ file_system_project_repository_ts_param(1, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.CommandExecutorPort)),
1230
+ file_system_project_repository_ts_param(2, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.PromptPort)),
1231
+ file_system_project_repository_ts_param(3, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.FileSystemUtility)),
1232
+ file_system_project_repository_ts_metadata("design:type", Function),
1233
+ file_system_project_repository_ts_metadata("design:paramtypes", [
1234
+ "undefined" == typeof FileSystemPort ? Object : FileSystemPort,
1235
+ "undefined" == typeof CommandExecutorPort ? Object : CommandExecutorPort,
1236
+ "undefined" == typeof PromptPort ? Object : PromptPort,
1237
+ "undefined" == typeof FileSystemUtility ? Object : FileSystemUtility
1238
+ ])
1239
+ ], FileSystemProjectRepository);
1240
+ function dependency_config_service_ts_decorate(decorators, target, key, desc) {
1241
+ var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
1242
+ if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
1243
+ 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;
1244
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
1245
+ }
1246
+ class DependencyConfigService {
1247
+ getMainDependencies() {
1248
+ return this.MAIN_DEPENDENCIES;
1249
+ }
1250
+ getDevDependencies() {
1251
+ return this.DEV_DEPENDENCIES;
1252
+ }
1253
+ getPackagesToRemove() {
1254
+ return this.PACKAGES_TO_REMOVE;
1255
+ }
1256
+ constructor(){
1257
+ this.MAIN_DEPENDENCIES = [
1258
+ "@codefast/ui",
1259
+ "@codefast/hooks",
1260
+ "recharts",
1261
+ "react-hook-form",
1262
+ "next-themes",
1263
+ "date-fns",
1264
+ "lucide-react"
1265
+ ];
1266
+ this.DEV_DEPENDENCIES = {
1267
+ commitLint: [
1268
+ "@commitlint/cli",
1269
+ "@commitlint/config-conventional",
1270
+ "@commitlint/types"
1271
+ ],
1272
+ gitTools: [
1273
+ "simple-git-hooks"
1274
+ ],
1275
+ formatting: [
1276
+ "prettier",
1277
+ "prettier-plugin-packagejson",
1278
+ "prettier-plugin-tailwindcss",
1279
+ "lint-staged"
1280
+ ],
1281
+ linting: [
1282
+ "@codefast/eslint-config"
1283
+ ]
1284
+ };
1285
+ this.PACKAGES_TO_REMOVE = [
1286
+ "@eslint/eslintrc",
1287
+ "eslint-config-next"
1288
+ ];
1289
+ }
1290
+ }
1291
+ DependencyConfigService = dependency_config_service_ts_decorate([
1292
+ (0, __WEBPACK_EXTERNAL_MODULE_inversify__.injectable)()
1293
+ ], DependencyConfigService);
1294
+ function node_package_info_service_ts_decorate(decorators, target, key, desc) {
1295
+ var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
1296
+ if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
1297
+ 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;
1298
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
1299
+ }
1300
+ function node_package_info_service_ts_metadata(k, v) {
1301
+ if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
1302
+ }
1303
+ function node_package_info_service_ts_param(paramIndex, decorator) {
1304
+ return function(target, key) {
1305
+ decorator(target, key, paramIndex);
1306
+ };
1307
+ }
1308
+ class NodePackageInfoService {
1309
+ constructor(fileSystemPort){
1310
+ this.fileSystemPort = fileSystemPort;
1311
+ }
1312
+ getPackageVersion() {
1313
+ try {
1314
+ const __filename = (0, __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__.fileURLToPath)(import.meta.url);
1315
+ const __dirname = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(__filename);
1316
+ const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(__dirname, "..", "package.json");
1317
+ const packageJsonResult = packageJsonSchema.parse(JSON.parse(this.fileSystemPort.readFile(packageJsonPath)));
1318
+ return packageJsonResult.version ?? "0.0.0";
904
1319
  } catch (error) {
905
- console.error("Error processing packages:", error);
906
- process.exit(1);
1320
+ console.warn(`Failed to read package version: ${error instanceof Error ? error.message : "Unknown error"}`);
1321
+ return "unknown";
907
1322
  }
908
- });
1323
+ }
1324
+ }
1325
+ NodePackageInfoService = node_package_info_service_ts_decorate([
1326
+ (0, __WEBPACK_EXTERNAL_MODULE_inversify__.injectable)(),
1327
+ node_package_info_service_ts_param(0, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.FileSystemPort)),
1328
+ node_package_info_service_ts_metadata("design:type", Function),
1329
+ node_package_info_service_ts_metadata("design:paramtypes", [
1330
+ "undefined" == typeof FileSystemPort ? Object : FileSystemPort
1331
+ ])
1332
+ ], NodePackageInfoService);
1333
+ function file_system_utility_ts_decorate(decorators, target, key, desc) {
1334
+ var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
1335
+ if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
1336
+ 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;
1337
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
909
1338
  }
910
- function getPackageInfo() {
911
- const __filename = (0, __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__.fileURLToPath)(import.meta.url);
912
- const __dirname = (0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.dirname)(__filename);
913
- const packageJsonPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.resolve)(__dirname, "../package.json");
914
- return JSON.parse((0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.readFileSync)(packageJsonPath, "utf8"));
1339
+ function file_system_utility_ts_metadata(k, v) {
1340
+ if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
915
1341
  }
916
- function getPackageVersion() {
917
- return getPackageInfo().version;
1342
+ function file_system_utility_ts_param(paramIndex, decorator) {
1343
+ return function(target, key) {
1344
+ decorator(target, key, paramIndex);
1345
+ };
1346
+ }
1347
+ class file_system_utility_FileSystemUtility {
1348
+ constructor(fileSystemPort){
1349
+ this.fileSystemPort = fileSystemPort;
1350
+ }
1351
+ updateFileIfNeeded(filePath, checkFn, updateFn) {
1352
+ if (!this.fileSystemPort.exists(filePath)) return;
1353
+ const currentContent = this.fileSystemPort.readFile(filePath);
1354
+ if (checkFn(currentContent)) return void console.log(`\u{2139}\u{FE0F} ${filePath} is already up to date`);
1355
+ try {
1356
+ const updatedContent = updateFn(currentContent);
1357
+ this.fileSystemPort.writeFile(filePath, updatedContent);
1358
+ console.log(`\u{1F4DD} Updated ${filePath}`);
1359
+ } catch (error) {
1360
+ console.warn(`\u{26A0}\u{FE0F} Failed to update ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
1361
+ }
1362
+ }
1363
+ backupFile(filePath, backupDir) {
1364
+ try {
1365
+ const content = this.fileSystemPort.readFile(filePath);
1366
+ const baseName = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].basename(filePath);
1367
+ const timestamp = new Date().toISOString().replaceAll(/[:.]/g, "-");
1368
+ const backupPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(filePath), backupDir, `${baseName}.backup.${timestamp}`);
1369
+ this.fileSystemPort.createDirectory(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(backupPath));
1370
+ this.fileSystemPort.writeFile(backupPath, content);
1371
+ } catch (error) {
1372
+ console.error(`Error backing up ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
1373
+ }
1374
+ }
918
1375
  }
1376
+ file_system_utility_FileSystemUtility = file_system_utility_ts_decorate([
1377
+ (0, __WEBPACK_EXTERNAL_MODULE_inversify__.injectable)(),
1378
+ file_system_utility_ts_param(0, (0, __WEBPACK_EXTERNAL_MODULE_inversify__.inject)(TYPES.FileSystemPort)),
1379
+ file_system_utility_ts_metadata("design:type", Function),
1380
+ file_system_utility_ts_metadata("design:paramtypes", [
1381
+ "undefined" == typeof FileSystemPort ? Object : FileSystemPort
1382
+ ])
1383
+ ], file_system_utility_FileSystemUtility);
1384
+ const container = new __WEBPACK_EXTERNAL_MODULE_inversify__.Container();
1385
+ container.bind(TYPES.ProjectRepository).to(FileSystemProjectRepository).inSingletonScope();
1386
+ container.bind(TYPES.PackageRepository).to(FileSystemPackageRepository).inSingletonScope();
1387
+ container.bind(TYPES.PackageInfoService).to(NodePackageInfoService).inSingletonScope();
1388
+ container.bind(TYPES.DependencyConfigService).to(DependencyConfigService).inSingletonScope();
1389
+ container.bind(TYPES.ConfigService).to(ConfigService).inSingletonScope();
1390
+ container.bind(TYPES.FileSystemPort).to(NodeFileSystemAdapter).inSingletonScope();
1391
+ container.bind(TYPES.CommandExecutorPort).to(NodeCommandExecutorAdapter).inSingletonScope();
1392
+ container.bind(TYPES.PromptPort).to(NodePromptAdapter).inSingletonScope();
1393
+ container.bind(TYPES.AnalysisPort).to(TsMorphAnalysisAdapter).inSingletonScope();
1394
+ container.bind(TYPES.CreateProjectUseCase).to(create_project_use_case_CreateProjectUseCase).inSingletonScope();
1395
+ container.bind(TYPES.UpdateExportsUseCase).to(update_exports_use_case_UpdateExportsUseCase).inSingletonScope();
1396
+ container.bind(TYPES.CreateProjectCommand).to(CreateProjectCommand).inSingletonScope();
1397
+ container.bind(TYPES.UpdateExportsCommand).to(UpdateExportsCommand).inSingletonScope();
1398
+ container.bind(TYPES.CLIAdapter).to(CLIAdapter).inSingletonScope();
1399
+ container.bind(TYPES.FileSystemUtility).to(file_system_utility_FileSystemUtility).inSingletonScope();
919
1400
  function main() {
920
- const program = new __WEBPACK_EXTERNAL_MODULE_commander__.Command();
921
- program.name("codefast").description("CodeFast CLI - A development toolkit for CodeFast.").version(getPackageVersion(), "-v, --version", "display CLI version");
922
- createUpdateExportsCommand(program);
923
- createProjectCommand(program);
924
- program.action(()=>{
925
- console.log('Use "codefast create-project" to create a new Next.js project.');
926
- console.log('Use "codefast update-exports" to update exports.');
927
- console.log('Run "codefast --help" to see all available commands.');
928
- program.help();
929
- });
930
- program.parse(process.argv);
1401
+ const cliAdapter = container.get(TYPES.CLIAdapter);
1402
+ cliAdapter.initialize();
931
1403
  }
932
1404
  main();
933
1405