@alagoni97/cli 0.72.1

package/dist/LoggingInterface.d.ts

@@ -0,0 +1,123 @@
+export type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'verbose' | 'debug';
+/**
+ * Logging interface for the model generation library
+ */
+export interface LoggingInterface {
+    debug(message?: unknown, ...optionalParams: unknown[]): void;
+    info(message?: unknown, ...optionalParams: unknown[]): void;
+    warn(message?: unknown, ...optionalParams: unknown[]): void;
+    error(message?: unknown, ...optionalParams: unknown[]): void;
+}
+/**
+ * Extended logging interface with additional capabilities
+ */
+export interface ExtendedLoggingInterface extends LoggingInterface {
+    verbose(message?: unknown, ...optionalParams: unknown[]): void;
+    startSpinner(text: string): void;
+    updateSpinner(text: string): void;
+    succeedSpinner(text?: string): void;
+    failSpinner(text?: string): void;
+    stopSpinner(): void;
+    json(data: unknown): void;
+    setLevel(level: LogLevel): void;
+    setJsonMode(enabled: boolean): void;
+    setColors(enabled: boolean): void;
+    getLevel(): LogLevel;
+    isJsonMode(): boolean;
+}
+/**
+ * Logger class with enhanced capabilities
+ *
+ * Supports log levels, colors, spinners, and JSON output mode.
+ * Acts as a forefront for any external loggers.
+ */
+export declare class LoggerClass implements ExtendedLoggingInterface {
+    private logger?;
+    private level;
+    private jsonMode;
+    private colorsEnabled;
+    private spinner;
+    /**
+     * Check if a message at the given level should be logged
+     */
+    private shouldLog;
+    /**
+     * Format a message with optional color
+     */
+    private formatMessage;
+    /**
+     * Stop spinner before logging to prevent output overlap
+     */
+    private pauseSpinner;
+    /**
+     * Resume spinner after logging
+     */
+    private resumeSpinner;
+    /**
+     * Render the spinner
+     */
+    private renderSpinner;
+    debug(message?: unknown, ...optionalParams: unknown[]): void;
+    verbose(message?: unknown, ...optionalParams: unknown[]): void;
+    info(message?: unknown, ...optionalParams: unknown[]): void;
+    warn(message?: unknown, ...optionalParams: unknown[]): void;
+    error(message?: unknown, ...optionalParams: unknown[]): void;
+    /**
+     * Start a spinner with the given text
+     */
+    startSpinner(text: string): void;
+    /**
+     * Update the spinner text
+     */
+    updateSpinner(text: string): void;
+    /**
+     * Stop the spinner with a success message
+     */
+    succeedSpinner(text?: string): void;
+    /**
+     * Stop the spinner with a failure message
+     */
+    failSpinner(text?: string): void;
+    /**
+     * Stop the spinner without a message
+     */
+    stopSpinner(): void;
+    /**
+     * Output structured JSON data
+     * Only outputs in JSON mode or when explicitly called
+     */
+    json(data: unknown): void;
+    /**
+     * Set the log level
+     */
+    setLevel(level: LogLevel): void;
+    /**
+     * Enable or disable JSON mode
+     * In JSON mode, only json() output is shown
+     */
+    setJsonMode(enabled: boolean): void;
+    /**
+     * Enable or disable colored output
+     */
+    setColors(enabled: boolean): void;
+    /**
+     * Get the current log level
+     */
+    getLevel(): LogLevel;
+    /**
+     * Check if JSON mode is enabled
+     */
+    isJsonMode(): boolean;
+    /**
+     * Sets the logger to use for the model generation library
+     *
+     * @param logger to add
+     */
+    setLogger(logger?: LoggingInterface): void;
+    /**
+     * Reset the logger to default state.
+     * Useful for testing or when re-initializing the logger.
+     */
+    reset(): void;
+}
+export declare const Logger: LoggerClass;

package/dist/LoggingInterface.js

@@ -0,0 +1,300 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LoggerClass = void 0;
+/* eslint-disable no-undef, no-console, security/detect-object-injection */
+/**
+ * Enhanced logging interface with levels, colors, and spinners
+ */
+const picocolors_1 = __importDefault(require("picocolors"));
+const LOG_LEVEL_PRIORITY = {
+    silent: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    verbose: 4,
+    debug: 5
+};
+// Simple spinner implementation using console
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+/**
+ * Logger class with enhanced capabilities
+ *
+ * Supports log levels, colors, spinners, and JSON output mode.
+ * Acts as a forefront for any external loggers.
+ */
+class LoggerClass {
+    logger = undefined;
+    level = 'info';
+    jsonMode = false;
+    colorsEnabled = true;
+    spinner = null;
+    /**
+     * Check if a message at the given level should be logged
+     */
+    shouldLog(messageLevel) {
+        return (LOG_LEVEL_PRIORITY[messageLevel] <= LOG_LEVEL_PRIORITY[this.level] &&
+            !this.jsonMode);
+    }
+    /**
+     * Format a message with optional color
+     */
+    formatMessage(message, colorFn) {
+        const msg = String(message);
+        if (this.colorsEnabled && colorFn) {
+            return colorFn(msg);
+        }
+        return msg;
+    }
+    /**
+     * Stop spinner before logging to prevent output overlap
+     */
+    pauseSpinner() {
+        if (this.spinner?.interval) {
+            clearInterval(this.spinner.interval);
+            this.spinner.interval = null;
+            // Clear the current line
+            if (process.stdout.isTTY) {
+                process.stdout.clearLine(0);
+                process.stdout.cursorTo(0);
+            }
+        }
+    }
+    /**
+     * Resume spinner after logging
+     */
+    resumeSpinner() {
+        if (this.spinner && !this.spinner.interval) {
+            this.renderSpinner();
+        }
+    }
+    /**
+     * Render the spinner
+     */
+    renderSpinner() {
+        if (!this.spinner || !process.stdout.isTTY) {
+            return;
+        }
+        this.spinner.interval = setInterval(() => {
+            if (!this.spinner) {
+                return;
+            }
+            const frame = this.colorsEnabled
+                ? picocolors_1.default.cyan(SPINNER_FRAMES[this.spinner.frameIndex])
+                : SPINNER_FRAMES[this.spinner.frameIndex];
+            process.stdout.clearLine(0);
+            process.stdout.cursorTo(0);
+            process.stdout.write(`${frame} ${this.spinner.text}`);
+            this.spinner.frameIndex =
+                (this.spinner.frameIndex + 1) % SPINNER_FRAMES.length;
+        }, 80);
+    }
+    debug(message, ...optionalParams) {
+        if (!this.shouldLog('debug')) {
+            return;
+        }
+        this.pauseSpinner();
+        const prefix = this.formatMessage('[DEBUG] ', picocolors_1.default.gray);
+        const formattedMessage = this.formatMessage(message, picocolors_1.default.gray);
+        if (this.logger) {
+            this.logger.debug(prefix + formattedMessage, ...optionalParams);
+        }
+        else {
+            console.debug(prefix + formattedMessage, ...optionalParams);
+        }
+        this.resumeSpinner();
+    }
+    verbose(message, ...optionalParams) {
+        if (!this.shouldLog('verbose')) {
+            return;
+        }
+        this.pauseSpinner();
+        const formattedMessage = this.formatMessage(message, picocolors_1.default.dim);
+        if (this.logger) {
+            this.logger.info(formattedMessage, ...optionalParams);
+        }
+        else {
+            console.log(formattedMessage, ...optionalParams);
+        }
+        this.resumeSpinner();
+    }
+    info(message, ...optionalParams) {
+        if (!this.shouldLog('info')) {
+            return;
+        }
+        this.pauseSpinner();
+        const msg = String(message);
+        if (this.logger) {
+            this.logger.info(msg, ...optionalParams);
+        }
+        else {
+            // Use process.stdout.write for better capture by oclif test utilities
+            const fullMsg = optionalParams.length > 0
+                ? `${msg} ${optionalParams.join(' ')}\n`
+                : `${msg}\n`;
+            process.stdout.write(fullMsg);
+        }
+        this.resumeSpinner();
+    }
+    warn(message, ...optionalParams) {
+        if (!this.shouldLog('warn')) {
+            return;
+        }
+        this.pauseSpinner();
+        const formattedMessage = this.formatMessage(message, picocolors_1.default.yellow);
+        if (this.logger) {
+            this.logger.warn(formattedMessage, ...optionalParams);
+        }
+        else {
+            console.warn(formattedMessage, ...optionalParams);
+        }
+        this.resumeSpinner();
+    }
+    error(message, ...optionalParams) {
+        if (!this.shouldLog('error')) {
+            return;
+        }
+        this.pauseSpinner();
+        const formattedMessage = this.formatMessage(message, picocolors_1.default.red);
+        if (this.logger) {
+            this.logger.error(formattedMessage, ...optionalParams);
+        }
+        else {
+            console.error(formattedMessage, ...optionalParams);
+        }
+        this.resumeSpinner();
+    }
+    /**
+     * Start a spinner with the given text
+     */
+    startSpinner(text) {
+        if (this.jsonMode) {
+            return;
+        }
+        this.stopSpinner();
+        this.spinner = {
+            text,
+            interval: null,
+            frameIndex: 0
+        };
+        if (process.stdout.isTTY) {
+            this.renderSpinner();
+        }
+        else {
+            // In non-TTY mode, just print the text
+            console.log(text);
+        }
+    }
+    /**
+     * Update the spinner text
+     */
+    updateSpinner(text) {
+        if (this.spinner) {
+            this.spinner.text = text;
+        }
+    }
+    /**
+     * Stop the spinner with a success message
+     */
+    succeedSpinner(text) {
+        const spinnerText = this.spinner?.text;
+        this.stopSpinner();
+        const displayText = text || spinnerText || '';
+        if (displayText && this.shouldLog('info')) {
+            const symbol = this.colorsEnabled ? picocolors_1.default.green('✓') : '[OK]';
+            console.log(`${symbol} ${displayText}`);
+        }
+    }
+    /**
+     * Stop the spinner with a failure message
+     */
+    failSpinner(text) {
+        const spinnerText = this.spinner?.text;
+        this.stopSpinner();
+        const displayText = text || spinnerText || '';
+        if (displayText && this.shouldLog('error')) {
+            const symbol = this.colorsEnabled ? picocolors_1.default.red('✗') : '[FAIL]';
+            console.log(`${symbol} ${displayText}`);
+        }
+    }
+    /**
+     * Stop the spinner without a message
+     */
+    stopSpinner() {
+        if (this.spinner) {
+            if (this.spinner.interval) {
+                clearInterval(this.spinner.interval);
+            }
+            if (process.stdout.isTTY) {
+                process.stdout.clearLine(0);
+                process.stdout.cursorTo(0);
+            }
+            this.spinner = null;
+        }
+    }
+    /**
+     * Output structured JSON data
+     * Only outputs in JSON mode or when explicitly called
+     */
+    json(data) {
+        this.stopSpinner();
+        console.log(JSON.stringify(data, null, 2));
+    }
+    /**
+     * Set the log level
+     */
+    setLevel(level) {
+        this.level = level;
+    }
+    /**
+     * Enable or disable JSON mode
+     * In JSON mode, only json() output is shown
+     */
+    setJsonMode(enabled) {
+        this.jsonMode = enabled;
+        if (enabled) {
+            this.stopSpinner();
+        }
+    }
+    /**
+     * Enable or disable colored output
+     */
+    setColors(enabled) {
+        this.colorsEnabled = enabled;
+    }
+    /**
+     * Get the current log level
+     */
+    getLevel() {
+        return this.level;
+    }
+    /**
+     * Check if JSON mode is enabled
+     */
+    isJsonMode() {
+        return this.jsonMode;
+    }
+    /**
+     * Sets the logger to use for the model generation library
+     *
+     * @param logger to add
+     */
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    /**
+     * Reset the logger to default state.
+     * Useful for testing or when re-initializing the logger.
+     */
+    reset() {
+        this.stopSpinner();
+        this.level = 'info';
+        this.jsonMode = false;
+        this.colorsEnabled = true;
+        this.logger = undefined;
+    }
+}
+exports.LoggerClass = LoggerClass;
+exports.Logger = new LoggerClass();

package/dist/PersistedConfig.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Global configuration interface stored in ~/.the-codegen-project/config.json
+ * This configuration persists across all projects and CLI sessions.
+ */
+export interface GlobalConfig {
+    version: string;
+    telemetry: TelemetryConfig;
+    hasShownTelemetryNotice: boolean;
+    lastUpdated?: string;
+}
+/**
+ * Telemetry configuration interface
+ */
+export interface TelemetryConfig {
+    enabled: boolean;
+    anonymousId: string;
+    endpoint: string;
+    trackingId: string;
+    apiSecret: string;
+}
+/**
+ * Get global configuration.
+ * Creates default config if it doesn't exist.
+ * This function never throws - returns default config on any error.
+ */
+export declare function getGlobalConfig(): Promise<GlobalConfig>;
+/**
+ * Update global configuration.
+ * Creates config directory if it doesn't exist.
+ * This function never throws - fails silently on errors.
+ */
+export declare function updateGlobalConfig(config: GlobalConfig): Promise<void>;
+/**
+ * Check if the global config file exists.
+ */
+export declare function configFileExists(): Promise<boolean>;
+/**
+ * Get the path to the global config file.
+ * Useful for debugging and testing.
+ */
+export declare function getConfigFilePath(): string;
+/**
+ * Get the path to the config directory.
+ * Useful for debugging and testing.
+ */
+export declare function getConfigDirectoryPath(): string;

package/dist/PersistedConfig.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigDirectoryPath = exports.getConfigFilePath = exports.configFileExists = exports.updateGlobalConfig = exports.getGlobalConfig = void 0;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const uuid_1 = require("uuid");
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.the-codegen-project');
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
+/**
+ * Get global configuration.
+ * Creates default config if it doesn't exist.
+ * This function never throws - returns default config on any error.
+ */
+async function getGlobalConfig() {
+    try {
+        const data = await promises_1.default.readFile(CONFIG_FILE, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        // Config doesn't exist or is invalid, create default
+        return await createDefaultGlobalConfig();
+    }
+}
+exports.getGlobalConfig = getGlobalConfig;
+/**
+ * Update global configuration.
+ * Creates config directory if it doesn't exist.
+ * This function never throws - fails silently on errors.
+ */
+async function updateGlobalConfig(config) {
+    try {
+        await promises_1.default.mkdir(CONFIG_DIR, { recursive: true });
+        config.lastUpdated = new Date().toISOString();
+        await promises_1.default.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
+    }
+    catch {
+        // Fail silently - config update is not critical
+        // Debug logging intentionally omitted to avoid dependencies
+    }
+}
+exports.updateGlobalConfig = updateGlobalConfig;
+/**
+ * Create default global configuration with telemetry enabled.
+ * Uses GA4 Measurement Protocol as the default endpoint.
+ */
+async function createDefaultGlobalConfig() {
+    const globalConfig = {
+        version: '1.0.0',
+        telemetry: {
+            enabled: true,
+            anonymousId: (0, uuid_1.v4)(),
+            endpoint: 'https://www.google-analytics.com/mp/collect',
+            trackingId: 'G-45KZ589PCT',
+            apiSecret: 'emUAvwyZRDqCKYbmvWUM9g' // NOTE: is OKAY to be committed as its a public API secret
+        },
+        hasShownTelemetryNotice: false,
+        lastUpdated: new Date().toISOString()
+    };
+    await updateGlobalConfig(globalConfig);
+    return globalConfig;
+}
+/**
+ * Check if the global config file exists.
+ */
+async function configFileExists() {
+    try {
+        await promises_1.default.access(CONFIG_FILE);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+exports.configFileExists = configFileExists;
+/**
+ * Get the path to the global config file.
+ * Useful for debugging and testing.
+ */
+function getConfigFilePath() {
+    return CONFIG_FILE;
+}
+exports.getConfigFilePath = getConfigFilePath;
+/**
+ * Get the path to the config directory.
+ * Useful for debugging and testing.
+ */
+function getConfigDirectoryPath() {
+    return CONFIG_DIR;
+}
+exports.getConfigDirectoryPath = getConfigDirectoryPath;

package/dist/browser/adapters/output.d.ts

@@ -0,0 +1,69 @@
+/**
+ * In-memory file output adapter for browser environments.
+ * Replaces filesystem writes with Map<string, string> storage.
+ * Implements OutputAdapter interface for compatibility with shared generators.
+ */
+import { OutputAdapter } from '../../codegen/output/types';
+export declare class BrowserOutput implements OutputAdapter {
+    private files;
+    /**
+     * Write a file to memory.
+     * @param path - The file path (e.g., 'src/models/User.ts')
+     * @param content - The file content
+     */
+    write(path: string, content: string): Promise<void>;
+    /**
+     * No-op for browser - directories are virtual.
+     */
+    mkdir(_dirPath: string, _options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    /**
+     * Get all file paths that were written.
+     * Implements OutputAdapter interface.
+     */
+    getWrittenFiles(): string[];
+    /**
+     * Get all files with their content.
+     * Implements OutputAdapter interface.
+     */
+    getAllFiles(): Record<string, string>;
+    /**
+     * Read a file from memory.
+     * @param path - The file path
+     * @returns The file content, or undefined if not found
+     */
+    read(path: string): string | undefined;
+    /**
+     * Get all files as a Record.
+     * @deprecated Use getAllFiles() instead for OutputAdapter compatibility
+     * @returns A copy of all files as Record<path, content>
+     */
+    getAll(): Record<string, string>;
+    /**
+     * Clear all files from memory.
+     */
+    clear(): void;
+    /**
+     * Check if a file exists.
+     * @param path - The file path
+     * @returns True if the file exists
+     */
+    has(path: string): boolean;
+    /**
+     * Delete a specific file.
+     * @param path - The file path
+     * @returns True if the file was deleted, false if it didn't exist
+     */
+    delete(path: string): boolean;
+    /**
+     * Get all file paths.
+     * @deprecated Use getWrittenFiles() instead for OutputAdapter compatibility
+     * @returns Array of file paths
+     */
+    getPaths(): string[];
+    /**
+     * Get the number of files.
+     */
+    get size(): number;
+}