@kya-os/cli 1.1.0 → 1.2.1

package/dist/effects/types.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Core types and interfaces for the Terminal Effects Engine
+ * Based on TerminalTextEffects Python library architecture
+ */
+/**
+ * RGB color string in hex format (without #)
+ */
+export type RGBColor = string;
+/**
+ * XTerm 256 color code
+ */
+export type XTermColor = number;
+/**
+ * Color can be RGB hex or XTerm-256
+ */
+export type Color = RGBColor | XTermColor | null;
+/**
+ * Color pair for foreground and background
+ */
+export interface ColorPair {
+    fg: Color;
+    bg: Color;
+}
+/**
+ * Character visual state at a point in time
+ */
+export interface CharacterVisual {
+    symbol: string;
+    colors: ColorPair;
+}
+/**
+ * Single frame of animation
+ */
+export interface Frame {
+    characters: CharacterVisual[];
+    duration?: number;
+}
+/**
+ * Terminal dimensions
+ */
+export interface TerminalDimensions {
+    width: number;
+    height: number;
+}
+/**
+ * Coordinate in 2D space
+ */
+export interface Coordinate {
+    x: number;
+    y: number;
+}
+/**
+ * Animation easing function
+ */
+export type EasingFunction = (t: number) => number;
+/**
+ * Effect configuration options
+ */
+export interface EffectConfig {
+    /** Target frame rate (fps) */
+    frameRate: number;
+    /** Use XTerm colors instead of RGB */
+    useXTermColors: boolean;
+    /** Disable all colors */
+    noColor: boolean;
+    /** Canvas dimensions */
+    canvas?: TerminalDimensions;
+    /** Custom parameters for specific effects */
+    [key: string]: any;
+}
+/**
+ * Base interface for all effects
+ */
+export interface Effect {
+    /** Effect name for identification */
+    readonly name: string;
+    /** Effect description */
+    readonly description: string;
+    /** Initialize the effect with text and config */
+    initialize(text: string, config: Partial<EffectConfig>): void;
+    /** Render the next frame of the effect */
+    render(): Promise<string[]>;
+    /** Render fallback plain text version */
+    renderFallback(): string[];
+    /** Check if the effect is complete */
+    isComplete(): boolean;
+    /** Reset the effect to initial state */
+    reset(): void;
+    /** Cleanup any resources */
+    cleanup(): void;
+}
+/**
+ * Scene represents a sequence of visual changes
+ */
+export interface Scene {
+    id: string;
+    frames: Frame[];
+    isLooping: boolean;
+    currentFrame: number;
+}
+/**
+ * Motion path for character movement
+ */
+export interface Path {
+    waypoints: Coordinate[];
+    currentPosition: number;
+    easing?: EasingFunction;
+}
+/**
+ * Character state including position and animation
+ */
+export interface EffectCharacter {
+    id: string;
+    originalSymbol: string;
+    originalPosition: Coordinate;
+    currentPosition: Coordinate;
+    visual: CharacterVisual;
+    motion?: Path;
+    scene?: Scene;
+}
+/**
+ * Effect execution result
+ */
+export interface EffectResult {
+    success: boolean;
+    frames?: string[];
+    error?: Error;
+    duration?: number;
+}
+/**
+ * Terminal capability detection result
+ */
+export interface TerminalCapabilities {
+    supportsColor: boolean;
+    supports256Color: boolean;
+    supportsTrueColor: boolean;
+    dimensions: TerminalDimensions;
+    isInteractive: boolean;
+}
+/**
+ * Effect registry entry
+ */
+export interface EffectRegistryEntry {
+    name: string;
+    description: string;
+    factory: () => Effect;
+}
+/**
+ * Safety configuration for effects
+ */
+export interface SafetyConfig {
+    /** Maximum execution time in milliseconds */
+    maxExecutionTime: number;
+    /** Maximum memory usage in MB */
+    maxMemoryUsage: number;
+    /** Enable performance monitoring */
+    enableMonitoring: boolean;
+    /** Force fallback mode */
+    forceFallback: boolean;
+}
+/**
+ * Performance metrics for monitoring
+ */
+export interface PerformanceMetrics {
+    frameCount: number;
+    totalDuration: number;
+    averageFrameTime: number;
+    maxFrameTime: number;
+    memoryUsage: number;
+}
+/**
+ * Abstract base class for effects
+ */
+export declare abstract class BaseEffect implements Effect {
+    abstract readonly name: string;
+    abstract readonly description: string;
+    protected text: string;
+    protected config: EffectConfig;
+    protected characters: EffectCharacter[];
+    protected frameCount: number;
+    protected isInitialized: boolean;
+    initialize(text: string, config: Partial<EffectConfig>): void;
+    abstract render(): Promise<string[]>;
+    abstract renderFallback(): string[];
+    abstract isComplete(): boolean;
+    reset(): void;
+    cleanup(): void;
+    protected abstract onInitialize(): void;
+    protected abstract onReset(): void;
+    protected onCleanup(): void;
+    protected createCharacters(text: string): EffectCharacter[];
+    protected getCanvasDimensions(): TerminalDimensions;
+}
+/**
+ * Type guard for Color types
+ */
+export declare function isRGBColor(color: Color): color is RGBColor;
+export declare function isXTermColor(color: Color): color is XTermColor;
+//# sourceMappingURL=types.d.ts.map

package/dist/effects/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/effects/types.ts"],"names":[],"mappings":"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"}

package/dist/effects/types.js

@@ -0,0 +1,80 @@
+/**
+ * Core types and interfaces for the Terminal Effects Engine
+ * Based on TerminalTextEffects Python library architecture
+ */
+/**
+ * Abstract base class for effects
+ */
+export class BaseEffect {
+    constructor() {
+        this.text = "";
+        this.config = {
+            frameRate: 30,
+            useXTermColors: false,
+            noColor: false,
+        };
+        this.characters = [];
+        this.frameCount = 0;
+        this.isInitialized = false;
+    }
+    initialize(text, config) {
+        this.text = text;
+        this.config = { ...this.config, ...config };
+        this.characters = this.createCharacters(text);
+        this.isInitialized = true;
+        this.onInitialize();
+    }
+    reset() {
+        this.frameCount = 0;
+        this.characters = this.createCharacters(this.text);
+        this.onReset();
+    }
+    cleanup() {
+        this.characters = [];
+        this.onCleanup();
+    }
+    onCleanup() {
+        // Optional cleanup hook
+    }
+    createCharacters(text) {
+        const lines = text.split("\n");
+        const characters = [];
+        lines.forEach((line, y) => {
+            [...line].forEach((char, x) => {
+                if (char !== " ") {
+                    characters.push({
+                        id: `${x}-${y}`,
+                        originalSymbol: char,
+                        originalPosition: { x, y },
+                        currentPosition: { x, y },
+                        visual: {
+                            symbol: char,
+                            colors: { fg: null, bg: null },
+                        },
+                    });
+                }
+            });
+        });
+        return characters;
+    }
+    getCanvasDimensions() {
+        if (this.config.canvas) {
+            return this.config.canvas;
+        }
+        // Calculate from text if no canvas specified
+        const lines = this.text.split("\n");
+        const height = lines.length;
+        const width = Math.max(...lines.map((line) => line.length));
+        return { width, height };
+    }
+}
+/**
+ * Type guard for Color types
+ */
+export function isRGBColor(color) {
+    return typeof color === "string" && /^[0-9a-fA-F]{6}$/.test(color);
+}
+export function isXTermColor(color) {
+    return typeof color === "number" && color >= 0 && color <= 255;
+}
+//# sourceMappingURL=types.js.map

package/dist/effects/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/effects/types.ts"],"names":[],"mappings":"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"}

package/dist/effects/utils.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Utility functions for terminal effects
+ */
+import { TerminalCapabilities, TerminalDimensions, Color, RGBColor, XTermColor } from "./types.js";
+/**
+ * ANSI escape codes
+ */
+export declare const ANSI: {
+    reset: string;
+    cursor: {
+        hide: string;
+        show: string;
+        save: string;
+        restore: string;
+        home: string;
+        moveTo: (x: number, y: number) => string;
+    };
+    clear: {
+        screen: string;
+        line: string;
+        toEnd: string;
+        toStart: string;
+    };
+    color: {
+        fg: (color: Color) => string;
+        bg: (color: Color) => string;
+    };
+};
+/**
+ * Detect terminal capabilities
+ */
+export declare function detectTerminalCapabilities(): TerminalCapabilities;
+/**
+ * Get terminal dimensions
+ */
+export declare function getTerminalDimensions(): TerminalDimensions;
+/**
+ * Convert RGB hex to XTerm-256 color
+ * Based on the algorithm from https://github.com/Qix-/color-convert
+ */
+export declare function rgbToXterm(hex: RGBColor): XTermColor;
+/**
+ * Strip ANSI codes from string
+ */
+export declare function stripAnsi(str: string): string;
+/**
+ * Measure the visible length of a string (excluding ANSI codes)
+ */
+export declare function measureString(str: string): number;
+/**
+ * Pad string to specified width (accounting for ANSI codes)
+ */
+export declare function padString(str: string, width: number, align?: "left" | "right" | "center"): string;
+/**
+ * Create a buffer for double-buffered rendering
+ */
+export declare class RenderBuffer {
+    private buffer;
+    private width;
+    private height;
+    constructor(width: number, height: number);
+    clear(): void;
+    setChar(x: number, y: number, char: string, color?: string): void;
+    toString(): string;
+    getLines(): string[];
+}
+/**
+ * Sleep for specified milliseconds
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Calculate FPS delay from frame rate
+ */
+export declare function calculateFrameDelay(fps: number): number;
+/**
+ * Easing functions for smooth animations
+ */
+export declare const Easing: {
+    linear: (t: number) => number;
+    easeIn: (t: number) => number;
+    easeOut: (t: number) => number;
+    easeInOut: (t: number) => number;
+    easeInCubic: (t: number) => number;
+    easeOutCubic: (t: number) => number;
+    easeInOutCubic: (t: number) => number;
+    easeInOutSine: (t: number) => number;
+};
+export declare const easeInQuad: (t: number) => number;
+export declare const easeOutQuad: (t: number) => number;
+export declare const easeInOutQuad: (t: number) => number;
+export declare const easeInOutSine: (t: number) => number;
+/**
+ * Interpolate between two values
+ */
+export declare function lerp(start: number, end: number, t: number): number;
+/**
+ * Clamp a value between min and max
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Create a gradient between two colors
+ */
+export declare function createGradient(startColor: RGBColor, endColor: RGBColor, steps: number): RGBColor[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/effects/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/effects/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,KAAK,EACL,QAAQ,EACR,UAAU,EAGX,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,eAAO,MAAM,IAAI;;;;;;;;oBAQD,MAAM,KAAK,MAAM;;;;;;;;;oBASjB,KAAK;oBAWL,KAAK;;CAYpB,CAAC;AAEF;;GAEG;AACH,wBAAgB,0BAA0B,IAAI,oBAAoB,CAWjE;AA6BD;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,kBAAkB,CAS1D;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,QAAQ,GAAG,UAAU,CA2DpD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,KAAK,GAAE,MAAM,GAAG,OAAO,GAAG,QAAiB,GAC1C,MAAM,CAcR;AAED;;GAEG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,MAAM,CAAS;gBAEX,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAMzC,KAAK,IAAI,IAAI;IAMb,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAMjE,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,MAAM,EAAE;CAGrB;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGvD;AAED;;GAEG;AACH,eAAO,MAAM,MAAM;gBACL,MAAM;gBACN,MAAM;iBACL,MAAM;mBACJ,MAAM;qBACJ,MAAM;sBACL,MAAM;wBACJ,MAAM;uBAEP,MAAM;CAC1B,CAAC;AAGF,eAAO,MAAM,UAAU,MAXT,MAAM,WAWmB,CAAC;AACxC,eAAO,MAAM,WAAW,MAXT,MAAM,WAWoB,CAAC;AAC1C,eAAO,MAAM,aAAa,MAXT,MAAM,WAWsB,CAAC;AAC9C,eAAO,MAAM,aAAa,MAPL,MAAM,WAOsB,CAAC;AAElD;;GAEG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,QAAQ,EACpB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,GACZ,QAAQ,EAAE,CAyBZ"}

package/dist/effects/utils.js

@@ -0,0 +1,280 @@
+/**
+ * Utility functions for terminal effects
+ */
+import { isRGBColor, isXTermColor, } from "./types.js";
+/**
+ * ANSI escape codes
+ */
+export const ANSI = {
+    reset: "\x1b[0m",
+    cursor: {
+        hide: "\x1b[?25l",
+        show: "\x1b[?25h",
+        save: "\x1b[s",
+        restore: "\x1b[u",
+        home: "\x1b[H",
+        moveTo: (x, y) => `\x1b[${y + 1};${x + 1}H`,
+    },
+    clear: {
+        screen: "\x1b[2J",
+        line: "\x1b[2K",
+        toEnd: "\x1b[0J",
+        toStart: "\x1b[1J",
+    },
+    color: {
+        fg: (color) => {
+            if (isRGBColor(color)) {
+                const r = parseInt(color.substr(0, 2), 16);
+                const g = parseInt(color.substr(2, 2), 16);
+                const b = parseInt(color.substr(4, 2), 16);
+                return `\x1b[38;2;${r};${g};${b}m`;
+            }
+            else if (isXTermColor(color)) {
+                return `\x1b[38;5;${color}m`;
+            }
+            return "";
+        },
+        bg: (color) => {
+            if (isRGBColor(color)) {
+                const r = parseInt(color.substr(0, 2), 16);
+                const g = parseInt(color.substr(2, 2), 16);
+                const b = parseInt(color.substr(4, 2), 16);
+                return `\x1b[48;2;${r};${g};${b}m`;
+            }
+            else if (isXTermColor(color)) {
+                return `\x1b[48;5;${color}m`;
+            }
+            return "";
+        },
+    },
+};
+/**
+ * Detect terminal capabilities
+ */
+export function detectTerminalCapabilities() {
+    const isInteractive = process.stdout.isTTY || false;
+    const colorLevel = getColorLevel();
+    return {
+        supportsColor: colorLevel > 0,
+        supports256Color: colorLevel >= 2,
+        supportsTrueColor: colorLevel >= 3,
+        dimensions: getTerminalDimensions(),
+        isInteractive,
+    };
+}
+/**
+ * Get color support level
+ * 0 = no color, 1 = basic color, 2 = 256 color, 3 = true color
+ */
+function getColorLevel() {
+    if (process.env.NO_COLOR || process.env.TERM === "dumb") {
+        return 0;
+    }
+    if (process.env.COLORTERM === "truecolor" ||
+        process.env.TERM_PROGRAM === "iTerm.app") {
+        return 3;
+    }
+    if (process.env.TERM && /256/.test(process.env.TERM)) {
+        return 2;
+    }
+    if (process.stdout.hasColors?.()) {
+        return process.stdout.hasColors(256) ? 2 : 1;
+    }
+    return 0;
+}
+/**
+ * Get terminal dimensions
+ */
+export function getTerminalDimensions() {
+    if (process.stdout.isTTY) {
+        return {
+            width: process.stdout.columns || 80,
+            height: process.stdout.rows || 24,
+        };
+    }
+    return { width: 80, height: 24 };
+}
+/**
+ * Convert RGB hex to XTerm-256 color
+ * Based on the algorithm from https://github.com/Qix-/color-convert
+ */
+export function rgbToXterm(hex) {
+    const r = parseInt(hex.substr(0, 2), 16);
+    const g = parseInt(hex.substr(2, 2), 16);
+    const b = parseInt(hex.substr(4, 2), 16);
+    // Check for exact matches in the basic 16 colors
+    const basicColors = [
+        [0, 0, 0],
+        [128, 0, 0],
+        [0, 128, 0],
+        [128, 128, 0],
+        [0, 0, 128],
+        [128, 0, 128],
+        [0, 128, 128],
+        [192, 192, 192],
+        [128, 128, 128],
+        [255, 0, 0],
+        [0, 255, 0],
+        [255, 255, 0],
+        [0, 0, 255],
+        [255, 0, 255],
+        [0, 255, 255],
+        [255, 255, 255],
+    ];
+    for (let i = 0; i < basicColors.length; i++) {
+        const [br, bg, bb] = basicColors[i];
+        if (r === br && g === bg && b === bb) {
+            return i;
+        }
+    }
+    // Check grayscale
+    if (r === g && g === b) {
+        if (r < 8)
+            return 16;
+        if (r > 248)
+            return 231;
+        return Math.round(((r - 8) / 247) * 24) + 232;
+    }
+    // Use 6x6x6 color cube
+    const levels = [0, 95, 135, 175, 215, 255];
+    const findClosest = (value) => {
+        let minDist = Infinity;
+        let closest = 0;
+        for (let i = 0; i < levels.length; i++) {
+            const dist = Math.abs(value - levels[i]);
+            if (dist < minDist) {
+                minDist = dist;
+                closest = i;
+            }
+        }
+        return closest;
+    };
+    const ri = findClosest(r);
+    const gi = findClosest(g);
+    const bi = findClosest(b);
+    return 16 + 36 * ri + 6 * gi + bi;
+}
+/**
+ * Strip ANSI codes from string
+ */
+export function stripAnsi(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+/**
+ * Measure the visible length of a string (excluding ANSI codes)
+ */
+export function measureString(str) {
+    return stripAnsi(str).length;
+}
+/**
+ * Pad string to specified width (accounting for ANSI codes)
+ */
+export function padString(str, width, align = "left") {
+    const visibleLength = measureString(str);
+    const padding = Math.max(0, width - visibleLength);
+    switch (align) {
+        case "right":
+            return " ".repeat(padding) + str;
+        case "center":
+            const leftPad = Math.floor(padding / 2);
+            const rightPad = padding - leftPad;
+            return " ".repeat(leftPad) + str + " ".repeat(rightPad);
+        default:
+            return str + " ".repeat(padding);
+    }
+}
+/**
+ * Create a buffer for double-buffered rendering
+ */
+export class RenderBuffer {
+    constructor(width, height) {
+        this.buffer = [];
+        this.width = width;
+        this.height = height;
+        this.clear();
+    }
+    clear() {
+        this.buffer = Array(this.height)
+            .fill(null)
+            .map(() => Array(this.width).fill(" "));
+    }
+    setChar(x, y, char, color) {
+        if (x >= 0 && x < this.width && y >= 0 && y < this.height) {
+            this.buffer[y][x] = color ? `${color}${char}${ANSI.reset}` : char;
+        }
+    }
+    toString() {
+        return this.buffer.map((row) => row.join("")).join("\n");
+    }
+    getLines() {
+        return this.buffer.map((row) => row.join(""));
+    }
+}
+/**
+ * Sleep for specified milliseconds
+ */
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Calculate FPS delay from frame rate
+ */
+export function calculateFrameDelay(fps) {
+    if (fps <= 0)
+        return 0;
+    return Math.floor(1000 / fps);
+}
+/**
+ * Easing functions for smooth animations
+ */
+export const Easing = {
+    linear: (t) => t,
+    easeIn: (t) => t * t,
+    easeOut: (t) => t * (2 - t),
+    easeInOut: (t) => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t),
+    easeInCubic: (t) => t * t * t,
+    easeOutCubic: (t) => --t * t * t + 1,
+    easeInOutCubic: (t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1,
+    easeInOutSine: (t) => -(Math.cos(Math.PI * t) - 1) / 2,
+};
+// Export individual easing functions for convenience
+export const easeInQuad = Easing.easeIn;
+export const easeOutQuad = Easing.easeOut;
+export const easeInOutQuad = Easing.easeInOut;
+export const easeInOutSine = Easing.easeInOutSine;
+/**
+ * Interpolate between two values
+ */
+export function lerp(start, end, t) {
+    return start + (end - start) * t;
+}
+/**
+ * Clamp a value between min and max
+ */
+export function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+/**
+ * Create a gradient between two colors
+ */
+export function createGradient(startColor, endColor, steps) {
+    const colors = [];
+    const sr = parseInt(startColor.substr(0, 2), 16);
+    const sg = parseInt(startColor.substr(2, 2), 16);
+    const sb = parseInt(startColor.substr(4, 2), 16);
+    const er = parseInt(endColor.substr(0, 2), 16);
+    const eg = parseInt(endColor.substr(2, 2), 16);
+    const eb = parseInt(endColor.substr(4, 2), 16);
+    for (let i = 0; i < steps; i++) {
+        const t = i / (steps - 1);
+        const r = Math.round(lerp(sr, er, t));
+        const g = Math.round(lerp(sg, eg, t));
+        const b = Math.round(lerp(sb, eb, t));
+        colors.push(r.toString(16).padStart(2, "0") +
+            g.toString(16).padStart(2, "0") +
+            b.toString(16).padStart(2, "0"));
+    }
+    return colors;
+}
+//# sourceMappingURL=utils.js.map