@codefast/cli 0.2.46-canary.6

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

@@ -0,0 +1,83 @@
+import { z } from "zod";
+export declare const PackageConfigSchema: z.ZodInterface<{
+    cjsOutputPattern: z.ZodString;
+    esmOutputPattern: z.ZodString;
+    packageJsonPath: z.ZodString;
+    srcIndexPath: z.ZodString;
+    typesOutputCjsPattern: z.ZodString;
+    typesOutputPattern: z.ZodString;
+    exportPathPrefixesToRemove: z.ZodArray<z.ZodString>;
+}, {
+    optional: "exportPathPrefixesToRemove";
+    defaulted: never;
+    extra: {};
+}>;
+export declare const ScriptConfigSchema: z.ZodInterface<{
+    customPackageConfigs: z.ZodRecord<z.ZodString, z.ZodInterface<{
+        cjsOutputPattern: z.ZodOptional<z.ZodString>;
+        esmOutputPattern: z.ZodOptional<z.ZodString>;
+        packageJsonPath: z.ZodOptional<z.ZodString>;
+        srcIndexPath: z.ZodOptional<z.ZodString>;
+        typesOutputCjsPattern: z.ZodOptional<z.ZodString>;
+        typesOutputPattern: z.ZodOptional<z.ZodString>;
+        exportPathPrefixesToRemove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, {
+        optional: "cjsOutputPattern" | "esmOutputPattern" | "packageJsonPath" | "srcIndexPath" | "typesOutputCjsPattern" | "typesOutputPattern" | "exportPathPrefixesToRemove";
+        defaulted: never;
+        extra: {};
+    }>>;
+    defaultPackageConfig: z.ZodInterface<{
+        cjsOutputPattern: z.ZodString;
+        esmOutputPattern: z.ZodString;
+        packageJsonPath: z.ZodString;
+        srcIndexPath: z.ZodString;
+        typesOutputCjsPattern: z.ZodString;
+        typesOutputPattern: z.ZodString;
+        exportPathPrefixesToRemove: z.ZodArray<z.ZodString>;
+    }, {
+        optional: "exportPathPrefixesToRemove";
+        defaulted: never;
+        extra: {};
+    }>;
+    packagesGlob: z.ZodString;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>;
+export type PackageConfig = z.infer<typeof PackageConfigSchema>;
+export type ScriptConfig = z.infer<typeof ScriptConfigSchema>;
+export interface ImportPath {
+    directory: string;
+    exportPath: string;
+    name: string;
+    originalPath: string;
+}
+export interface AnalysisResult {
+    imports: ImportPath[];
+}
+export interface ExportConfig {
+    import: {
+        default: string;
+        types: string;
+    };
+    require: {
+        default: string;
+        types: string;
+    };
+}
+export type ExportTarget = ExportConfig | string;
+export type PackageExports = Record<string, ExportTarget>;
+export interface PackageJson {
+    [key: string]: unknown;
+    name: string;
+    version: string;
+    exports?: PackageExports;
+}
+export interface ProcessOptions {
+    dryRun: boolean;
+    verbose: boolean;
+    configPath?: string;
+    packageFilter?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/src/commands/update-exports/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/commands/update-exports/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAsB9B,CAAC;AAGH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW7B,CAAC;AAGH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAG9D,MAAM,WAAW,UAAU;IAEzB,SAAS,EAAE,MAAM,CAAC;IAElB,UAAU,EAAE,MAAM,CAAC;IAEnB,IAAI,EAAE,MAAM,CAAC;IAEb,YAAY,EAAE,MAAM,CAAC;CACtB;AAGD,MAAM,WAAW,cAAc;IAE7B,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB;AAGD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE;QACN,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,OAAO,EAAE;QACP,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;CACH;AAED,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,MAAM,CAAC;AACjD,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AAG1D,MAAM,WAAW,WAAW;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAEhB,OAAO,CAAC,EAAE,cAAc,CAAC;CAC1B;AAGD,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB"}

package/dist/types/src/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":""}

package/dist/types/src/lib/logger.d.ts

@@ -0,0 +1,15 @@
+interface LoggerOptions {
+    verbose?: boolean;
+}
+export declare class Logger {
+    private readonly verbose;
+    constructor(options?: LoggerOptions);
+    info(message: string, ...args: any[]): void;
+    success(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+    table(data: any[]): void;
+}
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/types/src/lib/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../../src/lib/logger.ts"],"names":[],"mappings":"AAEA,UAAU,aAAa;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;gBAEtB,OAAO,GAAE,aAAkB;IAIvC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAI3C,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAI9C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAI3C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAI5C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAM5C,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;CAGzB"}

package/eslint.config.js

@@ -0,0 +1,18 @@
+import { config } from "@codefast/eslint-config/library";
+
+/** @type {import('eslint').Linter.Config[]} */
+export default [
+  ...config,
+  {
+    rules: {
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-non-null-assertion": "off",
+      "@typescript-eslint/no-redundant-type-constituents": "off",
+      "@typescript-eslint/no-unsafe-argument": "off",
+      "@typescript-eslint/no-unsafe-assignment": "off",
+      "@typescript-eslint/no-unsafe-member-access": "off",
+      "@typescript-eslint/no-unsafe-return": "off",
+      "no-console": "off",
+    },
+  },
+];

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@codefast/cli",
+  "version": "0.2.46-canary.6",
+  "description": "CodeFast CLI - A development toolkit for CodeFast.",
+  "bugs": {
+    "url": "https://github.com/codefastlabs/codefast/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/codefastlabs/codefast.git",
+    "directory": "packages/cli"
+  },
+  "license": "MIT",
+  "author": "Vuong Phan <mr.thevuong@gmail.com>",
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "bin": {
+    "codefast": "./dist/esm/index.js"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "glob": "^11.0.1",
+    "lodash-es": "^4.17.21",
+    "ts-morph": "^25.0.1",
+    "zod": "4.0.0-beta.20250414T061543"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.6.3",
+    "@types/commander": "^2.12.5",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^22.14.1",
+    "eslint": "^9.24.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3",
+    "@codefast/eslint-config": "0.2.46-canary.6",
+    "@codefast/typescript-config": "0.2.46-canary.6"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "check-types": "tsc --noEmit",
+    "clean": "rimraf node_modules dist",
+    "dev": "rslib build --watch",
+    "lint": "eslint --max-warnings 0",
+    "lint:inspect": "npx @eslint/config-inspector@latest"
+  }
+}

package/rslib.config.ts

@@ -0,0 +1,40 @@
+import { defineConfig } from "@rslib/core";
+
+export default defineConfig({
+  lib: [
+    {
+      bundle: false,
+      dts: {
+        distPath: "./dist/types",
+      },
+      format: "esm",
+      output: {
+        distPath: {
+          root: "./dist/esm",
+        },
+      },
+    },
+    {
+      bundle: false,
+      format: "cjs",
+      output: {
+        distPath: {
+          root: "./dist/cjs",
+        },
+      },
+    },
+  ],
+  output: {
+    sourceMap: true,
+  },
+  performance: {
+    buildCache: true,
+    printFileSize: false,
+  },
+  source: {
+    entry: {
+      index: ["./src/**/*.{ts,tsx}", "!./src/**/*.{test,spec}.{ts,tsx}"],
+    },
+    tsconfigPath: "./tsconfig.build.json",
+  },
+});

package/src/commands/update-exports/analyze-imports.ts

@@ -0,0 +1,112 @@
+import type { SourceFile } from "ts-morph";
+
+import { Project } from "ts-morph";
+
+import type { AnalysisResult, ImportPath, PackageConfig } from "@/commands/update-exports/types";
+
+/**
+ * Creates a regex to remove specified prefixes from paths
+ * @param prefixes - Array of prefixes to remove
+ * @returns RegExp matching any prefix
+ */
+function makeRegexPrefixesToRemove(prefixes: string[]): RegExp {
+  // Matches: ^\.?\/?(prefix1|prefix2)\/(.*)
+  // - ^\.?\/?          : Optional ./ or /
+  // - (prefix1|prefix2): Any prefix from the list
+  // - \/(.*)           : Remaining path after prefix
+  const prefixPattern = prefixes.join("|");
+
+  return new RegExp(`^.?\\/?(?:${prefixPattern})\\/(.*)$`);
+}
+
+/**
+ * Processes an export path by removing specified prefixes
+ * @param modulePath - Path to process
+ * @param regexPattern - Regex for prefix removal
+ * @returns Processed path starting with ./
+ */
+function processExportPath(modulePath: string, regexPattern: RegExp): string {
+  let processedPath = modulePath;
+  const match = processedPath.match(regexPattern);
+
+  if (match) {
+    const remainingPath = match[1];
+
+    processedPath = remainingPath.startsWith("./") ? remainingPath : `./${remainingPath}`;
+  }
+
+  return processedPath;
+}
+
+/**
+ * Analyzes imports from an index.ts file
+ * @param indexFilePath - Path to index.ts
+ * @param packageConfig - Package configuration
+ * @returns AnalysisResult containing import paths
+ */
+export function analyzeImports(indexFilePath: string, packageConfig: PackageConfig): AnalysisResult {
+  const project = new Project();
+  let sourceFile: SourceFile;
+
+  try {
+    sourceFile = project.addSourceFileAtPath(indexFilePath);
+  } catch (error) {
+    console.error(`Error loading source file at ${indexFilePath}:`, error);
+
+    return { imports: [] };
+  }
+
+  const imports: ImportPath[] = [];
+  const prefixesToRemove = packageConfig.exportPathPrefixesToRemove ?? [];
+  const regexPattern = makeRegexPrefixesToRemove(prefixesToRemove);
+
+  for (const exportDecl of sourceFile.getExportDeclarations()) {
+    let moduleSpecifier = exportDecl.getModuleSpecifierValue();
+
+    if (!moduleSpecifier) {
+      continue;
+    }
+
+    // Normalize @/ to ./
+    if (moduleSpecifier.startsWith("@/")) {
+      moduleSpecifier = `./${moduleSpecifier.slice(2)}`;
+    }
+
+    const isExternal = !moduleSpecifier.startsWith(".");
+
+    if (isExternal) {
+      continue;
+    }
+
+    const parts = moduleSpecifier.split("/").filter(Boolean);
+
+    if (parts.length < 2) {
+      continue;
+    }
+
+    let directory;
+
+    if (parts.length <= 1) {
+      directory = ".";
+    } else {
+      directory = parts.slice(0, -1).join("/");
+
+      if (directory.startsWith("./")) {
+        directory = directory.slice(2);
+      }
+    }
+
+    const name = parts.at(-1) ?? "";
+
+    const importPath: ImportPath = {
+      originalPath: moduleSpecifier,
+      directory,
+      name,
+      exportPath: processExportPath(moduleSpecifier, regexPattern),
+    };
+
+    imports.push(importPath);
+  }
+
+  return { imports };
+}

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

@@ -0,0 +1,38 @@
+import type { Command } from "commander";
+
+import type { ProcessOptions } from "@/commands/update-exports/types";
+
+import { processAllPackages } from "@/commands/update-exports/process-package";
+import { Logger } from "@/lib/logger";
+
+/**
+ * Creates a commander command for updating exports
+ * @param program - Commander program instance
+ */
+export function createUpdateExportsCommand(program: Command): void {
+  // noinspection RequiredAttributes
+  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("-v, --verbose", "Show detailed output")
+    .option("-c, --config <path>", "Path to configuration file")
+    .action(async (options) => {
+      const processorOptions: ProcessOptions = {
+        packageFilter: options.package,
+        dryRun: Boolean(options.dryRun),
+        verbose: Boolean(options.verbose),
+        configPath: options.config,
+      };
+
+      const logger = new Logger({ verbose: processorOptions.verbose });
+
+      try {
+        await processAllPackages(processorOptions, logger);
+      } catch (error) {
+        logger.error("Error processing packages:", error);
+        process.exit(1);
+      }
+    });
+}

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

@@ -0,0 +1,99 @@
+import { merge } from "lodash-es";
+import fs from "node:fs";
+import path from "node:path";
+
+import type { PackageConfig, ScriptConfig } from "@/commands/update-exports/types";
+
+import { ScriptConfigSchema } from "@/commands/update-exports/types";
+
+// Cache for storing configuration to avoid repeated file reads
+let cachedConfig: null | ScriptConfig = null;
+
+/**
+ * Loads and validates configuration from a file
+ * @param configPath - Optional path to the config file
+ * @returns Partial ScriptConfig or empty object if not found/invalid
+ */
+function loadConfigFile(configPath?: string): Partial<ScriptConfig> {
+  if (!configPath) {
+    return {};
+  }
+
+  try {
+    const fullPath = path.resolve(configPath);
+
+    if (!fs.existsSync(fullPath)) {
+      console.warn(`Configuration file not found at ${fullPath}`);
+
+      return {};
+    }
+
+    const configContent = fs.readFileSync(fullPath, "utf8");
+    const config = JSON.parse(configContent);
+
+    // Validate against schema
+    return ScriptConfigSchema.parse(config);
+  } catch (error) {
+    console.error("Error reading configuration file:", error);
+
+    return {};
+  }
+}
+
+/**
+ * Retrieves merged configuration, using cache if no path is provided
+ * @param configPath - Optional path to override default config
+ * @returns Merged ScriptConfig
+ */
+export function getConfig(configPath?: string): ScriptConfig {
+  if (cachedConfig && !configPath) {
+    return cachedConfig;
+  }
+
+  const userConfig = loadConfigFile(configPath);
+  const config = merge({}, defaultConfig, userConfig) as ScriptConfig;
+
+  // Cache config if no path is provided
+  if (!configPath) {
+    cachedConfig = config;
+  }
+
+  return config;
+}
+
+/**
+ * Retrieves configuration for a specific package
+ * @param packageName - Name of the package
+ * @param config - Optional ScriptConfig to use
+ * @returns PackageConfig combining defaults and custom settings
+ */
+export function getPackageConfig(packageName: string, config?: ScriptConfig): PackageConfig {
+  const configObj = config ?? getConfig();
+  const customConfig = configObj.customPackageConfigs[packageName] ?? {};
+
+  return {
+    ...configObj.defaultPackageConfig,
+    ...customConfig,
+  };
+}
+
+// Default configuration for the script
+export const defaultConfig: ScriptConfig = {
+  packagesGlob: "./packages/**/package.json",
+  defaultPackageConfig: {
+    cjsOutputPattern: "./dist/cjs/{dir}/{name}.cjs",
+    esmOutputPattern: "./dist/esm/{dir}/{name}.js",
+    packageJsonPath: "package.json",
+    srcIndexPath: "src/index.ts",
+    typesOutputCjsPattern: "./dist/types/{dir}/{name}.d.ts",
+    typesOutputPattern: "./dist/types/{dir}/{name}.d.ts",
+  },
+  customPackageConfigs: {
+    "@codefast/ui": {
+      exportPathPrefixesToRemove: ["components"],
+    },
+    "@codefast/style-guide": {
+      exportPathPrefixesToRemove: ["configs"],
+    },
+  },
+};

package/src/commands/update-exports/file-utils.ts

@@ -0,0 +1,178 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import type { AnalysisResult, PackageExports, PackageJson } from "@/commands/update-exports/types";
+
+// Constants for file operations
+const EXPORTS_ANALYSIS_DIR = ".exports-analysis";
+const EXPORTS_PREVIEW_FILE = "exports-preview.json";
+const EXPORTS_ANALYSIS_FILE = "exports-analysis.json";
+const ENCODING = "utf8";
+const JSON_INDENT = 2;
+/**
+ * Utility functions for file and directory operations
+ */
+const FileUtils = {
+  /**
+   * Checks if a file exists
+   * @param filePath - Path to check
+   * @returns True if a file exists
+   */
+  exists(filePath: string): boolean {
+    return fs.existsSync(filePath);
+  },
+
+  /**
+   * Creates a directory if it doesn't exist
+   * @param dirPath - Directory path
+   */
+  ensureDirectoryExists(dirPath: string): void {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+  },
+
+  /**
+   * Reads and parses a JSON file
+   * @param filePath - Path to JSON file
+   * @returns Parsed content or null if error
+   */
+  readJsonFile<T>(filePath: string): null | T {
+    try {
+      const content = fs.readFileSync(filePath, ENCODING);
+
+      return JSON.parse(content) as T;
+    } catch (error) {
+      console.error(`Error reading JSON file at ${filePath}:`, error);
+
+      return null;
+    }
+  },
+
+  /**
+   * Writes content to a JSON file
+   * @param filePath - Path to write
+   * @param content - Content to write
+   * @returns True if successful
+   */
+  writeJsonFile<T>(filePath: string, content: T): boolean {
+    try {
+      fs.writeFileSync(filePath, `${JSON.stringify(content, null, JSON_INDENT)}\n`, ENCODING);
+
+      return true;
+    } catch (error) {
+      console.error(`Error writing JSON file at ${filePath}:`, error);
+
+      return false;
+    }
+  },
+
+  /**
+   * Gets the exports analysis directory path
+   * @param packageDir - Package directory
+   * @returns Analysis directory path
+   */
+  getAnalysisDir(packageDir: string): string {
+    const outputDir = path.join(packageDir, EXPORTS_ANALYSIS_DIR);
+
+    this.ensureDirectoryExists(outputDir);
+
+    return outputDir;
+  },
+
+  /**
+   * Creates a timestamped backup filename
+   * @param baseFilename - Original filename
+   * @returns Backup filename with timestamp
+   */
+  createBackupFilename(baseFilename: string): string {
+    const timestamp = new Date().toISOString().replaceAll(/[:.]/g, "-");
+
+    return `${baseFilename}.backup.${timestamp}`;
+  },
+};
+
+/**
+ * Checks if a file exists
+ * @param filePath - Path to check
+ * @returns True if a file exists
+ */
+export function fileExists(filePath: string): boolean {
+  return FileUtils.exists(filePath);
+}
+
+/**
+ * Reads and parses package.json content
+ * @param filePath - Path to package.json
+ * @returns Parsed PackageJson or null if error
+ */
+export function readPackageJson(filePath: string): null | PackageJson {
+  return FileUtils.readJsonFile<PackageJson>(filePath);
+}
+
+/**
+ * Creates a backup of package.json
+ * @param filePath - Path to package.json
+ * @returns True if backup was successful
+ */
+export function backupPackageJson(filePath: string): boolean {
+  try {
+    const content = fs.readFileSync(filePath, ENCODING);
+    const dir = path.dirname(filePath);
+    const backupDir = path.join(dir, EXPORTS_ANALYSIS_DIR);
+
+    FileUtils.ensureDirectoryExists(backupDir);
+
+    const baseName = path.basename(filePath);
+    const backupPath = path.join(backupDir, FileUtils.createBackupFilename(baseName));
+
+    fs.writeFileSync(backupPath, content, ENCODING);
+
+    return true;
+  } catch (error) {
+    console.error(`Error backing up package.json at ${filePath}:`, error);
+
+    return false;
+  }
+}
+
+/**
+ * Saves updated package.json content
+ * @param filePath - Path to package.json
+ * @param content - Updated content
+ * @returns True if save was successful
+ */
+export function savePackageJson(filePath: string, content: PackageJson): boolean {
+  return FileUtils.writeJsonFile(filePath, content);
+}
+
+/**
+ * Saves the given JSON content to a specified file within the analysis directory.
+ *
+ * @param packageDir - The root directory where the analysis directory resides.
+ * @param fileName - The name of the file to which the JSON content will be written.
+ * @param content - The JSON content to save to the file.
+ */
+export function saveJsonToFile<T>(packageDir: string, fileName: string, content: T): void {
+  const outputDir = FileUtils.getAnalysisDir(packageDir);
+
+  FileUtils.writeJsonFile(path.join(outputDir, fileName), content);
+}
+
+/**
+ * Saves exports analysis results
+ * @param packageDir - Package directory
+ * @param analysis - Analysis results
+ */
+export function saveExportsAnalysis(packageDir: string, analysis: AnalysisResult): void {
+  saveJsonToFile(packageDir, EXPORTS_ANALYSIS_FILE, analysis);
+}
+
+/**
+ * Saves preview of generated exports
+ * @param packageDir - Package directory
+ * @param exports - Generated exports
+ */
+export function saveExportsPreview(packageDir: string, exports: PackageExports): void {
+  saveJsonToFile(packageDir, EXPORTS_PREVIEW_FILE, exports);
+}