@syrin/cli 1.3.0

package/dist/utils/logger.js

@@ -0,0 +1,330 @@
+/**
+ * Unified logging utility for Syrin.
+ * Combines structured logging with styled console output.
+ */
+import { Icons } from '../constants/icons.js';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["SILENT"] = 4] = "SILENT";
+})(LogLevel || (LogLevel = {}));
+export const Icon = {
+    ERROR: Icons.ERROR,
+    WARNING: Icons.WARNING,
+    TIP: Icons.TIP,
+    SUCCESS: Icons.SUCCESS,
+    FAILURE: Icons.FAILURE,
+    CHECK: Icons.CHECK,
+    FOLDER: Icons.FOLDER,
+    DOCUMENT: Icons.DOCUMENT,
+};
+// ANSI color codes
+const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    cyan: '\x1b[36m',
+    blue: '\x1b[34m',
+};
+/**
+ * Unified logger class with structured logging and styled output.
+ */
+export class Log {
+    level;
+    context;
+    useStructuredLogging;
+    constructor(level = LogLevel.INFO, context = {}, useStructuredLogging = false) {
+        this.level = level;
+        this.context = context;
+        this.useStructuredLogging = useStructuredLogging;
+    }
+    /**
+     * Create a child logger with additional context.
+     */
+    child(additionalContext) {
+        return new Log(this.level, { ...this.context, ...additionalContext }, this.useStructuredLogging);
+    }
+    /**
+     * Set the log level.
+     */
+    setLevel(level) {
+        this.level = level;
+    }
+    /**
+     * Enable or disable structured logging.
+     */
+    setStructuredLogging(enabled) {
+        this.useStructuredLogging = enabled;
+    }
+    /**
+     * Style text with colors and formatting.
+     */
+    style(text, ...styles) {
+        const styleCodes = styles.map(s => colors[s]).join('');
+        return `${styleCodes}${text}${colors.reset}`;
+    }
+    /**
+     * Internal structured logging method.
+     */
+    structuredLog(level, message, context, error) {
+        if (level < this.level) {
+            return;
+        }
+        const mergedContext = {
+            ...this.context,
+        };
+        if (context) {
+            for (const [key, value] of Object.entries(context)) {
+                if (typeof value === 'string' ||
+                    typeof value === 'number' ||
+                    typeof value === 'boolean' ||
+                    value === null ||
+                    value === undefined) {
+                    mergedContext[key] = value;
+                }
+            }
+        }
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            message,
+            context: mergedContext,
+            error,
+        };
+        const levelName = LogLevel[level];
+        const prefix = `[${entry.timestamp}] [${levelName}]`;
+        if (error) {
+            // Use console.error for structured logging errors to maintain proper error output
+            console.error(`${prefix} ${message}`, {
+                ...entry.context,
+                error: error.message,
+                stack: error.stack,
+            });
+        }
+        else if (context && Object.keys(context).length > 0) {
+            // Use console.log for structured logging to maintain proper log format
+            console.log(`${prefix} ${message}`, entry.context);
+        }
+        else {
+            // Use console.log for structured logging to maintain proper log format
+            console.log(`${prefix} ${message}`);
+        }
+    }
+    /**
+     * Print styled text to console.
+     */
+    print(text, ...styles) {
+        if (this.useStructuredLogging) {
+            this.structuredLog(LogLevel.INFO, text);
+        }
+        else {
+            console.log(this.style(text, ...styles));
+        }
+    }
+    // ==================== Unified Logging Methods ====================
+    // These methods behave differently based on useStructuredLogging flag:
+    // - If useStructuredLogging is true: structured logging with levels
+    // - If useStructuredLogging is false: styled output with icons
+    /**
+     * Print a heading (green, bold).
+     */
+    heading(text) {
+        this.print(text, 'bold', 'green');
+    }
+    /**
+     * Print a label (dim).
+     */
+    label(text) {
+        this.print(text, 'dim');
+    }
+    /**
+     * Print a value (cyan).
+     */
+    value(text) {
+        this.print(text, 'cyan');
+    }
+    /**
+     * Log/print success message (green) with success icon.
+     * For structured logging: logs at INFO level
+     * For styled output: prints with green color and success icon
+     */
+    success(text, icon) {
+        if (this.useStructuredLogging) {
+            this.structuredLog(LogLevel.INFO, text);
+        }
+        else {
+            const iconText = icon ? `${icon} ` : `${Icon.SUCCESS} `;
+            this.print(`${iconText}${text}`, 'green');
+        }
+    }
+    /**
+     * Log/print error message (red) with error icon.
+     * For structured logging: logs at ERROR level (can include Error object)
+     * For styled output: prints with red color and error icon
+     */
+    error(message, errorOrIcon, contextOrIcon) {
+        if (this.useStructuredLogging) {
+            // Structured logging: errorOrIcon is Error, contextOrIcon is context
+            const err = errorOrIcon instanceof Error ? errorOrIcon : undefined;
+            const context = errorOrIcon instanceof Error
+                ? contextOrIcon
+                : errorOrIcon;
+            this.structuredLog(LogLevel.ERROR, message, context, err);
+        }
+        else {
+            // Styled output: errorOrIcon is optional Icon
+            const icon = errorOrIcon;
+            const iconText = icon ? `${icon} ` : `${Icon.ERROR} `;
+            this.print(`${iconText}${message}`, 'red');
+        }
+    }
+    warning(text, contextOrIcon) {
+        if (this.useStructuredLogging) {
+            // For structured logging, second param is always context
+            const context = contextOrIcon;
+            this.structuredLog(LogLevel.WARN, text, context);
+        }
+        else {
+            // For styled output, second param is always icon
+            const icon = contextOrIcon;
+            const iconText = icon ? `${icon} ` : `${Icon.WARNING} `;
+            this.print(`${iconText}${text}`, 'yellow');
+        }
+    }
+    warn(text, contextOrIcon) {
+        if (this.useStructuredLogging) {
+            // For structured logging, second param is always context
+            const context = contextOrIcon;
+            this.structuredLog(LogLevel.WARN, text, context);
+        }
+        else {
+            // For styled output, second param is always icon
+            const icon = contextOrIcon;
+            const iconText = icon ? `${icon} ` : `${Icon.WARNING} `;
+            this.print(`${iconText}${text}`, 'yellow');
+        }
+    }
+    info(text, contextOrIcon) {
+        if (this.useStructuredLogging) {
+            // For structured logging, second param is always context
+            const context = contextOrIcon;
+            this.structuredLog(LogLevel.INFO, text, context);
+        }
+        else {
+            // For styled output, second param is always icon
+            const icon = contextOrIcon;
+            const iconText = icon ? `${icon} ` : `${Icon.TIP} `;
+            this.print(`${iconText}${text}`, 'cyan');
+        }
+    }
+    debug(text, contextOrIcon) {
+        if (this.useStructuredLogging) {
+            // For structured logging, second param is always context
+            const context = contextOrIcon;
+            this.structuredLog(LogLevel.DEBUG, text, context);
+        }
+        else {
+            // For styled output, second param is always icon
+            const icon = contextOrIcon;
+            const iconText = icon ? `${icon} ` : '';
+            this.print(`${iconText}${text}`, 'dim');
+        }
+    }
+    /**
+     * Print a line with label and value.
+     */
+    labelValue(labelText, valueText) {
+        const output = `${this.style(labelText, 'dim')} ${this.style(valueText, 'cyan')}`;
+        if (this.useStructuredLogging) {
+            this.structuredLog(LogLevel.INFO, `${labelText} ${valueText}`);
+        }
+        else {
+            console.log(output);
+        }
+    }
+    /**
+     * Print a numbered item.
+     */
+    numberedItem(number, text, ...additionalStyles) {
+        this.print(`${number}. ${text}`, 'bold', 'green', ...additionalStyles);
+    }
+    /**
+     * Print a checkmark with text.
+     */
+    checkmark(text) {
+        this.print(`${Icons.SUCCESS} ${text}`, 'green', 'bold');
+    }
+    /**
+     * Print an X mark with text.
+     */
+    xmark(text) {
+        this.print(`${Icons.FAILURE} ${text}`, 'red', 'bold');
+    }
+    /**
+     * Get a styled tick/checkmark (✓) in green.
+     * Returns a styled string that can be used in other messages.
+     */
+    tick() {
+        return this.styleText(Icons.SUCCESS, 'green');
+    }
+    /**
+     * Get a styled cross/X mark (✗) in red.
+     * Returns a styled string that can be used in other messages.
+     */
+    cross() {
+        return this.styleText(Icons.FAILURE, 'red');
+    }
+    /**
+     * Print a warning symbol with text.
+     */
+    warnSymbol(text) {
+        this.print(`⚠  ${text}`, 'yellow');
+    }
+    /**
+     * Print plain text (no styling).
+     */
+    plain(text) {
+        if (this.useStructuredLogging) {
+            this.structuredLog(LogLevel.INFO, text);
+        }
+        else {
+            console.log(text);
+        }
+    }
+    /**
+     * Print an empty line.
+     */
+    blank() {
+        console.log('');
+    }
+    /**
+     * Style text with colors and formatting (returns styled string).
+     * This is a public method that can be used to get styled strings without printing.
+     */
+    styleText(text, ...styles) {
+        return this.style(text, ...styles);
+    }
+}
+/**
+ * Default logger instance for styled output (non-structured).
+ * Use this for UI/presentation output.
+ */
+export const log = new Log(LogLevel.INFO, {}, false);
+/**
+ * Default structured logger instance.
+ * Use this for application logging with levels and context.
+ */
+export const logger = new Log(LogLevel.INFO, {}, true);
+/**
+ * Create a logger with a specific context.
+ */
+export function createLogger(context) {
+    return logger.child(context);
+}
+//# sourceMappingURL=logger.js.map

package/dist/utils/package-manager.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Package management utilities.
+ * Provides functions to interact with npm for updating/installing packages.
+ */
+export interface InstallResult {
+    success: boolean;
+    error?: string;
+    version?: string;
+}
+/**
+ * Detect if the package is installed globally or locally.
+ */
+export declare function detectInstallType(): 'global' | 'local';
+/**
+ * Update package to latest version.
+ */
+export declare function updatePackage(packageName?: string): Promise<InstallResult>;
+/**
+ * Install a specific version of the package.
+ */
+export declare function installPackageVersion(version: string, packageName?: string): Promise<InstallResult>;
+/**
+ * Validate version string format.
+ */
+export declare function isValidVersion(version: string): boolean;
+/**
+ * Normalize version string (remove 'v' prefix if present).
+ */
+export declare function normalizeVersion(version: string): string;
+//# sourceMappingURL=package-manager.d.ts.map

package/dist/utils/package-manager.js

@@ -0,0 +1,157 @@
+/**
+ * Package management utilities.
+ * Provides functions to interact with npm for updating/installing packages.
+ */
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { PACKAGE_NAME } from '../constants/app.js';
+/**
+ * Detect if the package is installed globally or locally.
+ */
+export function detectInstallType() {
+    // Check if we're running from a global installation
+    // Global npm packages are typically in:
+    // - macOS/Linux: /usr/local/lib/node_modules or ~/.npm-global
+    // - Windows: %APPDATA%\npm\node_modules
+    const packageJsonPath = path.join(__dirname, '../../package.json');
+    const resolvedPath = fs.realpathSync(packageJsonPath);
+    const nodeModulesPath = path.join(resolvedPath, '../../..');
+    // Check if node_modules parent is a global location
+    if (nodeModulesPath.includes('node_modules') &&
+        (nodeModulesPath.includes('npm') ||
+            nodeModulesPath.includes('.npm-global') ||
+            nodeModulesPath.startsWith('/usr/local') ||
+            nodeModulesPath.startsWith('/opt'))) {
+        return 'global';
+    }
+    return 'local';
+}
+/**
+ * Execute npm command and return result.
+ */
+function executeNpmCommand(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const npm = spawn('npm', args, {
+            cwd: cwd || process.cwd(),
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        npm.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        npm.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        npm.on('close', code => {
+            if (code === 0) {
+                resolve({ success: true, stdout, stderr });
+            }
+            else {
+                resolve({ success: false, stdout, stderr });
+            }
+        });
+        npm.on('error', error => {
+            reject(error);
+        });
+    });
+}
+/**
+ * Update package to latest version.
+ */
+export async function updatePackage(packageName = PACKAGE_NAME) {
+    const installType = detectInstallType();
+    const args = installType === 'global'
+        ? ['install', '-g', `${packageName}@latest`]
+        : ['install', `${packageName}@latest`];
+    try {
+        const result = await executeNpmCommand(args);
+        if (result.success) {
+            // Try to get the installed version from package.json
+            const packageJsonPath = path.join(__dirname, '../../package.json');
+            let version;
+            try {
+                if (fs.existsSync(packageJsonPath)) {
+                    const packageJsonContent = fs.readFileSync(packageJsonPath, 'utf-8');
+                    const packageJson = JSON.parse(packageJsonContent);
+                    version = packageJson.version;
+                }
+            }
+            catch {
+                // Ignore errors reading version
+            }
+            return {
+                success: true,
+                version,
+            };
+        }
+        return {
+            success: false,
+            error: result.stderr || 'Update failed',
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Install a specific version of the package.
+ */
+export async function installPackageVersion(version, packageName = PACKAGE_NAME) {
+    const installType = detectInstallType();
+    const args = installType === 'global'
+        ? ['install', '-g', `${packageName}@${version}`]
+        : ['install', `${packageName}@${version}`];
+    try {
+        const result = await executeNpmCommand(args);
+        if (result.success) {
+            // Try to get the installed version from package.json
+            const packageJsonPath = path.join(__dirname, '../../package.json');
+            let installedVersion;
+            try {
+                if (fs.existsSync(packageJsonPath)) {
+                    const packageJsonContent = fs.readFileSync(packageJsonPath, 'utf-8');
+                    const packageJson = JSON.parse(packageJsonContent);
+                    installedVersion = packageJson.version;
+                }
+            }
+            catch {
+                // Ignore errors reading version
+            }
+            return {
+                success: true,
+                version: installedVersion || version,
+            };
+        }
+        return {
+            success: false,
+            error: result.stderr || 'Installation failed',
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Validate version string format.
+ */
+export function isValidVersion(version) {
+    // Basic semver validation: major.minor.patch or vmajor.minor.patch
+    const semverPattern = /^v?\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/;
+    return semverPattern.test(version);
+}
+/**
+ * Normalize version string (remove 'v' prefix if present).
+ */
+export function normalizeVersion(version) {
+    return version.replace(/^v/, '');
+}
+//# sourceMappingURL=package-manager.js.map

package/dist/utils/version-checker.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Version checking utilities.
+ * Provides functions to check current version and compare with npm registry.
+ */
+export interface VersionInfo {
+    current: string;
+    latest?: string;
+    isLatest: boolean;
+    updateAvailable: boolean;
+}
+export interface RegistryPackageInfo {
+    'dist-tags': {
+        latest: string;
+    };
+    versions: Record<string, unknown>;
+}
+/**
+ * Get the current version from package.json.
+ * Works in both development and installed package contexts.
+ */
+export declare function getCurrentVersion(): string;
+/**
+ * Fetch package information from npm registry.
+ */
+export declare function fetchPackageInfo(packageName?: string): Promise<RegistryPackageInfo>;
+/**
+ * Get the latest version from npm registry.
+ */
+export declare function getLatestVersion(packageName?: string): Promise<string | undefined>;
+/**
+ * Compare two version strings using simple semantic version comparison.
+ * Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
+ */
+export declare function compareVersions(v1: string, v2: string): number;
+/**
+ * Check Syrin version information including update availability.
+ */
+export declare function checkSyrinVersion(): Promise<VersionInfo>;
+/**
+ * Check version information including update availability.
+ */
+export declare function checkVersion(packageName?: string): Promise<VersionInfo>;
+/**
+ * Format version string with update information.
+ */
+export declare function formatVersionWithUpdate(versionInfo: VersionInfo, packageName?: string): string;
+//# sourceMappingURL=version-checker.d.ts.map