@push.rocks/smartlog 3.0.9 → 3.1.2

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartlog',
-    version: '3.0.9',
+    version: '3.1.2',
     description: 'A minimalistic, distributed, and extensible logging tool supporting centralized log management.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxzQkFBc0I7SUFDNUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLGlHQUFpRztDQUMvRyxDQUFBIn0=

package/dist_ts_source_interactive/index.d.ts

@@ -0,0 +1,137 @@
+declare const spinnerFrames: {
+    dots: string[];
+    line: string[];
+    star: string[];
+    simple: string[];
+};
+declare const colors: {
+    black: string;
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    white: string;
+    gray: string;
+    reset: string;
+};
+/**
+ * A class for creating interactive spinners
+ * Automatically handles non-interactive environments
+ */
+export declare class SmartlogSourceInteractive {
+    private textContent;
+    private currentFrame;
+    private interval;
+    private started;
+    private spinnerStyle;
+    private color;
+    private frames;
+    private frameInterval;
+    private interactive;
+    constructor();
+    /**
+     * Sets the text for the spinner and starts it if not already started
+     */
+    text(textArg: string): void;
+    /**
+     * Starts the spinner animation
+     */
+    private start;
+    /**
+     * Renders the current frame of the spinner
+     */
+    private renderFrame;
+    /**
+     * Stops the spinner
+     */
+    stop(): void;
+    /**
+     * Marks the spinner as successful and optionally displays a success message
+     */
+    finishSuccess(textArg?: string): void;
+    /**
+     * Marks the spinner as failed and optionally displays a failure message
+     */
+    finishFail(textArg?: string): void;
+    /**
+     * Marks the current spinner as successful and starts a new one
+     */
+    successAndNext(textArg: string): void;
+    /**
+     * Marks the current spinner as failed and starts a new one
+     */
+    failAndNext(textArg: string): void;
+    /**
+     * Sets the spinner style
+     */
+    setSpinnerStyle(style: keyof typeof spinnerFrames): this;
+    /**
+     * Sets the spinner color
+     */
+    setColor(colorName: keyof typeof colors): this;
+    /**
+     * Sets the animation speed in milliseconds
+     */
+    setSpeed(ms: number): this;
+    /**
+     * Gets the current started state
+     */
+    isStarted(): boolean;
+}
+export interface IProgressBarOptions {
+    total: number;
+    width?: number;
+    complete?: string;
+    incomplete?: string;
+    renderThrottle?: number;
+    clear?: boolean;
+    showEta?: boolean;
+    showPercent?: boolean;
+    showCount?: boolean;
+}
+export declare class SmartlogProgressBar {
+    private total;
+    private current;
+    private width;
+    private completeChar;
+    private incomplete;
+    private renderThrottle;
+    private clear;
+    private showEta;
+    private showPercent;
+    private showCount;
+    private color;
+    private startTime;
+    private lastRenderTime;
+    private interactive;
+    private lastLoggedPercent;
+    private logThreshold;
+    constructor(options: IProgressBarOptions);
+    /**
+     * Update the progress bar to a specific value
+     */
+    update(value: number): this;
+    /**
+     * Increment the progress bar by a value
+     */
+    increment(value?: number): this;
+    /**
+     * Mark the progress bar as complete
+     */
+    complete(): this;
+    /**
+     * Set the color of the progress bar
+     */
+    setColor(colorName: keyof typeof colors): this;
+    /**
+     * Render the progress bar
+     */
+    private render;
+}
+export declare class SmartlogSourceOra extends SmartlogSourceInteractive {
+    get oraInstance(): any;
+    set oraInstance(value: any);
+}
+export {};

package/dist_ts_source_interactive/index.js

@@ -0,0 +1,345 @@
+import * as plugins from './smartlog-source-interactive.plugins.js';
+/**
+ * Utility to detect if the environment is interactive
+ * Checks for TTY capability and common CI environment variables
+ */
+const isInteractive = () => {
+    try {
+        return Boolean(
+        // Check TTY capability
+        process.stdout && process.stdout.isTTY &&
+            // Additional checks for non-interactive environments
+            !('CI' in process.env) &&
+            !process.env.GITHUB_ACTIONS &&
+            !process.env.JENKINS_URL &&
+            !process.env.GITLAB_CI &&
+            !process.env.TRAVIS &&
+            !process.env.CIRCLECI &&
+            process.env.TERM !== 'dumb');
+    }
+    catch (e) {
+        // If any error occurs (e.g., in browser environments without process),
+        // assume a non-interactive environment to be safe
+        return false;
+    }
+};
+// Helper to log messages in non-interactive mode
+const logMessage = (message, prefix = '') => {
+    if (prefix) {
+        console.log(`${prefix} ${message}`);
+    }
+    else {
+        console.log(message);
+    }
+};
+// Spinner frames and styles
+const spinnerFrames = {
+    dots: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
+    line: ['|', '/', '-', '\\'],
+    star: ['✶', '✸', '✹', '✺', '✹', '✷'],
+    simple: ['-', '\\', '|', '/']
+};
+// Color names mapping to ANSI color codes
+const colors = {
+    black: '\u001b[30m',
+    red: '\u001b[31m',
+    green: '\u001b[32m',
+    yellow: '\u001b[33m',
+    blue: '\u001b[34m',
+    magenta: '\u001b[35m',
+    cyan: '\u001b[36m',
+    white: '\u001b[37m',
+    gray: '\u001b[90m',
+    reset: '\u001b[0m'
+};
+/**
+ * A class for creating interactive spinners
+ * Automatically handles non-interactive environments
+ */
+export class SmartlogSourceInteractive {
+    constructor() {
+        this.textContent = 'loading';
+        this.currentFrame = 0;
+        this.interval = null;
+        this.started = false;
+        this.spinnerStyle = 'dots';
+        this.color = 'cyan';
+        this.frameInterval = 80;
+        this.frames = spinnerFrames[this.spinnerStyle];
+        this.interactive = isInteractive();
+    }
+    /**
+     * Sets the text for the spinner and starts it if not already started
+     */
+    text(textArg) {
+        this.textContent = textArg;
+        if (!this.interactive) {
+            // In non-interactive mode, just log the message with a loading indicator
+            logMessage(textArg, '[Loading]');
+            this.started = true;
+            return;
+        }
+        if (!this.started) {
+            this.started = true;
+            this.start();
+        }
+        else {
+            this.renderFrame();
+        }
+    }
+    /**
+     * Starts the spinner animation
+     */
+    start() {
+        if (!this.interactive) {
+            return; // No animation in non-interactive mode
+        }
+        if (this.interval) {
+            clearInterval(this.interval);
+        }
+        this.renderFrame();
+        this.interval = setInterval(() => {
+            this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+            this.renderFrame();
+        }, this.frameInterval);
+    }
+    /**
+     * Renders the current frame of the spinner
+     */
+    renderFrame() {
+        if (!this.started || !this.interactive)
+            return;
+        const frame = this.frames[this.currentFrame];
+        const colorCode = colors[this.color];
+        const resetCode = colors.reset;
+        // Only use ANSI escape codes in interactive mode
+        process.stdout.write('\r\x1b[2K'); // Clear the current line
+        process.stdout.write(`${colorCode}${frame}${resetCode} ${this.textContent}`);
+    }
+    /**
+     * Stops the spinner
+     */
+    stop() {
+        // Always clear the interval even in non-interactive mode
+        // This prevents memory leaks in tests and long-running applications
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        if (!this.interactive) {
+            return; // No need to clear the line in non-interactive mode
+        }
+        process.stdout.write('\r\x1b[2K'); // Clear the current line
+    }
+    /**
+     * Marks the spinner as successful and optionally displays a success message
+     */
+    finishSuccess(textArg) {
+        const message = textArg || this.textContent;
+        // Always stop the spinner first to clean up intervals
+        this.stop();
+        if (!this.interactive) {
+            logMessage(message, '[Success]');
+        }
+        else {
+            const successSymbol = colors.green + '✓' + colors.reset;
+            process.stdout.write(`${successSymbol} ${message}\n`);
+        }
+        this.started = false;
+    }
+    /**
+     * Marks the spinner as failed and optionally displays a failure message
+     */
+    finishFail(textArg) {
+        const message = textArg || this.textContent;
+        // Always stop the spinner first to clean up intervals
+        this.stop();
+        if (!this.interactive) {
+            logMessage(message, '[Failed]');
+        }
+        else {
+            const failSymbol = colors.red + '✗' + colors.reset;
+            process.stdout.write(`${failSymbol} ${message}\n`);
+        }
+        this.started = false;
+    }
+    /**
+     * Marks the current spinner as successful and starts a new one
+     */
+    successAndNext(textArg) {
+        this.finishSuccess();
+        this.text(textArg);
+    }
+    /**
+     * Marks the current spinner as failed and starts a new one
+     */
+    failAndNext(textArg) {
+        this.finishFail();
+        this.text(textArg);
+    }
+    /**
+     * Sets the spinner style
+     */
+    setSpinnerStyle(style) {
+        this.spinnerStyle = style;
+        this.frames = spinnerFrames[style];
+        return this;
+    }
+    /**
+     * Sets the spinner color
+     */
+    setColor(colorName) {
+        if (colorName in colors) {
+            this.color = colorName;
+        }
+        return this;
+    }
+    /**
+     * Sets the animation speed in milliseconds
+     */
+    setSpeed(ms) {
+        this.frameInterval = ms;
+        if (this.started) {
+            this.stop();
+            this.start();
+        }
+        return this;
+    }
+    /**
+     * Gets the current started state
+     */
+    isStarted() {
+        return this.started;
+    }
+}
+export class SmartlogProgressBar {
+    constructor(options) {
+        this.current = 0;
+        this.color = 'green';
+        this.startTime = null;
+        this.lastRenderTime = 0;
+        this.lastLoggedPercent = 0;
+        this.logThreshold = 10; // Log every 10% in non-interactive mode
+        this.total = options.total;
+        this.width = options.width || 30;
+        this.completeChar = options.complete || '█';
+        this.incomplete = options.incomplete || '░';
+        this.renderThrottle = options.renderThrottle || 16;
+        this.clear = options.clear !== undefined ? options.clear : false;
+        this.showEta = options.showEta !== undefined ? options.showEta : true;
+        this.showPercent = options.showPercent !== undefined ? options.showPercent : true;
+        this.showCount = options.showCount !== undefined ? options.showCount : true;
+        this.interactive = isInteractive();
+    }
+    /**
+     * Update the progress bar to a specific value
+     */
+    update(value) {
+        if (this.startTime === null) {
+            this.startTime = Date.now();
+        }
+        this.current = Math.min(value, this.total);
+        if (!this.interactive) {
+            // In non-interactive mode, log progress at certain thresholds
+            const percent = Math.floor((this.current / this.total) * 100);
+            const currentThreshold = Math.floor(percent / this.logThreshold) * this.logThreshold;
+            if (currentThreshold > this.lastLoggedPercent || percent === 100) {
+                this.lastLoggedPercent = currentThreshold;
+                logMessage(`Progress: ${percent}% (${this.current}/${this.total})`);
+            }
+            return this;
+        }
+        // Throttle rendering to avoid excessive updates in interactive mode
+        const now = Date.now();
+        if (now - this.lastRenderTime < this.renderThrottle) {
+            return this;
+        }
+        this.lastRenderTime = now;
+        this.render();
+        return this;
+    }
+    /**
+     * Increment the progress bar by a value
+     */
+    increment(value = 1) {
+        return this.update(this.current + value);
+    }
+    /**
+     * Mark the progress bar as complete
+     */
+    complete() {
+        this.update(this.total);
+        if (!this.interactive) {
+            logMessage(`Completed: 100% (${this.total}/${this.total})`);
+            return this;
+        }
+        if (this.clear) {
+            process.stdout.write('\r\x1b[2K');
+        }
+        else {
+            process.stdout.write('\n');
+        }
+        return this;
+    }
+    /**
+     * Set the color of the progress bar
+     */
+    setColor(colorName) {
+        if (colorName in colors) {
+            this.color = colorName;
+        }
+        return this;
+    }
+    /**
+     * Render the progress bar
+     */
+    render() {
+        if (!this.interactive) {
+            return; // Don't render in non-interactive mode
+        }
+        // Calculate percent complete
+        const percent = Math.floor((this.current / this.total) * 100);
+        const completeLength = Math.round((this.current / this.total) * this.width);
+        const incompleteLength = this.width - completeLength;
+        // Build the progress bar
+        const completePart = colors[this.color] + this.completeChar.repeat(completeLength) + colors.reset;
+        const incompletePart = this.incomplete.repeat(incompleteLength);
+        const progressBar = `[${completePart}${incompletePart}]`;
+        // Calculate ETA if needed
+        let etaStr = '';
+        if (this.showEta && this.startTime !== null && this.current > 0) {
+            const elapsed = (Date.now() - this.startTime) / 1000;
+            const rate = this.current / elapsed;
+            const remaining = Math.max(0, this.total - this.current);
+            const eta = Math.round(remaining / rate);
+            const mins = Math.floor(eta / 60);
+            const secs = eta % 60;
+            etaStr = ` eta: ${mins}m${secs}s`;
+        }
+        // Build additional information
+        const percentStr = this.showPercent ? ` ${percent}%` : '';
+        const countStr = this.showCount ? ` ${this.current}/${this.total}` : '';
+        // Clear the line and render
+        process.stdout.write('\r\x1b[2K');
+        process.stdout.write(`${progressBar}${percentStr}${countStr}${etaStr}`);
+    }
+}
+// For backward compatibility with 'source-ora' module
+export class SmartlogSourceOra extends SmartlogSourceInteractive {
+    // Add a stub for the oraInstance property for backward compatibility
+    get oraInstance() {
+        // Use public methods instead of accessing private properties
+        const instance = this;
+        return {
+            get text() { return ''; }, // We can't access private textContent directly
+            start: () => instance.text(''), // This starts the spinner
+            stop: () => instance.stop(),
+            succeed: (text) => instance.finishSuccess(text),
+            fail: (text) => instance.finishFail(text)
+        };
+    }
+    set oraInstance(value) {
+        // No-op, just for compatibility
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts_source_interactive/index.ts"],"names":[],"mappings":"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"}

package/dist_ts_source_interactive/smartlog-source-interactive.plugins.d.ts

@@ -0,0 +1,5 @@
+import * as smartlogInterfaces from '../dist_ts_interfaces/index.js';
+import * as consolecolor from '@push.rocks/consolecolor';
+export { smartlogInterfaces, consolecolor };
+import { stdout, stderr } from 'process';
+export { stdout, stderr };

package/dist_ts_source_interactive/smartlog-source-interactive.plugins.js

@@ -0,0 +1,8 @@
+// pushrocks scope
+import * as smartlogInterfaces from '../dist_ts_interfaces/index.js';
+import * as consolecolor from '@push.rocks/consolecolor';
+export { smartlogInterfaces, consolecolor };
+// node.js internal
+import { stdout, stderr } from 'process';
+export { stdout, stderr };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRsb2ctc291cmNlLWludGVyYWN0aXZlLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19zb3VyY2VfaW50ZXJhY3RpdmUvc21hcnRsb2ctc291cmNlLWludGVyYWN0aXZlLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsa0JBQWtCO0FBQ2xCLE9BQU8sS0FBSyxrQkFBa0IsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNyRSxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBRXpELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxZQUFZLEVBQUUsQ0FBQztBQUU1QyxtQkFBbUI7QUFDbkIsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFFekMsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsQ0FBQyJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartlog",
-  "version": "3.0.9",
+  "version": "3.1.2",
   "private": false,
   "description": "A minimalistic, distributed, and extensible logging tool supporting centralized log management.",
   "keywords": [
@@ -25,7 +25,7 @@
     },
     "./context": "./dist_ts_context/index.js",
     "./interfaces": "./dist_ts_interfaces/index.js",
-    "./source-ora": "./dist_ts_source_ora/index.js",
+    "./source-interactive": "./dist_ts_source_interactive/index.js",
     "./destination-clickhouse": "./dist_ts_destination_clickhouse/index.js",
     "./destination-devtools": "./dist_ts_destination_devtools/index.js",
     "./destination-file": "./dist_ts_destination_file/index.js",
@@ -36,12 +36,11 @@
   "author": "Lossless GmbH",
   "license": "MIT",
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.3.2",
+    "@git.zone/tsbuild": "^2.5.1",
     "@git.zone/tsbundle": "^2.2.5",
     "@git.zone/tsrun": "^1.3.3",
-    "@git.zone/tstest": "^1.0.96",
-    "@push.rocks/tapbundle": "^6.0.3",
-    "@types/node": "^22.15.17"
+    "@git.zone/tstest": "^1.7.0",
+    "@types/node": "^22.15.18"
   },
   "dependencies": {
     "@api.global/typedrequest-interfaces": "^3.0.19",
@@ -53,8 +52,7 @@
     "@push.rocks/smartpromise": "^4.2.3",
     "@push.rocks/smarttime": "^4.1.1",
     "@push.rocks/webrequest": "^3.0.37",
-    "@tsclass/tsclass": "^9.2.0",
-    "ora": "^8.2.0"
+    "@tsclass/tsclass": "^9.2.0"
   },
   "files": [
     "ts/**/*",
@@ -81,7 +79,7 @@
     "url": "https://code.foss.global/push.rocks/smartlog/issues"
   },
   "scripts": {
-    "test": "(tstest test/)",
+    "test": "(tstest test/**/*.ts --verbose)",
     "build": "(tsbuild tsfolders --allowimplicitany && tsbundle npm)",
     "format": "(gitzone format)",
     "buildDocs": "tsdoc"

package/readme.md

@@ -60,6 +60,78 @@ defaultLogger.log('warn', 'This is a warning message using the default logger');
 
 This is particularly helpful for simple applications or for initial project setup.
 
+### Interactive Console Features
+
+Smartlog provides interactive console features through the `@push.rocks/smartlog/source-interactive` module:
+
+#### Spinners
+
+Use spinners to show progress for operations:
+
+```typescript
+import { SmartlogSourceInteractive } from '@push.rocks/smartlog/source-interactive';
+
+const spinner = new SmartlogSourceInteractive();
+spinner.text('Loading data...');
+
+// Later, when the operation completes:
+spinner.finishSuccess('Data loaded successfully!');
+// Or if it fails:
+spinner.finishFail('Failed to load data');
+
+// You can chain operations:
+spinner.text('Connecting to server');
+spinner.successAndNext('Fetching records');
+spinner.successAndNext('Processing data');
+spinner.finishSuccess('All done!');
+
+// Customize appearance:
+spinner.setSpinnerStyle('line'); // 'dots', 'line', 'star', or 'simple'
+spinner.setColor('green');       // 'red', 'green', 'yellow', 'blue', etc.
+spinner.setSpeed(100);           // Animation speed in milliseconds
+```
+
+#### Progress Bars
+
+Create progress bars for tracking operation progress:
+
+```typescript
+import { SmartlogProgressBar } from '@push.rocks/smartlog/source-interactive';
+
+const progressBar = new SmartlogProgressBar({
+  total: 100,                // Total number of items
+  width: 40,                 // Width of the progress bar
+  complete: '█',             // Character for completed section
+  incomplete: '░',           // Character for incomplete section
+  showEta: true,             // Show estimated time remaining
+  showPercent: true,         // Show percentage
+  showCount: true            // Show count (e.g., "50/100")
+});
+
+// Update progress
+progressBar.update(50);      // Set to 50% progress
+
+// Or increment
+progressBar.increment(10);   // Increase by 10 units
+
+// Change color
+progressBar.setColor('blue');
+
+// Complete the progress bar
+progressBar.update(100);     // or progressBar.complete();
+```
+
+#### Non-Interactive Environments
+
+Both spinners and progress bars automatically detect non-interactive environments (CI/CD, piped output, non-TTY) and provide fallback text-based output:
+
+```
+[Loading] Loading data...
+Progress: 50% (50/100)
+Progress: 100% (100/100)
+[Success] Data loaded successfully!
+```
+
 ### Extending With Log Destinations
 
 One of the core strengths of `@push.rocks/smartlog` is its ability to work with multiple log destinations, enabling you to log messages not just to the console but also to external logging services or custom destinations.
@@ -121,4 +193,4 @@ Registered at District court Bremen HRB 35230 HB, Germany
 
 For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
 
-By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

package/readme.plan.md

@@ -0,0 +1,101 @@
+# Smartlog Interactive Console Features Plan
+
+## Overview
+
+This document outlines the plan for enhancing the console output capabilities of `@push.rocks/smartlog` by creating a comprehensive interactive console module. This involves renaming the current `ts_source_ora` module to `ts_source_interactive`, implementing our own spinner functionality (removing the ora dependency), and adding new features like progress bars and other interactive elements.
+
+## Implementation Steps
+
+### 1. Rename and Restructure
+
+- Rename directory from `ts_source_ora` to `ts_source_interactive`
+- Update all imports, exports, and references
+- Update package.json exports to reflect new module name
+- Maintain backward compatibility through proper export paths
+
+### 2. Custom Spinner Implementation
+
+- Create a native spinner implementation to replace ora dependency
+- Implement spinner frames and animation timing
+- Maintain API compatibility with current spinner methods:
+  - `text(textArg)` - Set text and start spinner
+  - `stop()` - Stop the spinner
+  - `finishSuccess(textArg?)` - Mark as succeeded
+  - `finishFail(textArg?)` - Mark as failed
+  - `successAndNext(textArg)` - Success and start new spinner
+  - `failAndNext(textArg)` - Fail and start new spinner
+- Add spinner customization options (speed, frames, colors)
+
+### 3. Progress Bar Implementation
+
+- Create a progress bar component with the following features:
+  - Configurable width and style
+  - Percentage display
+  - ETA calculation
+  - Current/total value display
+  - Custom formatting
+  - Theming support
+  - Methods for incrementing and updating
+
+### 4. Additional Interactive Features
+
+- Add indeterminate progress indicator
+- Add multi-line status display
+- Add table formatting for structured data
+- Add interactive prompts/confirmations
+
+### 5. Testing
+
+- Update existing tests to work with new implementation
+- Add tests for new progress bar functionality
+- Add tests for additional interactive features
+- Ensure consistent behavior across platforms
+
+### 6. Documentation
+
+- Update README with examples of new features
+- Add API documentation for all new methods
+- Include usage examples
+
+## Implementation Details
+
+### Progress Bar API
+
+```typescript
+// Creating a progress bar
+const progressBar = new SmartlogProgressBar({
+  total: 100,
+  width: 40,
+  complete: '=',
+  incomplete: ' ',
+  renderThrottle: 100, // ms
+  clearOnComplete: false,
+  showEta: true
+});
+
+// Updating a progress bar
+progressBar.update(50); // Update to 50%
+progressBar.increment(10); // Increment by 10
+progressBar.complete(); // Mark as complete
+```
+
+### Spinner API (maintains compatibility)
+
+```typescript
+// Current API (to be maintained)
+const spinner = new SmartlogSourceInteractive();
+spinner.text('Loading data');
+spinner.finishSuccess('Data loaded successfully');
+
+// New additions
+spinner.setSpinnerStyle('dots'); // Change spinner style
+spinner.setColor('green'); // Change color
+```
+
+## Benefits
+
+- Remove external dependency (ora) for better control and smaller bundle size
+- Provide more interactive console features for improved user experience
+- Maintain consistent API styling across all smartlog modules
+- Improve testability with custom implementation
+- Enable more advanced terminal interactions

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartlog',
-  version: '3.0.9',
+  version: '3.1.2',
   description: 'A minimalistic, distributed, and extensible logging tool supporting centralized log management.'
 }