@codefast/cli 0.2.46-canary.6

package/src/commands/update-exports/generate-exports.ts

@@ -0,0 +1,74 @@
+import type { ImportPath, PackageExports, ScriptConfig } from "@/commands/update-exports/types";
+
+import { getPackageConfig } from "@/commands/update-exports/config";
+
+/**
+ * Formats an output path based on a pattern, directory, and name
+ * @param pattern - Output pattern
+ * @param directory - Directory path
+ * @param name - Module name
+ * @returns Formatted output path
+ */
+function formatOutputPath(pattern: string, directory: string, name: string): string {
+  const dirPart = directory === "." ? "" : `${directory}/`;
+
+  return pattern.replace("{dir}/", dirPart).replace("{dir}", directory).replace("{name}", name);
+}
+
+/**
+ * Generates export structure for package.json
+ * @param packageName - Name of the package
+ * @param imports - Analyzed import paths
+ * @param existingExports - Current exports to preserve
+ * @param config - Optional ScriptConfig
+ * @returns Updated PackageExports
+ */
+export function generateExports(
+  packageName: string,
+  imports: ImportPath[],
+  existingExports: PackageExports = {},
+  config?: ScriptConfig,
+): PackageExports {
+  const packageConfig = getPackageConfig(packageName, config);
+
+  const exports: PackageExports = {
+    ".": existingExports["."] ?? {
+      import: {
+        types: "./dist/types/index.d.ts",
+        default: "./dist/esm/index.js",
+      },
+      require: {
+        types: "./dist/types/index.d.cts",
+        default: "./dist/cjs/index.cjs",
+      },
+    },
+  };
+
+  // Preserve existing CSS exports
+  if (existingExports["./styles.css"]) {
+    exports["./styles.css"] = existingExports["./styles.css"];
+  }
+
+  // Generate exports for each import path
+  for (const importPath of imports) {
+    const { directory, name, exportPath } = importPath;
+
+    const esmOutput = formatOutputPath(packageConfig.esmOutputPattern, directory, name);
+    const cjsOutput = formatOutputPath(packageConfig.cjsOutputPattern, directory, name);
+    const typesOutput = formatOutputPath(packageConfig.typesOutputPattern, directory, name);
+    const typesCjsOutput = formatOutputPath(packageConfig.typesOutputCjsPattern, directory, name);
+
+    exports[exportPath] = {
+      import: {
+        types: typesOutput,
+        default: esmOutput,
+      },
+      require: {
+        types: typesCjsOutput,
+        default: cjsOutput,
+      },
+    };
+  }
+
+  return exports;
+}

package/src/commands/update-exports/index.ts

@@ -0,0 +1 @@
+export { createUpdateExportsCommand } from "@/commands/update-exports/command";

package/src/commands/update-exports/process-package.ts

@@ -0,0 +1,164 @@
+import { glob } from "glob";
+import path from "node:path";
+
+import type { ProcessOptions, ScriptConfig } from "@/commands/update-exports/types";
+import type { Logger } from "@/lib/logger";
+
+import { analyzeImports } from "@/commands/update-exports/analyze-imports";
+import { getConfig, getPackageConfig } from "@/commands/update-exports/config";
+import {
+  backupPackageJson,
+  fileExists,
+  readPackageJson,
+  saveExportsAnalysis,
+  saveExportsPreview,
+  savePackageJson,
+} from "@/commands/update-exports/file-utils";
+import { generateExports } from "@/commands/update-exports/generate-exports";
+
+const DEFAULT_IGNORE_PATTERN = ["**/node_modules/**"];
+
+/**
+ * Finds all package.json files in the workspace
+ * @param config - Optional ScriptConfig
+ * @returns Array of package.json paths
+ */
+export async function findAllPackages(config?: ScriptConfig): Promise<string[]> {
+  const configObj = config ?? getConfig();
+
+  return await glob(configObj.packagesGlob, {
+    ignore: DEFAULT_IGNORE_PATTERN,
+  });
+}
+
+/**
+ * Processes a single package
+ * @param packageJsonPath - Path to package.json
+ * @param options - Processing options
+ * @param logger - Logger instance
+ * @returns True if processing was successful
+ */
+export function processPackage(packageJsonPath: string, options: ProcessOptions, logger: Logger): boolean {
+  const packageDir = path.dirname(packageJsonPath);
+  const packageJson = readPackageJson(packageJsonPath);
+
+  if (!packageJson) {
+    logger.error(`Failed to read ${packageJsonPath}`);
+
+    return false;
+  }
+
+  const packageName = packageJson.name;
+
+  // Skip if package doesn't match filter
+  if (options.packageFilter && packageName !== options.packageFilter) {
+    logger.debug(`Skipping ${packageName} (does not match filter)`);
+
+    return false;
+  }
+
+  logger.info(`\n📦 Processing package: ${packageName}`);
+
+  const config = getConfig(options.configPath);
+  const packageConfig = getPackageConfig(packageName, config);
+  const srcIndexPath = path.join(packageDir, packageConfig.srcIndexPath);
+
+  if (!fileExists(srcIndexPath)) {
+    logger.error(`Source file not found at ${srcIndexPath}`);
+
+    return false;
+  }
+
+  // Analyze imports
+  logger.info(`🔍 Analyzing imports from ${srcIndexPath}...`);
+  const { imports } = analyzeImports(srcIndexPath, packageConfig);
+
+  if (imports.length === 0) {
+    logger.warn(`No imports found to analyze in ${packageName}`);
+
+    return false;
+  }
+
+  logger.success(`Analysis complete. Found ${imports.length} subpath exports.`);
+
+  // Save analysis results
+  saveExportsAnalysis(packageDir, { imports });
+
+  // Generate new exports
+  const newExports = generateExports(packageName, imports, packageJson.exports, config);
+
+  // Compare export counts
+  const currentExportsCount = packageJson.exports ? Object.keys(packageJson.exports).length : 0;
+  const newExportsCount = Object.keys(newExports).length;
+
+  logger.info(`📊 Exports: ${currentExportsCount} -> ${newExportsCount}`);
+
+  if (options.dryRun) {
+    saveExportsPreview(packageDir, newExports);
+    logger.warn(`🧪 📄 Saved exports preview to .exports-analysis`);
+    logger.warn(`🧪 🚫 Dry run: no changes saved for ${packageName}`);
+
+    return true;
+  }
+
+  // Backup package.json
+  if (backupPackageJson(packageJsonPath)) {
+    logger.success(`Backed up ${packageJsonPath}`);
+  }
+
+  // Update package.json
+  const updatedPackageJson = { ...packageJson, exports: newExports };
+
+  if (savePackageJson(packageJsonPath, updatedPackageJson)) {
+    logger.success(`Updated exports for ${packageName}`);
+
+    return true;
+  }
+
+  logger.error(`Failed to update ${packageJsonPath}`);
+
+  return false;
+}
+
+/**
+ * Processes all packages in the workspace
+ * @param options - Processing options
+ * @param logger - Logger instance
+ */
+export async function processAllPackages(options: ProcessOptions, logger: Logger): Promise<void> {
+  try {
+    logger.info("🔍 Searching for packages...");
+    const config = getConfig(options.configPath);
+    const packageJsonPaths = await findAllPackages(config);
+
+    if (packageJsonPaths.length === 0) {
+      logger.warn("⚠️ No packages found.");
+
+      return;
+    }
+
+    logger.success(`✅ Found ${packageJsonPaths.length} packages.`);
+
+    let successCount = 0;
+    let skipCount = 0;
+    let errorCount = 0;
+
+    for (const packageJsonPath of packageJsonPaths) {
+      const result = processPackage(packageJsonPath, options, logger);
+
+      if (result) {
+        successCount++;
+      } else if (options.packageFilter) {
+        skipCount++;
+      } else {
+        errorCount++;
+      }
+    }
+
+    logger.success("\n✅ Completed exports update.");
+    logger.info(`📊 Stats: ${successCount} succeeded, ${skipCount} skipped, ${errorCount} failed`);
+  } catch (error) {
+    logger.error("❌ Error processing packages:", error);
+    throw error;
+  }
+}

package/src/commands/update-exports/types.ts

@@ -0,0 +1,94 @@
+import { z } from "zod";
+
+// Schema for package configuration, defining output patterns and paths
+export const PackageConfigSchema = z.interface({
+  // Output path pattern for CommonJS (CJS) modules
+  // Example: "dist/cjs/*.js" specifies where CJS files are emitted
+  cjsOutputPattern: z.string(),
+  // Output path pattern for ES Modules (ESM)
+  // Example: "dist/esm/*.js" specifies where ESM files are emitted
+  esmOutputPattern: z.string(),
+  // Path to the package.json file
+  // Used to read or update package metadata (e.g., version, exports)
+  packageJsonPath: z.string(),
+  // Path to the src/index.ts file
+  // Main entry point for analyzing exports or building the package
+  srcIndexPath: z.string(),
+  // Output path pattern for CJS type definitions
+  // Example: "dist/cjs/*.d.ts" for CJS-compatible type definitions
+  typesOutputCjsPattern: z.string(),
+  // General output path pattern for type definitions
+  // Example: "dist/types/*.d.ts" for type definitions used by both CJS and ESM
+  typesOutputPattern: z.string(),
+  // Optional prefixes to strip from export paths
+  // Example: ["components"] removes "components" from export paths
+  "exportPathPrefixesToRemove?": z.array(z.string()),
+});
+
+// Schema for script configuration, defining package discovery and defaults
+export const ScriptConfigSchema = z.interface({
+  // Custom configurations for specific packages
+  // Key is the package name, value is a partial override of defaultPackageConfig
+  // Example: { "my-package": { cjsOutputPattern: "dist/custom/*.js" } }
+  customPackageConfigs: z.record(z.string(), PackageConfigSchema.partial()),
+  // Default configuration applied to all packages
+  // Ensures consistent settings unless overridden
+  defaultPackageConfig: PackageConfigSchema,
+  // Glob pattern to locate packages in the project
+  // Example: "packages/*" finds all package folders under packages/
+  packagesGlob: z.string(),
+});
+
+// TypeScript type inferred from schemas for type safety
+export type PackageConfig = z.infer<typeof PackageConfigSchema>;
+export type ScriptConfig = z.infer<typeof ScriptConfigSchema>;
+
+// Interface for import path metadata
+export interface ImportPath {
+  // Directory containing the module (e.g., 'components')
+  directory: string;
+  // Export path for package.json (e.g., './button')
+  exportPath: string;
+  // Module name (e.g., 'Button')
+  name: string;
+  // Original import path (e.g., './components/Button')
+  originalPath: string;
+}
+
+// Interface for import analysis results
+export interface AnalysisResult {
+  // List of analyzed import paths
+  imports: ImportPath[];
+}
+
+// Interface for module export configuration
+export interface ExportConfig {
+  import: {
+    default: string; // ESM default file (e.g., "./dist/esm/index.js")
+    types: string; // ESM type definitions (e.g., "./dist/types/index.d.ts")
+  };
+  require: {
+    default: string; // CJS default file (e.g., "./dist/cjs/index.cjs")
+    types: string; // CJS type definitions (e.g., "./dist/types/index.d.cts")
+  };
+}
+
+export type ExportTarget = ExportConfig | string;
+export type PackageExports = Record<string, ExportTarget>;
+
+// Interface for package.json structure
+export interface PackageJson {
+  [key: string]: unknown;
+  name: string;
+  version: string;
+
+  exports?: PackageExports;
+}
+
+// Options for processing packages
+export interface ProcessOptions {
+  dryRun: boolean;
+  verbose: boolean;
+  configPath?: string;
+  packageFilter?: string;
+}

package/src/index.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+
+import { createUpdateExportsCommand } from "@/commands/update-exports";
+
+import packageJson from "../package.json";
+
+function main(): void {
+  const program = new Command();
+
+  program
+    .name("codefast")
+    .description("CodeFast CLI - A development toolkit for CodeFast.")
+    .version(packageJson.version, "-v, --version", "display CLI version");
+
+  createUpdateExportsCommand(program);
+
+  program.action(() => {
+    console.log('Use "codefast update-exports" to update exports.');
+    console.log('Run "codefast --help" to see all available commands.');
+    program.help();
+  });
+
+  program.parse(process.argv);
+}
+
+main();

package/src/lib/logger.ts

@@ -0,0 +1,39 @@
+import chalk from "chalk";
+
+interface LoggerOptions {
+  verbose?: boolean;
+}
+
+export class Logger {
+  private readonly verbose: boolean;
+
+  constructor(options: LoggerOptions = {}) {
+    this.verbose = options.verbose ?? false;
+  }
+
+  info(message: string, ...args: any[]): void {
+    console.log(chalk.blue(message), ...args);
+  }
+
+  success(message: string, ...args: any[]): void {
+    console.log(chalk.green(message), ...args);
+  }
+
+  warn(message: string, ...args: any[]): void {
+    console.log(chalk.yellow(message), ...args);
+  }
+
+  error(message: string, ...args: any[]): void {
+    console.error(chalk.red(message), ...args);
+  }
+
+  debug(message: string, ...args: any[]): void {
+    if (this.verbose) {
+      console.log(chalk.gray(message), ...args);
+    }
+  }
+
+  table(data: any[]): void {
+    console.table(data);
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", ".turbo", "coverage", "/**/*.test.*", "**/*.spec.*"]
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "@codefast/typescript-config/library.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "esModuleInterop": true,
+    "outDir": "dist",
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+    "resolveJsonModule": true
+  },
+  "include": ["**/*.ts", "**/*.tsx"],
+  "exclude": ["node_modules", "dist", ".turbo", "coverage"]
+}