@alagoni97/cli 0.72.1

package/dist/commands/base.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Base command class with shared flags for verbosity and output control
+ */
+import { Command } from '@oclif/core';
+export declare abstract class BaseCommand extends Command {
+    static baseFlags: {
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        silent: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-color': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        debug: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    /**
+     * Configure the logger based on parsed flags
+     */
+    protected setupLogger(flags: Record<string, unknown>): void;
+}

package/dist/commands/base.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCommand = void 0;
+/**
+ * Base command class with shared flags for verbosity and output control
+ */
+const core_1 = require("@oclif/core");
+const LoggingInterface_1 = require("../LoggingInterface");
+class BaseCommand extends core_1.Command {
+    static baseFlags = {
+        verbose: core_1.Flags.boolean({
+            char: 'v',
+            description: 'Show detailed output'
+        }),
+        quiet: core_1.Flags.boolean({
+            char: 'q',
+            description: 'Only show errors and warnings',
+            exclusive: ['verbose', 'silent']
+        }),
+        silent: core_1.Flags.boolean({
+            description: 'Suppress all output except fatal errors',
+            exclusive: ['verbose', 'quiet']
+        }),
+        json: core_1.Flags.boolean({
+            description: 'Output results as JSON for scripting'
+        }),
+        'no-color': core_1.Flags.boolean({
+            description: 'Disable colored output'
+        }),
+        debug: core_1.Flags.boolean({
+            description: 'Show debug information',
+            exclusive: ['quiet', 'silent']
+        })
+    };
+    /**
+     * Configure the logger based on parsed flags
+     */
+    setupLogger(flags) {
+        // Reset logger to default state first to ensure clean state between commands
+        LoggingInterface_1.Logger.reset();
+        let logLevel = 'info';
+        if (flags.debug) {
+            logLevel = 'debug';
+        }
+        else if (flags.verbose) {
+            logLevel = 'verbose';
+        }
+        else if (flags.quiet) {
+            logLevel = 'warn';
+        }
+        else if (flags.silent) {
+            logLevel = 'silent';
+        }
+        LoggingInterface_1.Logger.setLevel(logLevel);
+        LoggingInterface_1.Logger.setJsonMode(!!flags.json);
+        LoggingInterface_1.Logger.setColors(!flags['no-color']);
+    }
+}
+exports.BaseCommand = BaseCommand;

package/dist/commands/generate.d.ts

@@ -0,0 +1,46 @@
+import { RunGeneratorContext } from '../codegen';
+import { BaseCommand } from './base';
+export default class Generate extends BaseCommand {
+    static description: string;
+    static args: {
+        file: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        silent: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-color': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        debug: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        watch: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        watchPath: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    /**
+     * Handle successful generation output based on flags
+     */
+    private handleSuccessOutput;
+    private runWithWatch;
+    handleWatchModeStartedTelemetry({ context, inputSource }: {
+        context: RunGeneratorContext;
+        inputSource: 'remote_url' | 'local_relative' | 'local_absolute' | undefined;
+    }): Promise<void>;
+    handleGeneratorUsageTelemetry({ context, inputSource }: {
+        context: RunGeneratorContext;
+        inputSource: 'remote_url' | 'local_relative' | 'local_absolute' | undefined;
+    }): Promise<void>;
+    handleSuccessfulGenerateTelemetry({ context, flags, inputSource, startTime }: {
+        context: RunGeneratorContext;
+        flags: any;
+        inputSource: 'remote_url' | 'local_relative' | 'local_absolute' | undefined;
+        startTime: number;
+    }): Promise<void>;
+    handleFailedGenerateTelemetry({ error, context, flags, inputSource, startTime }: {
+        error: unknown;
+        context: RunGeneratorContext;
+        flags: any;
+        inputSource: 'remote_url' | 'local_relative' | 'local_absolute' | undefined;
+        startTime: number;
+    }): Promise<void>;
+}

package/dist/commands/generate.js

@@ -0,0 +1,305 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-undef, sonarjs/cognitive-complexity */
+const core_1 = require("@oclif/core");
+const LoggingInterface_1 = require("../LoggingInterface");
+const generators_1 = require("../codegen/generators");
+const output_1 = require("../codegen/output");
+const chokidar_1 = __importDefault(require("chokidar"));
+const path_1 = __importDefault(require("path"));
+const configurations_1 = require("../codegen/configurations");
+const errors_1 = require("../codegen/errors");
+const telemetry_1 = require("../telemetry");
+const anonymize_1 = require("../telemetry/anonymize");
+const inputSource_1 = require("../utils/inputSource");
+const base_1 = require("./base");
+const picocolors_1 = __importDefault(require("picocolors"));
+/**
+ * Converts any error to a CodegenError for consistent error handling.
+ * If error is already a CodegenError, returns it directly.
+ * Otherwise wraps it in a generic generator error.
+ */
+function toCodegenError(error) {
+    if (error instanceof errors_1.CodegenError) {
+        return error;
+    }
+    return (0, errors_1.createGeneratorError)({
+        generatorId: 'generate',
+        originalError: error instanceof Error ? error : new Error(String(error))
+    });
+}
+class Generate extends base_1.BaseCommand {
+    static description = 'Generate code based on your configuration, use `init` to get started, `generate` to generate code from the configuration.';
+    static args = {
+        file: core_1.Args.string({
+            description: 'Path or URL to the configuration file, defaults to root of where the command is run'
+        })
+    };
+    static flags = {
+        help: core_1.Flags.help(),
+        watch: core_1.Flags.boolean({
+            char: 'w',
+            description: 'Watch for file changes and regenerate code automatically'
+        }),
+        watchPath: core_1.Flags.string({
+            char: 'p',
+            description: 'Optional path to watch for changes when --watch flag is used. If not provided, watches the input file from configuration'
+        }),
+        ...base_1.BaseCommand.baseFlags
+    };
+    async run() {
+        const startTime = Date.now();
+        const { args, flags } = await this.parse(Generate);
+        // Configure logger based on flags
+        this.setupLogger(flags);
+        const { file } = args;
+        const { watch, watchPath } = flags;
+        // Determine input source type if file is provided
+        let inputSource;
+        if (file) {
+            inputSource = (0, anonymize_1.getInputSourceType)(file);
+        }
+        let context;
+        try {
+            context = await (0, configurations_1.realizeGeneratorContext)(file);
+        }
+        catch (configError) {
+            const codegenError = toCodegenError(configError);
+            LoggingInterface_1.Logger.error(codegenError.format(!flags['no-color']));
+            // Use error message that includes details for better test assertions
+            const errorMessage = codegenError.details
+                ? `${codegenError.message}: ${codegenError.details}`
+                : codegenError.message;
+            this.error(errorMessage, { exit: 1 });
+        }
+        try {
+            let result;
+            if (watch) {
+                await this.handleWatchModeStartedTelemetry({ context, inputSource });
+                await this.runWithWatch({ configFile: file, watchPath, flags, context });
+            }
+            else {
+                LoggingInterface_1.Logger.startSpinner('Generating code...');
+                result = await (0, generators_1.generateWithConfig)(context);
+                // Write files to disk (pure core returns files, CLI writes)
+                const basePath = path_1.default.dirname(context.configFilePath);
+                await (0, output_1.writeGeneratedFiles)(result.files, basePath);
+                this.handleSuccessOutput(result, flags);
+            }
+            await this.handleGeneratorUsageTelemetry({ context, inputSource });
+            await this.handleSuccessfulGenerateTelemetry({
+                context,
+                flags,
+                inputSource,
+                startTime
+            });
+        }
+        catch (error) {
+            LoggingInterface_1.Logger.failSpinner('Generation failed');
+            const codegenError = toCodegenError(error);
+            LoggingInterface_1.Logger.error(codegenError.format(!flags['no-color']));
+            await this.handleFailedGenerateTelemetry({
+                error,
+                context,
+                flags,
+                inputSource,
+                startTime
+            });
+            // Use error message that includes details for better test assertions
+            const errorMessage = codegenError.details
+                ? `${codegenError.message}: ${codegenError.details}`
+                : codegenError.message;
+            this.error(errorMessage, { exit: 1 });
+        }
+    }
+    /**
+     * Handle successful generation output based on flags
+     */
+    handleSuccessOutput(result, flags) {
+        const totalFiles = result.files.length;
+        LoggingInterface_1.Logger.succeedSpinner(`Generated ${totalFiles} file${totalFiles !== 1 ? 's' : ''} in ${result.totalDuration}ms`);
+        // Verbose: show file list
+        if (flags.verbose && !flags.json) {
+            for (const file of result.files) {
+                const relativePath = path_1.default.relative(process.cwd(), file.path);
+                LoggingInterface_1.Logger.verbose(`  -> ${relativePath}`);
+            }
+        }
+        // JSON output
+        if (flags.json) {
+            LoggingInterface_1.Logger.json({
+                success: true,
+                files: result.files.map((file) => path_1.default.relative(process.cwd(), file.path)),
+                generators: result.generators.map((gen) => ({
+                    id: gen.id,
+                    preset: gen.preset,
+                    files: gen.files.map((file) => path_1.default.relative(process.cwd(), file.path)),
+                    duration: gen.duration
+                })),
+                totalFiles,
+                duration: result.totalDuration
+            });
+        }
+    }
+    async runWithWatch({ configFile, watchPath, flags, context }) {
+        const basePath = path_1.default.dirname(context.configFilePath);
+        // Initial generation
+        LoggingInterface_1.Logger.startSpinner('Generating initial code...');
+        const initialResult = await (0, generators_1.generateWithConfig)(configFile);
+        await (0, output_1.writeGeneratedFiles)(initialResult.files, basePath);
+        const totalFiles = initialResult.files.length;
+        LoggingInterface_1.Logger.succeedSpinner(`Initial generation complete (${totalFiles} file${totalFiles !== 1 ? 's' : ''})`);
+        // Determine what to watch
+        let pathToWatch;
+        if (watchPath) {
+            pathToWatch = path_1.default.resolve(watchPath);
+        }
+        else {
+            // Get the input file path from configuration
+            const watchContext = await (0, configurations_1.realizeGeneratorContext)(configFile);
+            pathToWatch = watchContext.documentPath;
+        }
+        const useColors = !flags['no-color'];
+        // Watch mode degrades gracefully for URL inputs: chokidar can only
+        // observe the local filesystem, so skip it and warn the user.
+        if ((0, inputSource_1.isRemoteUrl)(pathToWatch)) {
+            LoggingInterface_1.Logger.warn(`Watch mode: input is a remote URL — skipping input watcher. Use --watchPath to trigger regeneration on local file changes.`);
+            // Keep the process alive so users can still ^C cleanly.
+            return new Promise(() => undefined);
+        }
+        LoggingInterface_1.Logger.info(`\nWatching for changes in: ${useColors ? picocolors_1.default.cyan(pathToWatch) : pathToWatch}`);
+        LoggingInterface_1.Logger.info(useColors
+            ? picocolors_1.default.dim('Press Ctrl+C to stop watching...')
+            : 'Press Ctrl+C to stop watching...');
+        // Set up file watcher
+        const watcher = chokidar_1.default.watch(pathToWatch, {
+            ignored: /(^|[/\\])\../, // ignore dotfiles
+            persistent: true,
+            ignoreInitial: true
+        });
+        let isGenerating = false;
+        watcher.on('change', async (changedPath) => {
+            if (isGenerating) {
+                LoggingInterface_1.Logger.debug('Generation already in progress, skipping...');
+                return;
+            }
+            isGenerating = true;
+            LoggingInterface_1.Logger.startSpinner(`Regenerating (${path_1.default.basename(changedPath)} changed)...`);
+            try {
+                const result = await (0, generators_1.generateWithConfig)(configFile);
+                await (0, output_1.writeGeneratedFiles)(result.files, basePath);
+                const regenTotalFiles = result.files.length;
+                LoggingInterface_1.Logger.succeedSpinner(`Regenerated ${regenTotalFiles} file${regenTotalFiles !== 1 ? 's' : ''} in ${result.totalDuration}ms`);
+                // Verbose: show file list
+                if (flags.verbose && !flags.json) {
+                    for (const file of result.files) {
+                        const relativePath = path_1.default.relative(process.cwd(), file.path);
+                        LoggingInterface_1.Logger.verbose(`  -> ${relativePath}`);
+                    }
+                }
+            }
+            catch (error) {
+                const codegenError = toCodegenError(error);
+                LoggingInterface_1.Logger.failSpinner('Regeneration failed');
+                LoggingInterface_1.Logger.error(codegenError.format(!flags['no-color']));
+            }
+            finally {
+                isGenerating = false;
+            }
+        });
+        watcher.on('error', (error) => {
+            const codegenError = toCodegenError(error);
+            LoggingInterface_1.Logger.error(codegenError.format(!flags['no-color']));
+        });
+        // Set up graceful shutdown handlers
+        const cleanup = () => {
+            LoggingInterface_1.Logger.info('\nStopping file watcher...');
+            watcher.close();
+        };
+        // Handle process signals for graceful shutdown
+        // eslint-disable-next-line no-undef
+        process.on('SIGINT', cleanup);
+        // eslint-disable-next-line no-undef
+        process.on('SIGTERM', cleanup);
+        // Keep the process alive by waiting indefinitely
+        return new Promise(() => {
+            // This promise never resolves, keeping the process alive
+            // The process will exit when SIGINT/SIGTERM is received
+        });
+    }
+    async handleWatchModeStartedTelemetry({ context, inputSource }) {
+        const projectTelemetryConfig = context.configuration.telemetry;
+        // Track watch mode started (fire and forget, never throws)
+        (0, telemetry_1.trackEvent)({
+            event: 'watch_mode_started',
+            command: 'generate',
+            input_source: inputSource
+        }, projectTelemetryConfig);
+    }
+    async handleGeneratorUsageTelemetry({ context, inputSource }) {
+        const projectTelemetryConfig = context.configuration.telemetry;
+        // Track each generator usage (fire and forget, never throws)
+        for (const generator of context.configuration.generators) {
+            const generatorStartTime = Date.now();
+            const language = generator.language ||
+                context.configuration.language ||
+                'typescript';
+            // Sanitize options - remove sensitive data like paths
+            const { id, preset, outputPath, dependencies, ...sanitizedOptions } = generator;
+            (0, telemetry_1.trackEvent)({
+                event: 'generator_used',
+                generator_type: generator.preset,
+                input_type: context.configuration.inputType,
+                input_source: inputSource,
+                language,
+                options: JSON.stringify(sanitizedOptions),
+                duration: Date.now() - generatorStartTime,
+                success: true
+            }, projectTelemetryConfig);
+        }
+    }
+    async handleSuccessfulGenerateTelemetry({ context, flags, inputSource, startTime }) {
+        const projectTelemetryConfig = context.configuration.telemetry;
+        // Track successful execution with generator combination (fire and forget, never throws)
+        const activeFlags = Object.keys(flags).filter((f) => flags[f]);
+        const generatorPresets = context.configuration.generators.map((g) => g.preset);
+        (0, telemetry_1.trackEvent)({
+            event: 'command_executed',
+            command: 'generate',
+            flags: activeFlags.length > 0 ? activeFlags.join(',') : 'none',
+            input_source: inputSource || 'unknown',
+            input_type: context.configuration.inputType,
+            generators: generatorPresets.join(','),
+            generator_count: context.configuration.generators.length,
+            duration: Date.now() - startTime,
+            success: true
+        }, projectTelemetryConfig);
+    }
+    async handleFailedGenerateTelemetry({ error, context, flags, inputSource, startTime }) {
+        // Try to get project config for telemetry, but don't fail if we can't
+        const projectTelemetryConfig = context.configuration.telemetry;
+        const generators = context.configuration.generators.map((g) => g.preset);
+        const generatorCount = context.configuration.generators.length;
+        const inputType = context.configuration.inputType;
+        // Track failed execution (fire and forget, never throws)
+        const activeFlags = Object.keys(flags).filter((f) => flags[f]);
+        (0, telemetry_1.trackEvent)({
+            event: 'command_executed',
+            command: 'generate',
+            flags: activeFlags.length > 0 ? activeFlags.join(',') : 'none',
+            input_source: inputSource || 'unknown',
+            input_type: inputType,
+            generators: Array.isArray(generators)
+                ? generators.join(',')
+                : String(generators),
+            generator_count: generatorCount,
+            duration: Date.now() - startTime,
+            success: false,
+            error_type: (0, anonymize_1.categorizeError)(error)
+        }, projectTelemetryConfig);
+    }
+}
+exports.default = Generate;

package/dist/commands/init.d.ts

@@ -0,0 +1,55 @@
+import { BaseCommand } from './base';
+declare const ConfigOptions: readonly ["esm", "json", "yaml", "ts"];
+declare const LanguageOptions: readonly ["typescript"];
+interface FlagTypes {
+    inputFile: string;
+    inputType: string;
+    configName: string;
+    configType: (typeof ConfigOptions)[number];
+    outputDirectory: string;
+    includePayloads: boolean;
+    includeParameters: boolean;
+    includeChannels: boolean;
+    includeClient: boolean;
+    includeHeaders: boolean;
+    languages: (typeof LanguageOptions)[number];
+    noOutput: boolean;
+    gitignoreGenerated: boolean;
+}
+export default class Init extends BaseCommand {
+    static description: string;
+    static args: {};
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-color': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'input-file': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'config-name': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'input-type': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'output-directory': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'config-type': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        languages: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'no-tty': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'include-payloads': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'include-headers': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'include-client': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'include-parameters': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'include-channels': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-output': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'gitignore-generated': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    realizeConfigFile(flags: FlagTypes): string;
+    realizeFlags(flags: any): FlagTypes;
+    /**
+     * Interactively ask the user for which configuration to create
+     */
+    runInteractive(flags: FlagTypes): Promise<void>;
+    /**
+     * Based on the flags, create the appropriate configuration file
+     */
+    createConfiguration(flags: FlagTypes): Promise<void>;
+    handleSuccessfulInitTelemetry(flags: FlagTypes): Promise<void>;
+}
+export {};