algolia-codegen 0.1.3 → 0.1.4

package/README.md

@@ -149,7 +149,15 @@ After installation, you can use the CLI command:
 algolia-codegen
 ```
 
-Or specify a custom config file:
+#### Options
+
+- `-c, --config <path>` - Specify a custom config file path
+- `-v, --verbose` - Enable verbose output (shows detailed logging)
+- `--dry-run` - Simulate execution without writing files (useful for testing)
+
+#### Examples
+
+Specify a custom config file:
 
 ```bash
 algolia-codegen --config path/to/config.ts
@@ -157,6 +165,26 @@ algolia-codegen --config path/to/config.ts
 algolia-codegen -c path/to/config.ts
 ```
 
+Enable verbose output:
+
+```bash
+algolia-codegen --verbose
+# or
+algolia-codegen -v
+```
+
+Run in dry-run mode (no files will be written):
+
+```bash
+algolia-codegen --dry-run
+```
+
+Combine options:
+
+```bash
+algolia-codegen --config custom-config.ts --verbose --dry-run
+```
+
 Or if installed locally:
 
 ```bash
@@ -222,6 +250,7 @@ Each generated file contains all types found in the index, including nested type
 ## Examples
 
 See the [examples directory](./examples/) for comprehensive examples including:
+
 - Framework integrations (Next.js, React, Vue)
 - CI/CD integration (GitHub Actions)
 - Custom prefixes/postfixes

package/dist/{chunk-4T5DZK75.js → chunk-USMYY2DN.js}

@@ -450,27 +450,34 @@ function generateTypeScriptTypes(sampleHit, config) {
 }
 
 // src/utils/fetch-algolia-data.ts
-async function fetchAlgoliaData(filePath, generatorConfig, overwrite) {
-  console.log(`
-Processing file: ${filePath}`);
+async function fetchAlgoliaData(filePath, generatorConfig, overwrite, logger) {
+  logger.info(`Processing file: ${filePath}`);
   const resolvedPath = resolve2(process.cwd(), filePath);
+  logger.verbose(`Resolved path: ${resolvedPath}`);
   if (existsSync2(resolvedPath) && !overwrite) {
     throw new Error(
       `File already exists: ${resolvedPath}
 Set overwrite: true in config to allow overwriting existing files.`
     );
   }
-  console.log(`Connecting to Algolia...`);
-  console.log(`App ID: ${generatorConfig.appId}`);
+  const connectSpinner = logger.spinner("Connecting to Algolia...");
+  connectSpinner.start();
   let client;
   try {
+    logger.verbose(`App ID: ${generatorConfig.appId}`);
+    logger.verbose(`Index: ${generatorConfig.indexName}`);
     client = algoliasearch(generatorConfig.appId, generatorConfig.searchKey);
+    connectSpinner.succeed("Connected to Algolia");
   } catch (error) {
+    connectSpinner.fail("Failed to connect to Algolia");
     throw new Error(
       `Failed to initialize Algolia client: ${error instanceof Error ? error.message : String(error)}`
     );
   }
-  console.log(`Fetching sample record from index: ${generatorConfig.indexName}`);
+  const fetchSpinner = logger.spinner(
+    `Fetching sample record from index: ${generatorConfig.indexName}`
+  );
+  fetchSpinner.start();
   let results;
   try {
     results = await client.search([
@@ -482,7 +489,9 @@ Set overwrite: true in config to allow overwriting existing files.`
         }
       }
     ]);
+    fetchSpinner.succeed("Sample record fetched successfully");
   } catch (error) {
+    fetchSpinner.fail("Failed to fetch data from Algolia");
     let errorMessage;
     if (error instanceof Error) {
       errorMessage = error.message;
@@ -514,52 +523,183 @@ Set overwrite: true in config to allow overwriting existing files.`
     throw new Error(`No hits found in Algolia index: ${generatorConfig.indexName}`);
   }
   const sampleHit = result.hits[0];
-  console.log("Sample record fetched successfully");
-  console.log(`ObjectID: ${sampleHit.objectID || "N/A"}`);
+  logger.verbose(`ObjectID: ${sampleHit.objectID || "N/A"}`);
+  const generateSpinner = logger.spinner("Generating TypeScript types...");
+  generateSpinner.start();
   const fileContent = generateTypeScriptTypes(sampleHit, generatorConfig);
+  generateSpinner.succeed("TypeScript types generated");
   const dir = dirname(resolvedPath);
   if (!existsSync2(dir)) {
-    mkdirSync(dir, { recursive: true });
+    if (!logger.isDryRun) {
+      mkdirSync(dir, { recursive: true });
+      logger.verbose(`Created directory: ${dir}`);
+    } else {
+      logger.dryRun(`Would create directory: ${dir}`);
+    }
+  }
+  if (logger.isDryRun) {
+    logger.dryRun(`Would write file: ${filePath}`);
+    logger.verbose(`File content length: ${fileContent.length} characters`);
+  } else {
+    writeFileSync(resolvedPath, fileContent, "utf-8");
+    logger.success(`Generated file: ${filePath}`);
   }
-  writeFileSync(resolvedPath, fileContent, "utf-8");
-  console.log(`Generated file: ${filePath}`);
 }
 
+// src/utils/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+var Logger = class {
+  _verbose;
+  _dryRun;
+  constructor(options = {}) {
+    this._verbose = options.verbose ?? false;
+    this._dryRun = options.dryRun ?? false;
+  }
+  /**
+   * Check if verbose mode is enabled
+   */
+  get isVerbose() {
+    return this._verbose;
+  }
+  /**
+   * Check if dry-run mode is enabled
+   */
+  get isDryRun() {
+    return this._dryRun;
+  }
+  /**
+   * Log info message (always shown)
+   */
+  info(message) {
+    console.log(chalk.blue("\u2139"), message);
+  }
+  /**
+   * Log success message (always shown)
+   */
+  success(message) {
+    console.log(chalk.green("\u2713"), message);
+  }
+  /**
+   * Log warning message (always shown)
+   */
+  warn(message) {
+    console.log(chalk.yellow("\u26A0"), message);
+  }
+  /**
+   * Log error message (always shown)
+   */
+  error(message) {
+    console.error(chalk.red("\u2717"), message);
+  }
+  /**
+   * Log verbose message (only shown in verbose mode)
+   */
+  verbose(message) {
+    if (this._verbose) {
+      console.log(chalk.gray("\u2192"), message);
+    }
+  }
+  /**
+   * Log dry-run message (only shown in dry-run mode)
+   */
+  dryRun(message) {
+    if (this._dryRun) {
+      console.log(chalk.cyan("[DRY-RUN]"), message);
+    }
+  }
+  /**
+   * Create a spinner for long-running operations
+   */
+  spinner(text) {
+    return ora({
+      text,
+      color: "cyan",
+      spinner: "dots"
+    });
+  }
+  /**
+   * Log file operation (respects dry-run)
+   */
+  fileOperation(action, filePath) {
+    if (this._dryRun) {
+      this.dryRun(`Would ${action}: ${chalk.underline(filePath)}`);
+    } else {
+      this.verbose(`${action}: ${filePath}`);
+    }
+  }
+  /**
+   * Format error with context
+   */
+  formatError(error, context) {
+    let errorMessage = "";
+    if (error instanceof Error) {
+      errorMessage = error.message;
+      if (this._verbose && error.stack) {
+        errorMessage += `
+${chalk.gray(error.stack)}`;
+      }
+    } else if (error && typeof error === "object") {
+      const errorObj = error;
+      if (errorObj.message) {
+        errorMessage = String(errorObj.message);
+      } else if (errorObj.status) {
+        errorMessage = `HTTP ${errorObj.status}: ${errorObj.statusText || "Unknown error"}`;
+      } else {
+        try {
+          errorMessage = JSON.stringify(error, null, 2);
+        } catch {
+          errorMessage = String(error);
+        }
+      }
+    } else {
+      errorMessage = String(error);
+    }
+    if (context) {
+      return `${chalk.red(context)}
+${errorMessage}`;
+    }
+    return errorMessage;
+  }
+};
+var logger_default = Logger;
+
 // src/index.ts
-var main = async (configPath) => {
+var main = async (options) => {
+  const opts = typeof options === "string" ? { configPath: options } : options ?? {};
+  const logger = new logger_default({
+    verbose: opts.verbose ?? false,
+    dryRun: opts.dryRun ?? false
+  });
   try {
-    const config = await loadConfig(configPath);
-    console.log("Config loaded successfully");
+    const configSpinner = logger.spinner("Loading configuration...");
+    configSpinner.start();
+    const config = await loadConfig(opts.configPath);
+    configSpinner.succeed("Configuration loaded successfully");
+    logger.verbose(`Config path: ${opts.configPath || "default"}`);
+    logger.verbose(`Overwrite mode: ${config.overwrite ? "enabled" : "disabled"}`);
     const generatesArray = Array.isArray(config.generates) ? config.generates : [config.generates];
+    logger.verbose(`Found ${generatesArray.length} generate configuration(s)`);
     for (const urlSchema of generatesArray) {
       for (const [filePath, generatorConfig] of Object.entries(urlSchema)) {
         try {
-          await fetchAlgoliaData(filePath, generatorConfig, config.overwrite);
+          await fetchAlgoliaData(filePath, generatorConfig, config.overwrite, logger);
         } catch (error) {
-          console.error(`
-Error processing file: ${filePath}`);
-          if (error instanceof Error) {
-            console.error(error.message);
-            if (error.stack) {
-              console.error(error.stack);
-            }
-          } else {
-            try {
-              console.error(JSON.stringify(error, null, 2));
-            } catch {
-              console.error(String(error));
-            }
-          }
+          logger.error(`Error processing file: ${filePath}`);
+          const errorMessage = logger.formatError(error, "Processing failed");
+          logger.error(errorMessage);
         }
       }
     }
-  } catch (error) {
-    console.error("Error loading config:");
-    if (error instanceof Error) {
-      console.error(error.message);
+    if (opts.dryRun) {
+      logger.info("Dry-run completed. No files were written.");
     } else {
-      console.error(String(error));
+      logger.success("All files generated successfully!");
     }
+  } catch (error) {
+    logger.error("Failed to load configuration");
+    const errorMessage = logger.formatError(error, "Configuration error");
+    logger.error(errorMessage);
     process.exit(1);
   }
 };

package/dist/cli.cjs

@@ -481,27 +481,34 @@ function generateTypeScriptTypes(sampleHit, config) {
 }
 
 // src/utils/fetch-algolia-data.ts
-async function fetchAlgoliaData(filePath, generatorConfig, overwrite) {
-  console.log(`
-Processing file: ${filePath}`);
+async function fetchAlgoliaData(filePath, generatorConfig, overwrite, logger) {
+  logger.info(`Processing file: ${filePath}`);
   const resolvedPath = (0, import_path2.resolve)(process.cwd(), filePath);
+  logger.verbose(`Resolved path: ${resolvedPath}`);
   if ((0, import_fs3.existsSync)(resolvedPath) && !overwrite) {
     throw new Error(
       `File already exists: ${resolvedPath}
 Set overwrite: true in config to allow overwriting existing files.`
     );
   }
-  console.log(`Connecting to Algolia...`);
-  console.log(`App ID: ${generatorConfig.appId}`);
+  const connectSpinner = logger.spinner("Connecting to Algolia...");
+  connectSpinner.start();
   let client;
   try {
+    logger.verbose(`App ID: ${generatorConfig.appId}`);
+    logger.verbose(`Index: ${generatorConfig.indexName}`);
     client = (0, import_algoliasearch.algoliasearch)(generatorConfig.appId, generatorConfig.searchKey);
+    connectSpinner.succeed("Connected to Algolia");
   } catch (error) {
+    connectSpinner.fail("Failed to connect to Algolia");
     throw new Error(
       `Failed to initialize Algolia client: ${error instanceof Error ? error.message : String(error)}`
     );
   }
-  console.log(`Fetching sample record from index: ${generatorConfig.indexName}`);
+  const fetchSpinner = logger.spinner(
+    `Fetching sample record from index: ${generatorConfig.indexName}`
+  );
+  fetchSpinner.start();
   let results;
   try {
     results = await client.search([
@@ -513,7 +520,9 @@ Set overwrite: true in config to allow overwriting existing files.`
         }
       }
     ]);
+    fetchSpinner.succeed("Sample record fetched successfully");
   } catch (error) {
+    fetchSpinner.fail("Failed to fetch data from Algolia");
     let errorMessage;
     if (error instanceof Error) {
       errorMessage = error.message;
@@ -545,52 +554,183 @@ Set overwrite: true in config to allow overwriting existing files.`
     throw new Error(`No hits found in Algolia index: ${generatorConfig.indexName}`);
   }
   const sampleHit = result.hits[0];
-  console.log("Sample record fetched successfully");
-  console.log(`ObjectID: ${sampleHit.objectID || "N/A"}`);
+  logger.verbose(`ObjectID: ${sampleHit.objectID || "N/A"}`);
+  const generateSpinner = logger.spinner("Generating TypeScript types...");
+  generateSpinner.start();
   const fileContent = generateTypeScriptTypes(sampleHit, generatorConfig);
+  generateSpinner.succeed("TypeScript types generated");
   const dir = (0, import_path2.dirname)(resolvedPath);
   if (!(0, import_fs3.existsSync)(dir)) {
-    (0, import_fs3.mkdirSync)(dir, { recursive: true });
+    if (!logger.isDryRun) {
+      (0, import_fs3.mkdirSync)(dir, { recursive: true });
+      logger.verbose(`Created directory: ${dir}`);
+    } else {
+      logger.dryRun(`Would create directory: ${dir}`);
+    }
+  }
+  if (logger.isDryRun) {
+    logger.dryRun(`Would write file: ${filePath}`);
+    logger.verbose(`File content length: ${fileContent.length} characters`);
+  } else {
+    (0, import_fs3.writeFileSync)(resolvedPath, fileContent, "utf-8");
+    logger.success(`Generated file: ${filePath}`);
   }
-  (0, import_fs3.writeFileSync)(resolvedPath, fileContent, "utf-8");
-  console.log(`Generated file: ${filePath}`);
 }
 
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var import_ora = __toESM(require("ora"), 1);
+var Logger = class {
+  _verbose;
+  _dryRun;
+  constructor(options = {}) {
+    this._verbose = options.verbose ?? false;
+    this._dryRun = options.dryRun ?? false;
+  }
+  /**
+   * Check if verbose mode is enabled
+   */
+  get isVerbose() {
+    return this._verbose;
+  }
+  /**
+   * Check if dry-run mode is enabled
+   */
+  get isDryRun() {
+    return this._dryRun;
+  }
+  /**
+   * Log info message (always shown)
+   */
+  info(message) {
+    console.log(import_chalk.default.blue("\u2139"), message);
+  }
+  /**
+   * Log success message (always shown)
+   */
+  success(message) {
+    console.log(import_chalk.default.green("\u2713"), message);
+  }
+  /**
+   * Log warning message (always shown)
+   */
+  warn(message) {
+    console.log(import_chalk.default.yellow("\u26A0"), message);
+  }
+  /**
+   * Log error message (always shown)
+   */
+  error(message) {
+    console.error(import_chalk.default.red("\u2717"), message);
+  }
+  /**
+   * Log verbose message (only shown in verbose mode)
+   */
+  verbose(message) {
+    if (this._verbose) {
+      console.log(import_chalk.default.gray("\u2192"), message);
+    }
+  }
+  /**
+   * Log dry-run message (only shown in dry-run mode)
+   */
+  dryRun(message) {
+    if (this._dryRun) {
+      console.log(import_chalk.default.cyan("[DRY-RUN]"), message);
+    }
+  }
+  /**
+   * Create a spinner for long-running operations
+   */
+  spinner(text) {
+    return (0, import_ora.default)({
+      text,
+      color: "cyan",
+      spinner: "dots"
+    });
+  }
+  /**
+   * Log file operation (respects dry-run)
+   */
+  fileOperation(action, filePath) {
+    if (this._dryRun) {
+      this.dryRun(`Would ${action}: ${import_chalk.default.underline(filePath)}`);
+    } else {
+      this.verbose(`${action}: ${filePath}`);
+    }
+  }
+  /**
+   * Format error with context
+   */
+  formatError(error, context) {
+    let errorMessage = "";
+    if (error instanceof Error) {
+      errorMessage = error.message;
+      if (this._verbose && error.stack) {
+        errorMessage += `
+${import_chalk.default.gray(error.stack)}`;
+      }
+    } else if (error && typeof error === "object") {
+      const errorObj = error;
+      if (errorObj.message) {
+        errorMessage = String(errorObj.message);
+      } else if (errorObj.status) {
+        errorMessage = `HTTP ${errorObj.status}: ${errorObj.statusText || "Unknown error"}`;
+      } else {
+        try {
+          errorMessage = JSON.stringify(error, null, 2);
+        } catch {
+          errorMessage = String(error);
+        }
+      }
+    } else {
+      errorMessage = String(error);
+    }
+    if (context) {
+      return `${import_chalk.default.red(context)}
+${errorMessage}`;
+    }
+    return errorMessage;
+  }
+};
+var logger_default = Logger;
+
 // src/index.ts
-var main = async (configPath) => {
+var main = async (options) => {
+  const opts = typeof options === "string" ? { configPath: options } : options ?? {};
+  const logger = new logger_default({
+    verbose: opts.verbose ?? false,
+    dryRun: opts.dryRun ?? false
+  });
   try {
-    const config = await loadConfig(configPath);
-    console.log("Config loaded successfully");
+    const configSpinner = logger.spinner("Loading configuration...");
+    configSpinner.start();
+    const config = await loadConfig(opts.configPath);
+    configSpinner.succeed("Configuration loaded successfully");
+    logger.verbose(`Config path: ${opts.configPath || "default"}`);
+    logger.verbose(`Overwrite mode: ${config.overwrite ? "enabled" : "disabled"}`);
     const generatesArray = Array.isArray(config.generates) ? config.generates : [config.generates];
+    logger.verbose(`Found ${generatesArray.length} generate configuration(s)`);
     for (const urlSchema of generatesArray) {
       for (const [filePath, generatorConfig] of Object.entries(urlSchema)) {
         try {
-          await fetchAlgoliaData(filePath, generatorConfig, config.overwrite);
+          await fetchAlgoliaData(filePath, generatorConfig, config.overwrite, logger);
         } catch (error) {
-          console.error(`
-Error processing file: ${filePath}`);
-          if (error instanceof Error) {
-            console.error(error.message);
-            if (error.stack) {
-              console.error(error.stack);
-            }
-          } else {
-            try {
-              console.error(JSON.stringify(error, null, 2));
-            } catch {
-              console.error(String(error));
-            }
-          }
+          logger.error(`Error processing file: ${filePath}`);
+          const errorMessage = logger.formatError(error, "Processing failed");
+          logger.error(errorMessage);
         }
       }
     }
-  } catch (error) {
-    console.error("Error loading config:");
-    if (error instanceof Error) {
-      console.error(error.message);
+    if (opts.dryRun) {
+      logger.info("Dry-run completed. No files were written.");
     } else {
-      console.error(String(error));
+      logger.success("All files generated successfully!");
     }
+  } catch (error) {
+    logger.error("Failed to load configuration");
+    const errorMessage = logger.formatError(error, "Configuration error");
+    logger.error(errorMessage);
     process.exit(1);
   }
 };
@@ -601,6 +741,10 @@ if ((0, import_fs4.existsSync)(envPath)) {
   (0, import_dotenv.config)({ path: envPath });
 }
 var program = new import_commander.Command();
-program.name("algolia-codegen").description("Generate TypeScript types from Algolia index").option("-c, --config <path>", "Config file path").action(async (options) => {
-  await main(options.config);
+program.name("algolia-codegen").description("Generate TypeScript types from Algolia index").option("-c, --config <path>", "Config file path").option("-v, --verbose", "Enable verbose output").option("--dry-run", "Simulate execution without writing files").action(async (options) => {
+  await main({
+    configPath: options.config,
+    verbose: options.verbose ?? false,
+    dryRun: options.dryRun ?? false
+  });
 }).parse();

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   main
-} from "./chunk-4T5DZK75.js";
+} from "./chunk-USMYY2DN.js";
 
 // src/cli.ts
 import { config as loadDotenv } from "dotenv";
@@ -13,6 +13,10 @@ if (existsSync(envPath)) {
   loadDotenv({ path: envPath });
 }
 var program = new Command();
-program.name("algolia-codegen").description("Generate TypeScript types from Algolia index").option("-c, --config <path>", "Config file path").action(async (options) => {
-  await main(options.config);
+program.name("algolia-codegen").description("Generate TypeScript types from Algolia index").option("-c, --config <path>", "Config file path").option("-v, --verbose", "Enable verbose output").option("--dry-run", "Simulate execution without writing files").action(async (options) => {
+  await main({
+    configPath: options.config,
+    verbose: options.verbose ?? false,
+    dryRun: options.dryRun ?? false
+  });
 }).parse();

package/dist/index.cjs

@@ -489,27 +489,34 @@ function generateTypeScriptTypes(sampleHit, config) {
 }
 
 // src/utils/fetch-algolia-data.ts
-async function fetchAlgoliaData(filePath, generatorConfig, overwrite) {
-  console.log(`
-Processing file: ${filePath}`);
+async function fetchAlgoliaData(filePath, generatorConfig, overwrite, logger) {
+  logger.info(`Processing file: ${filePath}`);
   const resolvedPath = (0, import_path2.resolve)(process.cwd(), filePath);
+  logger.verbose(`Resolved path: ${resolvedPath}`);
   if ((0, import_fs3.existsSync)(resolvedPath) && !overwrite) {
     throw new Error(
       `File already exists: ${resolvedPath}
 Set overwrite: true in config to allow overwriting existing files.`
     );
   }
-  console.log(`Connecting to Algolia...`);
-  console.log(`App ID: ${generatorConfig.appId}`);
+  const connectSpinner = logger.spinner("Connecting to Algolia...");
+  connectSpinner.start();
   let client;
   try {
+    logger.verbose(`App ID: ${generatorConfig.appId}`);
+    logger.verbose(`Index: ${generatorConfig.indexName}`);
     client = (0, import_algoliasearch.algoliasearch)(generatorConfig.appId, generatorConfig.searchKey);
+    connectSpinner.succeed("Connected to Algolia");
   } catch (error) {
+    connectSpinner.fail("Failed to connect to Algolia");
     throw new Error(
       `Failed to initialize Algolia client: ${error instanceof Error ? error.message : String(error)}`
     );
   }
-  console.log(`Fetching sample record from index: ${generatorConfig.indexName}`);
+  const fetchSpinner = logger.spinner(
+    `Fetching sample record from index: ${generatorConfig.indexName}`
+  );
+  fetchSpinner.start();
   let results;
   try {
     results = await client.search([
@@ -521,7 +528,9 @@ Set overwrite: true in config to allow overwriting existing files.`
         }
       }
     ]);
+    fetchSpinner.succeed("Sample record fetched successfully");
   } catch (error) {
+    fetchSpinner.fail("Failed to fetch data from Algolia");
     let errorMessage;
     if (error instanceof Error) {
       errorMessage = error.message;
@@ -553,52 +562,183 @@ Set overwrite: true in config to allow overwriting existing files.`
     throw new Error(`No hits found in Algolia index: ${generatorConfig.indexName}`);
   }
   const sampleHit = result.hits[0];
-  console.log("Sample record fetched successfully");
-  console.log(`ObjectID: ${sampleHit.objectID || "N/A"}`);
+  logger.verbose(`ObjectID: ${sampleHit.objectID || "N/A"}`);
+  const generateSpinner = logger.spinner("Generating TypeScript types...");
+  generateSpinner.start();
   const fileContent = generateTypeScriptTypes(sampleHit, generatorConfig);
+  generateSpinner.succeed("TypeScript types generated");
   const dir = (0, import_path2.dirname)(resolvedPath);
   if (!(0, import_fs3.existsSync)(dir)) {
-    (0, import_fs3.mkdirSync)(dir, { recursive: true });
+    if (!logger.isDryRun) {
+      (0, import_fs3.mkdirSync)(dir, { recursive: true });
+      logger.verbose(`Created directory: ${dir}`);
+    } else {
+      logger.dryRun(`Would create directory: ${dir}`);
+    }
+  }
+  if (logger.isDryRun) {
+    logger.dryRun(`Would write file: ${filePath}`);
+    logger.verbose(`File content length: ${fileContent.length} characters`);
+  } else {
+    (0, import_fs3.writeFileSync)(resolvedPath, fileContent, "utf-8");
+    logger.success(`Generated file: ${filePath}`);
   }
-  (0, import_fs3.writeFileSync)(resolvedPath, fileContent, "utf-8");
-  console.log(`Generated file: ${filePath}`);
 }
 
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var import_ora = __toESM(require("ora"), 1);
+var Logger = class {
+  _verbose;
+  _dryRun;
+  constructor(options = {}) {
+    this._verbose = options.verbose ?? false;
+    this._dryRun = options.dryRun ?? false;
+  }
+  /**
+   * Check if verbose mode is enabled
+   */
+  get isVerbose() {
+    return this._verbose;
+  }
+  /**
+   * Check if dry-run mode is enabled
+   */
+  get isDryRun() {
+    return this._dryRun;
+  }
+  /**
+   * Log info message (always shown)
+   */
+  info(message) {
+    console.log(import_chalk.default.blue("\u2139"), message);
+  }
+  /**
+   * Log success message (always shown)
+   */
+  success(message) {
+    console.log(import_chalk.default.green("\u2713"), message);
+  }
+  /**
+   * Log warning message (always shown)
+   */
+  warn(message) {
+    console.log(import_chalk.default.yellow("\u26A0"), message);
+  }
+  /**
+   * Log error message (always shown)
+   */
+  error(message) {
+    console.error(import_chalk.default.red("\u2717"), message);
+  }
+  /**
+   * Log verbose message (only shown in verbose mode)
+   */
+  verbose(message) {
+    if (this._verbose) {
+      console.log(import_chalk.default.gray("\u2192"), message);
+    }
+  }
+  /**
+   * Log dry-run message (only shown in dry-run mode)
+   */
+  dryRun(message) {
+    if (this._dryRun) {
+      console.log(import_chalk.default.cyan("[DRY-RUN]"), message);
+    }
+  }
+  /**
+   * Create a spinner for long-running operations
+   */
+  spinner(text) {
+    return (0, import_ora.default)({
+      text,
+      color: "cyan",
+      spinner: "dots"
+    });
+  }
+  /**
+   * Log file operation (respects dry-run)
+   */
+  fileOperation(action, filePath) {
+    if (this._dryRun) {
+      this.dryRun(`Would ${action}: ${import_chalk.default.underline(filePath)}`);
+    } else {
+      this.verbose(`${action}: ${filePath}`);
+    }
+  }
+  /**
+   * Format error with context
+   */
+  formatError(error, context) {
+    let errorMessage = "";
+    if (error instanceof Error) {
+      errorMessage = error.message;
+      if (this._verbose && error.stack) {
+        errorMessage += `
+${import_chalk.default.gray(error.stack)}`;
+      }
+    } else if (error && typeof error === "object") {
+      const errorObj = error;
+      if (errorObj.message) {
+        errorMessage = String(errorObj.message);
+      } else if (errorObj.status) {
+        errorMessage = `HTTP ${errorObj.status}: ${errorObj.statusText || "Unknown error"}`;
+      } else {
+        try {
+          errorMessage = JSON.stringify(error, null, 2);
+        } catch {
+          errorMessage = String(error);
+        }
+      }
+    } else {
+      errorMessage = String(error);
+    }
+    if (context) {
+      return `${import_chalk.default.red(context)}
+${errorMessage}`;
+    }
+    return errorMessage;
+  }
+};
+var logger_default = Logger;
+
 // src/index.ts
-var main = async (configPath) => {
+var main = async (options) => {
+  const opts = typeof options === "string" ? { configPath: options } : options ?? {};
+  const logger = new logger_default({
+    verbose: opts.verbose ?? false,
+    dryRun: opts.dryRun ?? false
+  });
   try {
-    const config = await loadConfig(configPath);
-    console.log("Config loaded successfully");
+    const configSpinner = logger.spinner("Loading configuration...");
+    configSpinner.start();
+    const config = await loadConfig(opts.configPath);
+    configSpinner.succeed("Configuration loaded successfully");
+    logger.verbose(`Config path: ${opts.configPath || "default"}`);
+    logger.verbose(`Overwrite mode: ${config.overwrite ? "enabled" : "disabled"}`);
     const generatesArray = Array.isArray(config.generates) ? config.generates : [config.generates];
+    logger.verbose(`Found ${generatesArray.length} generate configuration(s)`);
     for (const urlSchema of generatesArray) {
       for (const [filePath, generatorConfig] of Object.entries(urlSchema)) {
         try {
-          await fetchAlgoliaData(filePath, generatorConfig, config.overwrite);
+          await fetchAlgoliaData(filePath, generatorConfig, config.overwrite, logger);
         } catch (error) {
-          console.error(`
-Error processing file: ${filePath}`);
-          if (error instanceof Error) {
-            console.error(error.message);
-            if (error.stack) {
-              console.error(error.stack);
-            }
-          } else {
-            try {
-              console.error(JSON.stringify(error, null, 2));
-            } catch {
-              console.error(String(error));
-            }
-          }
+          logger.error(`Error processing file: ${filePath}`);
+          const errorMessage = logger.formatError(error, "Processing failed");
+          logger.error(errorMessage);
         }
       }
     }
-  } catch (error) {
-    console.error("Error loading config:");
-    if (error instanceof Error) {
-      console.error(error.message);
+    if (opts.dryRun) {
+      logger.info("Dry-run completed. No files were written.");
     } else {
-      console.error(String(error));
+      logger.success("All files generated successfully!");
     }
+  } catch (error) {
+    logger.error("Failed to load configuration");
+    const errorMessage = logger.formatError(error, "Configuration error");
+    logger.error(errorMessage);
     process.exit(1);
   }
 };

package/dist/index.d.cts

@@ -29,9 +29,14 @@ declare function validateUrlSchema(urlSchema: unknown, path: string): asserts ur
  */
 declare function validateGeneratorConfig(config: unknown, path: string): asserts config is AlgoliaCodegenGeneratorConfig;
 
+interface MainOptions {
+    configPath?: string;
+    verbose?: boolean;
+    dryRun?: boolean;
+}
 /**
  * Main function to load and process configuration
  */
-declare const main: (configPath?: string) => Promise<void>;
+declare const main: (options?: MainOptions | string) => Promise<void>;
 
-export { type AlgoliaCodegenConfig, type AlgoliaCodegenGeneratorConfig, type InstanceOrArray, type UrlSchema, main, validateConfig, validateGeneratorConfig, validateUrlSchema };
+export { type AlgoliaCodegenConfig, type AlgoliaCodegenGeneratorConfig, type InstanceOrArray, type MainOptions, type UrlSchema, main, validateConfig, validateGeneratorConfig, validateUrlSchema };

package/dist/index.d.ts

@@ -29,9 +29,14 @@ declare function validateUrlSchema(urlSchema: unknown, path: string): asserts ur
  */
 declare function validateGeneratorConfig(config: unknown, path: string): asserts config is AlgoliaCodegenGeneratorConfig;
 
+interface MainOptions {
+    configPath?: string;
+    verbose?: boolean;
+    dryRun?: boolean;
+}
 /**
  * Main function to load and process configuration
  */
-declare const main: (configPath?: string) => Promise<void>;
+declare const main: (options?: MainOptions | string) => Promise<void>;
 
-export { type AlgoliaCodegenConfig, type AlgoliaCodegenGeneratorConfig, type InstanceOrArray, type UrlSchema, main, validateConfig, validateGeneratorConfig, validateUrlSchema };
+export { type AlgoliaCodegenConfig, type AlgoliaCodegenGeneratorConfig, type InstanceOrArray, type MainOptions, type UrlSchema, main, validateConfig, validateGeneratorConfig, validateUrlSchema };

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   validateConfig,
   validateGeneratorConfig,
   validateUrlSchema
-} from "./chunk-4T5DZK75.js";
+} from "./chunk-USMYY2DN.js";
 export {
   main,
   validateConfig,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "algolia-codegen",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Generate TypeScript types from Algolia indices",
   "license": "MIT",
   "author": "nightlightmare",
@@ -38,9 +38,11 @@
   ],
   "dependencies": {
     "algoliasearch": "^5.46.2",
+    "chalk": "^5.6.2",
     "commander": "^14.0.2",
     "dotenv": "^17.2.3",
     "esbuild": "^0.27.0",
+    "ora": "^9.0.0",
     "tsx": "^4.21.0"
   },
   "devDependencies": {