@vizzly-testing/cli 0.1.0

package/dist/types/utils/config-helpers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Define Vizzly configuration with type hints
+ * @param {import('../types/index.js').VizzlyConfig} config
+ * @returns {import('../types/index.js').VizzlyConfig}
+ */
+export function defineConfig(config: import("../types/index.js").VizzlyConfig): import("../types/index.js").VizzlyConfig;

package/dist/types/utils/config-loader.d.ts

@@ -0,0 +1,22 @@
+export function loadConfig(configPath?: any, cliOverrides?: {}): Promise<{
+    server: {
+        port: number;
+        timeout: number;
+        screenshotPath: string;
+    };
+    build: {
+        name: string;
+        environment: string;
+    };
+    upload: {
+        screenshotsDir: string;
+        batchSize: number;
+        timeout: number;
+    };
+    comparison: {
+        threshold: number;
+    };
+    apiKey: string;
+    apiUrl: string;
+}>;
+export function getScreenshotPaths(config: any): string[];

package/dist/types/utils/console-ui.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Simple console UI utilities for CLI output
+ */
+export class ConsoleUI {
+    constructor(options?: {});
+    colors: {
+        success: any;
+        error: any;
+        warning: any;
+        info: any;
+    };
+    json: any;
+    verbose: any;
+    spinner: NodeJS.Timeout;
+    lastLine: string;
+    /**
+     * Show a success message
+     */
+    success(message: any, data?: {}): void;
+    /**
+     * Show an error message and exit
+     */
+    error(message: any, error?: {}, exitCode?: number): void;
+    /**
+     * Show an info message
+     */
+    info(message: any, data?: {}): void;
+    /**
+     * Show a warning message
+     */
+    warning(message: any, data?: {}): void;
+    /**
+     * Show progress with spinner
+     */
+    progress(message: any, current?: number, total?: number): void;
+    /**
+     * Update a status line in place (for dynamic updates)
+     */
+    updateStatus(line: any, message: any): void;
+    /**
+     * Output structured data
+     */
+    data(data: any): void;
+    /**
+     * Start a spinner with message
+     */
+    startSpinner(message: any): void;
+    /**
+     * Update spinner message and progress
+     */
+    updateSpinner(message: any, current?: number, total?: number): void;
+    currentMessage: string;
+    /**
+     * Stop the spinner
+     */
+    stopSpinner(): void;
+    /**
+     * Clean up on exit
+     */
+    cleanup(): void;
+}

package/dist/types/utils/diagnostics.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Check if required dependencies are available
+ */
+export function checkDependencies(): Promise<{
+    all_ok: boolean;
+    details: {
+        node: {
+            available: boolean;
+            version: string;
+            supported: boolean;
+            message: string;
+            error?: undefined;
+        } | {
+            available: boolean;
+            error: any;
+            version?: undefined;
+            supported?: undefined;
+            message?: undefined;
+        };
+        npm: any;
+        git: any;
+        odiff: {
+            available: boolean;
+            path: any;
+            message: string;
+            error?: undefined;
+        } | {
+            available: boolean;
+            error: any;
+            message: string;
+            path?: undefined;
+        };
+    };
+}>;
+/**
+ * Check API connectivity
+ */
+export function checkApiConnectivity(config: any): Promise<{
+    url: any;
+    has_token: boolean;
+    reachable: boolean;
+    authenticated: boolean;
+} | {
+    error: any;
+    reachable: boolean;
+    authenticated: boolean;
+}>;
+/**
+ * Check terminal capabilities
+ */
+export function checkTerminalCapabilities(): {
+    stdout_is_tty: boolean;
+    stdin_is_tty: boolean;
+    supports_color: boolean;
+    terminal_type: string;
+    columns: number;
+    rows: number;
+};
+/**
+ * Get system information
+ */
+export function getSystemInfo(): {
+    platform: NodeJS.Platform;
+    arch: NodeJS.Architecture;
+    node_version: string;
+    memory_usage: NodeJS.MemoryUsage;
+    uptime: number;
+    working_directory: string;
+};

package/dist/types/utils/environment-config.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Environment Configuration Utility
+ * Centralized access to environment variables with proper defaults
+ */
+/**
+ * Get API token from environment
+ * @returns {string|undefined} API token
+ */
+export function getApiToken(): string | undefined;
+/**
+ * Get API URL from environment
+ * @returns {string} API URL with default
+ */
+export function getApiUrl(): string;
+/**
+ * Get log level from environment
+ * @returns {string} Log level with default
+ */
+export function getLogLevel(): string;
+/**
+ * Get user agent from environment
+ * @returns {string|undefined} User agent string
+ */
+export function getUserAgent(): string | undefined;
+/**
+ * Check if Vizzly is enabled in client
+ * @returns {boolean} Whether Vizzly is enabled
+ */
+export function isVizzlyEnabled(): boolean;
+/**
+ * Get server URL from environment
+ * @returns {string|undefined} Server URL
+ */
+export function getServerUrl(): string | undefined;
+/**
+ * Get build ID from environment
+ * @returns {string|undefined} Build ID
+ */
+export function getBuildId(): string | undefined;
+/**
+ * Check if TDD mode is enabled
+ * @returns {boolean} Whether TDD mode is enabled
+ */
+export function isTddMode(): boolean;
+/**
+ * Set Vizzly enabled state (for client)
+ * @param {boolean} enabled - Whether to enable Vizzly
+ */
+export function setVizzlyEnabled(enabled: boolean): void;
+/**
+ * Get all Vizzly environment variables
+ * @returns {Object} All environment configuration
+ */
+export function getAllEnvironmentConfig(): any;

package/dist/types/utils/environment.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Environment detection utilities for handling CI/interactive environments
+ */
+/**
+ * Check if running in a CI environment
+ * Based on common CI environment variables
+ * @returns {boolean} True if running in CI
+ */
+export function isCI(): boolean;
+/**
+ * Check if stdout supports interactive features
+ * @returns {boolean} True if interactive features are supported
+ */
+export function isInteractiveTerminal(): boolean;
+/**
+ * Determine if interactive mode should be enabled
+ * Takes into account CI detection, TTY support, and explicit flags
+ * @param {Object} options
+ * @param {boolean} [options.noInteractive] - Explicit flag to disable interactive mode
+ * @param {boolean} [options.interactive] - Explicit flag to force interactive mode
+ * @returns {boolean} True if interactive mode should be enabled
+ */
+export function shouldUseInteractiveMode(options?: {
+    noInteractive?: boolean;
+    interactive?: boolean;
+}): boolean;
+/**
+ * Get environment type for logging/debugging
+ * @returns {string} Environment type description
+ */
+export function getEnvironmentType(): string;
+/**
+ * Get detailed environment info for debugging
+ * @returns {Object} Environment details
+ */
+export function getEnvironmentDetails(): any;

package/dist/types/utils/error-messages.d.ts

@@ -0,0 +1,42 @@
+export function formatError(errorCode: any, context?: {}): {
+    message: any;
+    hint?: undefined;
+    docs?: undefined;
+    context?: undefined;
+} | {
+    message: any;
+    hint: any;
+    docs: any;
+    context: {};
+};
+export namespace ERROR_MESSAGES {
+    namespace NO_API_TOKEN {
+        let message: string;
+        let hint: string;
+        let docs: string;
+    }
+    namespace BUILD_CREATION_FAILED {
+        let message_1: string;
+        export { message_1 as message };
+        let hint_1: string;
+        export { hint_1 as hint };
+        let docs_1: string;
+        export { docs_1 as docs };
+    }
+    namespace NO_SCREENSHOTS_FOUND {
+        let message_2: string;
+        export { message_2 as message };
+        let hint_2: string;
+        export { hint_2 as hint };
+        let docs_2: string;
+        export { docs_2 as docs };
+    }
+    namespace PORT_IN_USE {
+        let message_3: string;
+        export { message_3 as message };
+        let hint_3: string;
+        export { hint_3 as hint };
+        let docs_3: string;
+        export { docs_3 as docs };
+    }
+}

package/dist/types/utils/fetch-utils.d.ts

@@ -0,0 +1 @@
+export function fetchWithTimeout(url: any, opts?: {}, ms?: number): Promise<Response>;

package/dist/types/utils/framework-detector.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Detect testing framework from project dependencies
+ * @returns {Promise<string|null>} Detected framework or null
+ */
+export function detectFramework(): Promise<string | null>;

package/dist/types/utils/git.d.ts

@@ -0,0 +1,44 @@
+export function getCommonAncestor(commit1: any, commit2: any, cwd?: string): Promise<string>;
+export function getCurrentCommitSha(cwd?: string): Promise<string>;
+export function getCurrentBranch(cwd?: string): Promise<string>;
+export function getDefaultBranch(cwd?: string): Promise<string>;
+export function generateBuildName(): string;
+/**
+ * Get the current commit message
+ * @param {string} cwd - Working directory
+ * @returns {Promise<string|null>} Commit message or null if not available
+ */
+export function getCommitMessage(cwd?: string): Promise<string | null>;
+/**
+ * Check if the working directory is a git repository
+ * @param {string} cwd - Working directory
+ * @returns {Promise<boolean>}
+ */
+export function isGitRepository(cwd?: string): Promise<boolean>;
+/**
+ * Get git status information
+ * @param {string} cwd - Working directory
+ * @returns {Promise<Object|null>} Git status info or null
+ */
+export function getGitStatus(cwd?: string): Promise<any | null>;
+/**
+ * Detect branch with override support
+ * @param {string} override - Branch override from CLI
+ * @param {string} cwd - Working directory
+ * @returns {Promise<string>}
+ */
+export function detectBranch(override?: string, cwd?: string): Promise<string>;
+/**
+ * Detect commit SHA with override support
+ * @param {string} override - Commit override from CLI
+ * @param {string} cwd - Working directory
+ * @returns {Promise<string|null>}
+ */
+export function detectCommit(override?: string, cwd?: string): Promise<string | null>;
+/**
+ * Generate build name with git information
+ * @param {string} override - Build name override from CLI
+ * @param {string} cwd - Working directory
+ * @returns {Promise<string>}
+ */
+export function generateBuildNameWithGit(override?: string, cwd?: string): Promise<string>;

package/dist/types/utils/help.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Display help information for the CLI
+ * @param {Object} globalOptions - Global CLI options
+ */
+export function showHelp(globalOptions?: any): void;
+/**
+ * Show error for unknown command
+ * @param {string} command - Unknown command name
+ * @param {Object} globalOptions - Global CLI options
+ */
+export function showUnknownCommand(command: string, globalOptions?: any): void;

package/dist/types/utils/image-comparison.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Compare two images and return the difference
+ * @param {Buffer} imageBuffer1 - First image buffer
+ * @param {Buffer} imageBuffer2 - Second image buffer
+ * @param {Object} options - Comparison options
+ * @param {number} options.threshold - Matching threshold (0-1)
+ * @param {boolean} options.ignoreAntialiasing - Ignore antialiasing
+ * @param {boolean} options.ignoreColors - Ignore colors (not supported by odiff)
+ * @param {Array} options.ignoreRegions - Regions to ignore in comparison
+ * @returns {Promise<Object>} Comparison result
+ */
+export function compareImages(imageBuffer1: Buffer, imageBuffer2: Buffer, options?: {
+    threshold: number;
+    ignoreAntialiasing: boolean;
+    ignoreColors: boolean;
+    ignoreRegions: any[];
+}): Promise<any>;
+/**
+ * Check if buffer is a valid PNG image
+ * @param {Buffer} buffer - Image buffer
+ * @returns {boolean} True if valid PNG
+ */
+export function isValidPNG(buffer: Buffer): boolean;
+/**
+ * Get image dimensions from PNG buffer
+ * @param {Buffer} buffer - Image buffer
+ * @returns {Object|null} Dimensions or null if invalid
+ */
+export function getImageDimensions(buffer: Buffer): any | null;
+/**
+ * Compare images with ignore regions
+ * @param {Buffer} imageBuffer1 - First image buffer
+ * @param {Buffer} imageBuffer2 - Second image buffer
+ * @param {Array<{x: number, y: number, width: number, height: number}>} ignoreRegions - Regions to ignore
+ * @returns {Promise<Object>} Comparison result
+ */
+export function compareImagesWithIgnoreRegions(imageBuffer1: Buffer, imageBuffer2: Buffer, ignoreRegions?: Array<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>): Promise<any>;

package/dist/types/utils/logger-factory.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Create a service logger with consistent naming and options
+ * @param {string} serviceName - Name of the service (e.g., 'TDD', 'SERVER', 'API')
+ * @param {Object} options - Logger options
+ * @returns {Logger} Configured logger instance
+ */
+export function createServiceLogger(serviceName: string, options?: any): Logger;
+/**
+ * Create a component logger for CLI commands and utilities
+ * @param {string} componentName - Name of the component
+ * @param {Object} options - Logger options
+ * @returns {Logger} Configured logger instance
+ */
+export function createComponentLogger(componentName: string, options?: any): Logger;
+/**
+ * Create a basic logger with standard defaults
+ * @param {Object} options - Logger options
+ * @returns {Logger} Configured logger instance
+ */
+export function createStandardLogger(options?: any): Logger;
+/**
+ * Create a logger for uploader service with specific defaults
+ * @param {Object} options - Logger options
+ * @returns {Logger} Configured logger instance
+ */
+export function createUploaderLogger(options?: any): Logger;

package/dist/types/utils/logger.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Create default logger instance
+ */
+export function createLogger(options?: {}): Logger;
+/**
+ * Structured logger with multiple output targets and log levels
+ */
+export class Logger {
+    constructor(options?: {});
+    level: any;
+    logFile: any;
+    verbose: any;
+    silent: any;
+    colors: boolean;
+    levels: {
+        error: number;
+        warn: number;
+        info: number;
+        debug: number;
+    };
+    /**
+     * Initialize log file with session header
+     */
+    initLogFile(): void;
+    /**
+     * Check if message should be logged at current level
+     */
+    shouldLog(level: any): boolean;
+    /**
+     * Log a message with specified level
+     */
+    log(level: any, message: any, data?: {}): void;
+    /**
+     * Output formatted message to console
+     */
+    outputToConsole(level: any, message: any, data: any): void;
+    /**
+     * Get colored prefix for log level
+     */
+    getColoredPrefix(level: any): any;
+    /**
+     * Convenience methods
+     */
+    error(message: any, data?: {}): void;
+    warn(message: any, data?: {}): void;
+    info(message: any, data?: {}): void;
+    debug(message: any, data?: {}): void;
+    /**
+     * Log progress updates
+     */
+    progress(stage: any, message: any, data?: {}): void;
+    /**
+     * Log command execution
+     */
+    command(command: any, data?: {}): void;
+    /**
+     * Log performance metrics
+     */
+    perf(operation: any, duration: any, data?: {}): void;
+    /**
+     * Create child logger with additional context
+     */
+    child(context?: {}): ChildLogger;
+}
+/**
+ * Child logger that inherits from parent with additional context
+ */
+declare class ChildLogger {
+    constructor(parent: any, context: any);
+    parent: any;
+    context: any;
+    log(level: any, message: any, data?: {}): void;
+    error(message: any, data?: {}): void;
+    warn(message: any, data?: {}): void;
+    info(message: any, data?: {}): void;
+    debug(message: any, data?: {}): void;
+    progress(stage: any, message: any, data?: {}): void;
+}
+export {};

package/dist/types/utils/package-info.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Get package.json information
+ * @returns {Object} Package.json data
+ */
+export function getPackageInfo(): any;
+/**
+ * Get package version
+ * @returns {string} Package version
+ */
+export function getPackageVersion(): string;
+/**
+ * Get package name
+ * @returns {string} Package name
+ */
+export function getPackageName(): string;

package/dist/types/utils/package.d.ts

@@ -0,0 +1 @@
+export function getPackageInfo(): Promise<any>;

package/dist/types/utils/project-detection.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Detect project type and framework
+ * @param {string} directory - Directory to analyze
+ * @returns {Promise<Object>} Project information
+ */
+export function detectProjectType(directory?: string): Promise<any>;
+/**
+ * Get suggested test command for framework
+ * @param {string} framework - Framework name
+ * @param {Object} packageJson - Package.json content
+ * @returns {string} Suggested test command
+ */
+export function getSuggestedTestCommand(framework: string, packageJson: any): string;
+/**
+ * Get suggested screenshots directory for framework
+ * @param {string} framework - Framework name
+ * @returns {string} Screenshots directory
+ */
+export function getSuggestedScreenshotsDir(framework: string): string;

package/dist/types/utils/ui-helpers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Color and styling utilities for Ink components
+ */
+/**
+ * Check if colors should be used
+ */
+export function shouldUseColors(flags?: {}): boolean;
+/**
+ * Get color for text based on type and color support
+ */
+export function getColor(type: any, flags?: {}): any;
+/**
+ * Get status icon with fallback for no-color mode
+ */
+export function getStatusIcon(status: any, flags?: {}): any;
+/**
+ * Responsive layout helper
+ */
+export function getLayout(columns?: number): {
+    type: string;
+    showDetails: boolean;
+    maxWidth: number;
+};

package/dist/utils/colors.js

@@ -0,0 +1,66 @@
+// Zero-dependency color helper using raw ANSI codes.
+// Detects terminal color support and emits codes only when enabled.
+
+function supportsColorDefault() {
+  // Respect NO_COLOR: https://no-color.org/
+  if ('NO_COLOR' in process.env) return false;
+
+  // Respect FORCE_COLOR if set to a truthy value (except '0')
+  if ('FORCE_COLOR' in process.env) {
+    const v = process.env.FORCE_COLOR;
+    if (v && v !== '0') return true;
+    if (v === '0') return false;
+  }
+
+  // If stdout is not a TTY, assume no color
+  if (!process.stdout || !process.stdout.isTTY) return false;
+
+  // Prefer getColorDepth when available
+  try {
+    const depth = typeof process.stdout.getColorDepth === 'function' ? process.stdout.getColorDepth() : 1;
+    return depth && depth > 1;
+  } catch {
+    // Fallback heuristic
+    return true;
+  }
+}
+function styleFn(open, close, enabled) {
+  return (input = '') => {
+    const str = String(input);
+    if (!enabled) return str;
+    return open + str + close;
+  };
+}
+export function createColors(options = {}) {
+  const enabled = options.useColor !== undefined ? !!options.useColor : supportsColorDefault();
+  const codes = {
+    reset: ['\x1b[0m', ''],
+    bold: ['\x1b[1m', '\x1b[22m'],
+    dim: ['\x1b[2m', '\x1b[22m'],
+    italic: ['\x1b[3m', '\x1b[23m'],
+    underline: ['\x1b[4m', '\x1b[24m'],
+    strikethrough: ['\x1b[9m', '\x1b[29m'],
+    red: ['\x1b[31m', '\x1b[39m'],
+    green: ['\x1b[32m', '\x1b[39m'],
+    yellow: ['\x1b[33m', '\x1b[39m'],
+    blue: ['\x1b[34m', '\x1b[39m'],
+    magenta: ['\x1b[35m', '\x1b[39m'],
+    cyan: ['\x1b[36m', '\x1b[39m'],
+    white: ['\x1b[37m', '\x1b[39m'],
+    gray: ['\x1b[90m', '\x1b[39m']
+  };
+  const api = {};
+  for (const [name, [open, close]] of Object.entries(codes)) {
+    api[name] = styleFn(open, close || '\x1b[0m', enabled);
+  }
+
+  // Semantic aliases
+  api.success = api.green;
+  api.error = api.red;
+  api.warning = api.yellow;
+  api.info = api.blue;
+  return api;
+}
+
+// Default export with auto-detected color support
+export const colors = createColors();

package/dist/utils/config-helpers.js

@@ -0,0 +1,8 @@
+/**
+ * Define Vizzly configuration with type hints
+ * @param {import('../types/index.js').VizzlyConfig} config
+ * @returns {import('../types/index.js').VizzlyConfig}
+ */
+export function defineConfig(config) {
+  return config;
+}