@pristine-ts/cli 2.0.5 → 2.0.7

package/dist/types/bootstrap/build-runner.d.ts

@@ -4,7 +4,7 @@
  * inline avoids the awkward "exit, ask the user to type a command, re-enter" loop.
  *
  * Spawning rather than dispatching to `BuildCommand` directly keeps `AppModuleLoader` free
- * of the build pipeline's dependency graph (ConsoleManager, ShellManager, etc.) which only
+ * of the build pipeline's dependency graph (LogHandler, ShellManager, CliOutput, etc.) which only
  * exists in the kernel container — and the kernel hasn't booted yet at the point this is
  * called. The subprocess re-bootstraps the kernel cleanly with all of those services.
  *

package/dist/types/commands/build.command.d.ts

@@ -1,6 +1,6 @@
 import { ExitCode } from "@pristine-ts/common";
+import { LogHandlerInterface } from "@pristine-ts/logging";
 import { CommandInterface } from "../interfaces/command.interface";
-import { ConsoleManager } from "../managers/console.manager";
 import { ShellManager } from "../managers/shell.manager";
 import { ConfigLoader } from "../config/config-loader";
 import { BuildManifestWriter } from "../bootstrap/build-manifest-writer";
@@ -24,7 +24,7 @@ import { BuildManifestWriter } from "../bootstrap/build-manifest-writer";
  *   - clean:    false           (set true to wipe outDir before building)
  */
 export declare class BuildCommand implements CommandInterface<null> {
-    private readonly consoleManager;
+    private readonly logHandler;
     private readonly shellManager;
     private readonly configLoader;
     private readonly buildManifestWriter;
@@ -33,7 +33,7 @@ export declare class BuildCommand implements CommandInterface<null> {
     description: string;
     private readonly defaultTsconfig;
     private readonly defaultFormat;
-    constructor(consoleManager: ConsoleManager, shellManager: ShellManager, configLoader: ConfigLoader, buildManifestWriter: BuildManifestWriter);
+    constructor(logHandler: LogHandlerInterface, shellManager: ShellManager, configLoader: ConfigLoader, buildManifestWriter: BuildManifestWriter);
     run(args: any): Promise<ExitCode | number>;
     private writeManifestIfConfigured;
     /**

package/dist/types/commands/config-print.command.d.ts

@@ -1,18 +1,23 @@
 import { ExitCode } from "@pristine-ts/common";
 import { CommandInterface } from "../interfaces/command.interface";
-import { ConsoleManager } from "../managers/console.manager";
+import { CliOutput } from "../managers/cli-output.manager";
 import { ConfigLoader } from "../config/config-loader";
 /**
  * Prints the resolved Pristine configuration plus where it was loaded from. Useful for
  * debugging discovery — when `pristine` is doing something unexpected, the first question is
  * always "which config file did it actually pick up?"
+ *
+ * This is a report command: its entire output is the report. It goes through `CliOutput`
+ * exclusively (not `LogHandler`) so the dump pipes/redirects cleanly — `pristine
+ * p:config:print > config.json` must produce a usable file, with no severity gating, no
+ * per-line timestamp/icon decoration, and no fan-out to file/Sentry transports.
  */
 export declare class ConfigPrintCommand implements CommandInterface<null> {
-    private readonly consoleManager;
+    private readonly cliOutput;
     private readonly configLoader;
     optionsType: null;
     name: string;
     description: string;
-    constructor(consoleManager: ConsoleManager, configLoader: ConfigLoader);
+    constructor(cliOutput: CliOutput, configLoader: ConfigLoader);
     run(args: any): Promise<ExitCode | number>;
 }

package/dist/types/commands/help.command.d.ts

@@ -1,7 +1,7 @@
 import { DependencyContainer } from "tsyringe";
 import { ExitCode } from "@pristine-ts/common";
 import { CommandInterface } from "../interfaces/command.interface";
-import { ConsoleManager } from "../managers/console.manager";
+import { CliOutput } from "../managers/cli-output.manager";
 /**
  * Prints a usage banner plus a one-line summary for every registered command. The output is
  * generated from the actual `CommandInterface[]` resolved from the current DI container, so
@@ -18,11 +18,11 @@ import { ConsoleManager } from "../managers/console.manager";
  * by which point every Command-tagged class is fully constructed and cached.
  */
 export declare class HelpCommand implements CommandInterface<null> {
-    private readonly consoleManager;
+    private readonly cliOutput;
     private readonly container;
     optionsType: null;
     name: string;
     description: string;
-    constructor(consoleManager: ConsoleManager, container: DependencyContainer);
+    constructor(cliOutput: CliOutput, container: DependencyContainer);
     run(args: any): Promise<ExitCode | number>;
 }

package/dist/types/commands/info.command.d.ts

@@ -1,6 +1,7 @@
 import { ExitCode } from "@pristine-ts/common";
+import { LogHandlerInterface } from "@pristine-ts/logging";
 import { CommandInterface } from "../interfaces/command.interface";
-import { ConsoleManager } from "../managers/console.manager";
+import { CliOutput } from "../managers/cli-output.manager";
 import { ConfigLoader } from "../config/config-loader";
 import { AppModuleLoader } from "../bootstrap/app-module-loader";
 /**
@@ -14,7 +15,8 @@ import { AppModuleLoader } from "../bootstrap/app-module-loader";
  * prevents `kernel.start()`.
  */
 export declare class InfoCommand implements CommandInterface<null> {
-    private readonly consoleManager;
+    private readonly logHandler;
+    private readonly cliOutput;
     private readonly configLoader;
     private readonly appModuleLoader;
     optionsType: null;
@@ -26,7 +28,7 @@ export declare class InfoCommand implements CommandInterface<null> {
      * package.json sits four levels up from dist/lib/cjs/commands/.
      */
     private readonly cliPackageJsonPath;
-    constructor(consoleManager: ConsoleManager, configLoader: ConfigLoader, appModuleLoader: AppModuleLoader);
+    constructor(logHandler: LogHandlerInterface, cliOutput: CliOutput, configLoader: ConfigLoader, appModuleLoader: AppModuleLoader);
     run(args: any): Promise<ExitCode | number>;
     private printRuntimeBanner;
     private printConfigSection;

package/dist/types/commands/init.command.d.ts

@@ -1,6 +1,6 @@
 import { ExitCode } from "@pristine-ts/common";
+import { LogHandlerInterface } from "@pristine-ts/logging";
 import { CommandInterface } from "../interfaces/command.interface";
-import { ConsoleManager } from "../managers/console.manager";
 import { InitCommandOptions } from "./init.command-options";
 import { InitPrompt } from "../bootstrap/init-prompt";
 /**
@@ -19,14 +19,14 @@ import { InitPrompt } from "../bootstrap/init-prompt";
  * Refuses to overwrite an existing `pristine.config.ts` so re-running init is safe.
  */
 export declare class InitCommand implements CommandInterface<InitCommandOptions> {
-    private readonly consoleManager;
+    private readonly logHandler;
     private readonly initPrompt;
     optionsType: typeof InitCommandOptions;
     name: string;
     description: string;
     private readonly configFileName;
     private readonly gitignoreEntry;
-    constructor(consoleManager: ConsoleManager, initPrompt: InitPrompt);
+    constructor(logHandler: LogHandlerInterface, initPrompt: InitPrompt);
     run(args: InitCommandOptions): Promise<ExitCode | number>;
     /**
      * Fills in answers from CLI flags first, then prompts (in TTY) for whatever's missing.

package/dist/types/commands/list.command.d.ts

@@ -1,18 +1,18 @@
 import { ExitCode } from "@pristine-ts/common";
 import { DependencyContainer } from "tsyringe";
 import { CommandInterface } from "../interfaces/command.interface";
-import { ConsoleManager } from "../managers/console.manager";
+import { CliOutput } from "../managers/cli-output.manager";
 /**
  * Lists every registered command's name. Like `HelpCommand`, this resolves the command set
  * lazily inside `run()` via the injected child container to avoid the self-referential cycle
  * that constructor-time `@injectAll(Command)` would create — see `HelpCommand` for details.
  */
 export declare class ListCommand implements CommandInterface<null> {
-    private readonly consoleManager;
+    private readonly cliOutput;
     private readonly container;
     optionsType: null;
     name: string;
     description: string;
-    constructor(consoleManager: ConsoleManager, container: DependencyContainer);
+    constructor(cliOutput: CliOutput, container: DependencyContainer);
     run(args: any): Promise<ExitCode | number>;
 }

package/dist/types/commands/start.command.d.ts

@@ -1,7 +1,7 @@
 import { ExitCode } from "@pristine-ts/common";
 import { Kernel, RuntimeServerInterface } from "@pristine-ts/core";
+import { LogHandlerInterface } from "@pristine-ts/logging";
 import { CommandInterface } from "../interfaces/command.interface";
-import { ConsoleManager } from "../managers/console.manager";
 import { StartCommandOptions } from "./start.command-options";
 /**
  * Boots the AppModule, starts every registered `RuntimeServerInterface` (HTTP server, gRPC
@@ -34,7 +34,7 @@ import { StartCommandOptions } from "./start.command-options";
  *     `nodemon` or `tsx --watch`.
  */
 export declare class StartCommand implements CommandInterface<StartCommandOptions> {
-    private readonly consoleManager;
+    private readonly logHandler;
     private readonly kernel;
     private readonly servers;
     optionsType: typeof StartCommandOptions;
@@ -42,6 +42,6 @@ export declare class StartCommand implements CommandInterface<StartCommandOption
     description: string;
     private static readonly HARD_EXIT_TIMEOUT_MS;
     private readonly defaultRuntimeServerName;
-    constructor(consoleManager: ConsoleManager, kernel: Kernel, servers: RuntimeServerInterface[]);
+    constructor(logHandler: LogHandlerInterface, kernel: Kernel, servers: RuntimeServerInterface[]);
     run(args: StartCommandOptions): Promise<ExitCode | number>;
 }

package/dist/types/event-handlers/cli.event-handler.d.ts

@@ -4,13 +4,11 @@ import { CommandEventResponse } from "../types/command-event-response.type";
 import { CommandInterface } from "../interfaces/command.interface";
 import { LogHandlerInterface } from "@pristine-ts/logging";
 import { Validator } from "@pristine-ts/class-validator";
-import { ConsoleManager } from "../managers/console.manager";
 export declare class CliEventHandler implements EventHandlerInterface<any, any> {
     private readonly logHandler;
     private readonly validator;
-    private readonly consoleManager;
     private readonly commands;
-    constructor(logHandler: LogHandlerInterface, validator: Validator, consoleManager: ConsoleManager, commands: CommandInterface<any>[]);
+    constructor(logHandler: LogHandlerInterface, validator: Validator, commands: CommandInterface<any>[]);
     handle(event: CommandEvent): Promise<CommandEventResponse>;
     /**
      * Maps `rawArgs` (the parsed argv shape produced by `CommandEventMapper`) into a typed

package/dist/types/managers/cli-output.manager.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Pipe-friendly stdout primitives for the CLI. Use this when you need to emit text that
+ * a user might redirect or pipe — help banners, command tables, JSON dumps — and the
+ * `LogHandler` pipeline would be wrong because it can be severity-gated, routed to
+ * stderr per-severity, or fanned out to file/Sentry transports. For event narration
+ * ("Compiling X", "Server started"), use `LogHandler` instead.
+ */
+export declare class CliOutput {
+    /**
+     * Writes a message to stdout without a newline.
+     */
+    write(message: string): void;
+    /**
+     * Writes a message to stdout with a newline.
+     */
+    writeLine(message: string): void;
+    /**
+     * Renders an array of objects as a table using Node's `console.table`.
+     */
+    writeTable(rows: any[]): void;
+}

package/dist/types/managers/cli-progress-bar.manager.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Inline progress bar rendered on the current TTY line. Each call clears and redraws
+ * the line, so callers must not interleave other output (LogHandler narration, raw
+ * CliOutput writes, etc.) between updates or the previous bar will be left behind on
+ * the line above.
+ */
+export declare class CliProgressBar {
+    private static readonly FILLED;
+    private static readonly EMPTY;
+    private static readonly CYAN;
+    private static readonly RESET;
+    /**
+     * Renders the progress bar at the current line. When `current >= total` the cursor
+     * is advanced to the next line so subsequent output doesn't overwrite the finished bar.
+     */
+    update(current: number, total: number, message?: string, width?: number): void;
+}

package/dist/types/managers/cli-prompt.manager.d.ts

@@ -0,0 +1,22 @@
+import { ConsoleReadlineOptions } from "../options/console-readline.options";
+/**
+ * Interactive stdin reader for CLI commands. Wraps Node's `readline/promises` and offers
+ * a single `readLine` method with optional masking after input is received.
+ */
+export declare class CliPrompt {
+    /**
+     * Reads a string from stdin synchronously. Returns whatever `process.stdin.read()`
+     * gives back (which may be `null` when no data is buffered).
+     */
+    read(): string;
+    /**
+     * Reads a line from stdin after displaying a prompt. When
+     * `options.showCharactersOnTyping` is false, the answered line is cleared and replaced
+     * with a masked echo so the typed value isn't left visible on screen.
+     *
+     * Note: this is not a true keystroke-suppressing password input — Node's stock
+     * `readline` does not support that without raw-mode handling. The current behavior is
+     * a post-input clear, sufficient for most CLI prompts.
+     */
+    readLine(question: string, options?: ConsoleReadlineOptions): Promise<string>;
+}

package/dist/types/managers/cli-spinner.manager.d.ts

@@ -0,0 +1,34 @@
+import { LogHandlerInterface } from "@pristine-ts/logging";
+/**
+ * Animated spinner for indicating long-running work in a TTY. Hides the cursor while
+ * spinning, redraws the current line every 80ms, and routes the completion message
+ * through the injected `LogHandler` so success/failure rendering matches the rest of
+ * the framework.
+ *
+ * Avoid emitting other output (especially LogHandler narration) while the spinner is
+ * active — concurrent writes will fight the spinner's line clearing and produce visual
+ * artifacts.
+ */
+export declare class CliSpinner {
+    private readonly logHandler;
+    private spinnerInterval;
+    private isSpinning;
+    private static readonly FRAMES;
+    private static readonly FRAME_INTERVAL_MS;
+    private static readonly CYAN;
+    private static readonly RESET;
+    private static readonly HIDE_CURSOR;
+    private static readonly SHOW_CURSOR;
+    constructor(logHandler: LogHandlerInterface);
+    /**
+     * Starts the spinner with the given label. Subsequent calls are no-ops until `stop()`
+     * is invoked.
+     */
+    start(message: string): void;
+    /**
+     * Stops the spinner, restores the cursor, and optionally emits a final completion
+     * message. `success` controls whether the message is rendered as a success log
+     * (`logHandler.success`) or an error log (`logHandler.error`).
+     */
+    stop(message?: string, success?: boolean): void;
+}

package/dist/types/managers/managers.d.ts

@@ -1,2 +1,5 @@
-export * from "./console.manager";
+export * from "./cli-output.manager";
+export * from "./cli-progress-bar.manager";
+export * from "./cli-prompt.manager";
+export * from "./cli-spinner.manager";
 export * from "./shell.manager";

package/dist/types/managers/shell.manager.d.ts

@@ -1,12 +1,12 @@
 import { ChildProcessWithoutNullStreams } from "child_process";
-import { ConsoleManager } from "./console.manager";
 import { PathManager } from "@pristine-ts/core";
 import { DateUtil } from "@pristine-ts/common";
+import { LogHandlerInterface } from "@pristine-ts/logging";
 export declare class ShellManager {
-    private readonly consoleManager;
+    private readonly logHandler;
     private readonly pathManager;
     private readonly dateUtil;
-    constructor(consoleManager: ConsoleManager, pathManager: PathManager, dateUtil: DateUtil);
+    constructor(logHandler: LogHandlerInterface, pathManager: PathManager, dateUtil: DateUtil);
     execute(command: string, options?: {
         directory?: string;
         streamStdout?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pristine-ts/cli",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "",
   "module": "dist/lib/esm/cli.module.js",
   "main": "dist/lib/cjs/cli.module.js",
@@ -25,13 +25,13 @@
   },
   "dependencies": {
     "@inquirer/prompts": "^7.2.0",
-    "@pristine-ts/common": "^2.0.5",
-    "@pristine-ts/core": "^2.0.5",
-    "@pristine-ts/data-mapping": "^2.0.5",
-    "@pristine-ts/data-mapping-common": "^2.0.5",
-    "@pristine-ts/file": "^2.0.5",
-    "@pristine-ts/logging": "^2.0.5",
-    "@pristine-ts/validation": "^2.0.5",
+    "@pristine-ts/common": "^2.0.7",
+    "@pristine-ts/core": "^2.0.7",
+    "@pristine-ts/data-mapping": "^2.0.7",
+    "@pristine-ts/data-mapping-common": "^2.0.7",
+    "@pristine-ts/file": "^2.0.7",
+    "@pristine-ts/logging": "^2.0.7",
+    "@pristine-ts/validation": "^2.0.7",
     "jiti": "^2.4.0",
     "uuid": "^9.0.1"
   },
@@ -72,7 +72,7 @@
       "src/*.{js,ts}"
     ]
   },
-  "gitHead": "9a960b330ee1961bb9a6151ce50257c4d8ccd48d",
+  "gitHead": "8788c711f72b7ebdcec76bc8f6a56d51af143087",
   "repository": {
     "type": "git",
     "url": "https://github.com/magieno/pristine-ts.git",

package/dist/lib/cjs/managers/console.manager.js

@@ -1,277 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsoleManager = void 0;
-const tsyringe_1 = require("tsyringe");
-const common_1 = require("@pristine-ts/common");
-const cli_module_keyname_1 = require("../cli.module.keyname");
-const readline = __importStar(require("node:readline/promises"));
-const node_readline_1 = require("node:readline");
-const node_process_1 = require("node:process");
-const console_readline_options_1 = require("../options/console-readline.options");
-/**
- * ANSI Escape Codes for formatting
- */
-const Colors = {
-    Reset: "\x1b[0m",
-    Bright: "\x1b[1m",
-    Dim: "\x1b[2m",
-    Underscore: "\x1b[4m",
-    Blink: "\x1b[5m",
-    Reverse: "\x1b[7m",
-    Hidden: "\x1b[8m",
-    FgBlack: "\x1b[30m",
-    FgRed: "\x1b[31m",
-    FgGreen: "\x1b[32m",
-    FgYellow: "\x1b[33m",
-    FgBlue: "\x1b[34m",
-    FgMagenta: "\x1b[35m",
-    FgCyan: "\x1b[36m",
-    FgWhite: "\x1b[37m",
-};
-let ConsoleManager = class ConsoleManager {
-    constructor() {
-        this.spinnerInterval = null;
-        this.isSpinning = false;
-    }
-    /**
-     * Writes a message to stdout without a newline.
-     * @param message The message to write.
-     */
-    write(message) {
-        process.stdout.write(message);
-    }
-    /**
-     * Writes a message to stdout with a newline.
-     * @param message The message to write.
-     */
-    writeLine(message) {
-        this.write(message + "\n");
-    }
-    /**
-     * Writes a table to stdout.
-     * @param table The array of objects to display as a table.
-     */
-    writeTable(table) {
-        console.table(table);
-    }
-    /**
-     * Writes an error message in red with an 'Error:' prefix.
-     * @param message The error message to display.
-     */
-    writeError(message) {
-        this.writeLine(`${Colors.FgRed}✖ Error:${Colors.Reset} ${message}`);
-    }
-    /**
-     * Writes a success message in green with a 'Success:' prefix.
-     * @param message The success message to display.
-     */
-    writeSuccess(message) {
-        this.writeLine(`${Colors.FgGreen}✔ Success:${Colors.Reset} ${message}`);
-    }
-    /**
-     * Writes a warning message in yellow with a 'Warning:' prefix.
-     * @param message The warning message to display.
-     */
-    writeWarning(message) {
-        this.writeLine(`${Colors.FgYellow}⚠ Warning:${Colors.Reset} ${message}`);
-    }
-    /**
-     * Writes an info message in cyan with an 'Info:' prefix.
-     * @param message The info message to display.
-     */
-    writeInfo(message) {
-        this.writeLine(`${Colors.FgCyan}ℹ Info:${Colors.Reset} ${message}`);
-    }
-    /**
-     * Starts a loading spinner with a message.
-     *
-     * @param message The message to display next to the spinner.
-     * @remarks
-     * This method hides the cursor and continuously updates the current line.
-     * Avoid calling other write methods while the spinner is active as they may conflict with the spinner's line clearing.
-     */
-    startSpinner(message) {
-        if (this.isSpinning)
-            return;
-        this.isSpinning = true;
-        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-        let i = 0;
-        process.stdout.write('\x1B[?25l'); // Hide cursor
-        this.spinnerInterval = setInterval(() => {
-            (0, node_readline_1.clearLine)(process.stdout, 0);
-            (0, node_readline_1.cursorTo)(process.stdout, 0);
-            const frame = frames[i = (i + 1) % frames.length];
-            process.stdout.write(`${Colors.FgCyan}${frame}${Colors.Reset} ${message}`);
-        }, 80);
-    }
-    /**
-     * Stops the loading spinner and optionally prints a completion message.
-     *
-     * @param message Optional completion message to display.
-     * @param success Whether the operation was successful. Defaults to true.
-     * @remarks
-     * Stops the spinner, shows the cursor, and prints a final success or error message on the same line.
-     */
-    stopSpinner(message, success = true) {
-        if (!this.isSpinning)
-            return;
-        if (this.spinnerInterval) {
-            clearInterval(this.spinnerInterval);
-            this.spinnerInterval = null;
-        }
-        this.isSpinning = false;
-        (0, node_readline_1.clearLine)(process.stdout, 0);
-        (0, node_readline_1.cursorTo)(process.stdout, 0);
-        process.stdout.write('\x1B[?25h'); // Show cursor
-        if (message) {
-            if (success) {
-                this.writeSuccess(message);
-            }
-            else {
-                this.writeError(message);
-            }
-        }
-    }
-    /**
-     * Displays or updates a progress bar.
-     *
-     * @param current The current progress value.
-     * @param total The total value to reach (100%).
-     * @param message Optional message to display next to the bar.
-     * @param width The visual width of the progress bar in characters. Defaults to 30.
-     *
-     * @remarks
-     * This method clears the *current* line and writes the progress bar.
-     *
-     * **Important:** If you call `writeLine()` (or any other method that outputs a newline) between calls to `updateProgressBar()`,
-     * the next call to `updateProgressBar()` will start on the *new* line, leaving the previous progress bar state on the line above.
-     *
-     * **Example of creating artifacts:**
-     * ```typescript
-     * manager.updateProgressBar(10, 100); // Draws bar at line N
-     * manager.writeLine("Log message");   // Moves cursor to line N+1
-     * manager.updateProgressBar(20, 100); // Draws bar at line N+1 (Line N has the old bar)
-     * ```
-     */
-    updateProgressBar(current, total, message = '', width = 30) {
-        const percentage = Math.min(Math.max(current / total, 0), 1);
-        const filledWidth = Math.round(width * percentage);
-        const emptyWidth = width - filledWidth;
-        const filledBar = '█'.repeat(filledWidth);
-        const emptyBar = '░'.repeat(emptyWidth);
-        (0, node_readline_1.clearLine)(process.stdout, 0);
-        (0, node_readline_1.cursorTo)(process.stdout, 0);
-        process.stdout.write(`${Colors.FgCyan}[${filledBar}${emptyBar}]${Colors.Reset} ${Math.round(percentage * 100)}% ${message}`);
-        if (current >= total) {
-            this.writeLine(''); // New line on completion
-        }
-    }
-    /**
-     * Reads a string from stdin.
-     * @returns The raw string read from stdin.
-     */
-    read() {
-        return process.stdin.read();
-    }
-    /**
-     * Reads a line from stdin with a prompt.
-     *
-     * @param question The prompt text to display.
-     * @param options Configuration options for the input (e.g., masking characters).
-     * @returns A promise resolving to the user's input string.
-     */
-    readLine(question_1) {
-        return __awaiter(this, arguments, void 0, function* (question, options = new console_readline_options_1.ConsoleReadlineOptions()) {
-            const rl = readline.createInterface({ input: node_process_1.stdin, output: node_process_1.stdout });
-            // If we want to hide characters (e.g. for password), we need to handle output manually-ish,
-            // but readline.question prints the prompt and then echoes input.
-            // A simple hack for passwords with standard readline is tricky without a dedicated library.
-            // However, we can use the 'mute' approach or simple overwriting if we accept some limitations.
-            // For now, adhering to the basic 'question' promise but supporting the 'showCharactersOnTyping' flag logic.
-            let queryPromise;
-            if (!options.showCharactersOnTyping) {
-                // Simple implementation: Ask question, but when user types, we can't easily intercept 'echo' with just createInterface
-                // unless we use a custom input stream or 'muted-stdout' pattern.
-                // Given constraint of no external libraries, we will use a basic workaround:
-                // We will output the question, set stdin to raw mode if possible (for true hiding) 
-                // OR just use the moveCursor trick the previous code had, although that is flaky.
-                // 
-                // Let's rely on the previous implementation's logic:
-                // The previous code did `moveCursor(output, 0, -1)` AFTER the answer was received.
-                // This clears the line AFTER typing. It doesn't hide it WHILE typing.
-                // Real password masking is complex in Node without libs.
-                // We will stick to the previous logic but ensure it's robust.
-                queryPromise = rl.question(question);
-            }
-            else {
-                queryPromise = rl.question(question);
-            }
-            const answer = yield queryPromise;
-            if (!options.showCharactersOnTyping) {
-                // Move up one line and clear it to hide the password typed
-                (0, node_readline_1.moveCursor)(node_process_1.stdout, 0, -1);
-                (0, node_readline_1.clearLine)(node_process_1.stdout, 0);
-                // We might want to re-print the question without the answer? 
-                // Or just leave it cleared. The previous code just moved cursor.
-                // Let's just print a confirmation.
-                this.writeLine(`${question} [******]`);
-            }
-            rl.close();
-            return answer;
-        });
-    }
-};
-exports.ConsoleManager = ConsoleManager;
-exports.ConsoleManager = ConsoleManager = __decorate([
-    (0, tsyringe_1.injectable)(),
-    (0, common_1.moduleScoped)(cli_module_keyname_1.CliModuleKeyname)
-], ConsoleManager);
-//# sourceMappingURL=console.manager.js.map