lsh-framework 0.5.4

package/dist/lib/logger.js

@@ -0,0 +1,274 @@
+/**
+ * Logging Framework
+ * Centralized logging utility with support for different log levels,
+ * structured logging, and environment-based configuration.
+ */
+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["NONE"] = 4] = "NONE";
+})(LogLevel || (LogLevel = {}));
+/**
+ * ANSI color codes for terminal output
+ */
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    // Foreground colors
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    // Background colors
+    bgBlack: '\x1b[40m',
+    bgRed: '\x1b[41m',
+    bgGreen: '\x1b[42m',
+    bgYellow: '\x1b[43m',
+    bgBlue: '\x1b[44m',
+    bgMagenta: '\x1b[45m',
+    bgCyan: '\x1b[46m',
+    bgWhite: '\x1b[47m',
+};
+/**
+ * Get log level from environment variable
+ */
+function getLogLevelFromEnv() {
+    const level = process.env.LSH_LOG_LEVEL?.toUpperCase();
+    switch (level) {
+        case 'DEBUG':
+            return LogLevel.DEBUG;
+        case 'INFO':
+            return LogLevel.INFO;
+        case 'WARN':
+            return LogLevel.WARN;
+        case 'ERROR':
+            return LogLevel.ERROR;
+        case 'NONE':
+            return LogLevel.NONE;
+        default:
+            return process.env.NODE_ENV === 'production' ? LogLevel.INFO : LogLevel.DEBUG;
+    }
+}
+/**
+ * Logger class for structured logging
+ */
+export class Logger {
+    config;
+    constructor(config) {
+        this.config = {
+            level: config?.level ?? getLogLevelFromEnv(),
+            enableTimestamp: config?.enableTimestamp ?? true,
+            enableColors: config?.enableColors ?? (!process.env.NO_COLOR && process.stdout.isTTY),
+            enableJSON: config?.enableJSON ?? (process.env.LSH_LOG_FORMAT === 'json'),
+            context: config?.context,
+        };
+    }
+    /**
+     * Create a child logger with a specific context
+     */
+    child(context) {
+        return new Logger({
+            ...this.config,
+            context: this.config.context ? `${this.config.context}:${context}` : context,
+        });
+    }
+    /**
+     * Set log level dynamically
+     */
+    setLevel(level) {
+        this.config.level = level;
+    }
+    /**
+     * Check if a log level is enabled
+     */
+    isLevelEnabled(level) {
+        return level >= this.config.level;
+    }
+    /**
+     * Format timestamp
+     */
+    formatTimestamp() {
+        const now = new Date();
+        return now.toISOString();
+    }
+    /**
+     * Get level name string
+     */
+    getLevelName(level) {
+        switch (level) {
+            case LogLevel.DEBUG:
+                return 'DEBUG';
+            case LogLevel.INFO:
+                return 'INFO';
+            case LogLevel.WARN:
+                return 'WARN';
+            case LogLevel.ERROR:
+                return 'ERROR';
+            default:
+                return 'UNKNOWN';
+        }
+    }
+    /**
+     * Get color for log level
+     */
+    getLevelColor(level) {
+        switch (level) {
+            case LogLevel.DEBUG:
+                return colors.cyan;
+            case LogLevel.INFO:
+                return colors.green;
+            case LogLevel.WARN:
+                return colors.yellow;
+            case LogLevel.ERROR:
+                return colors.red;
+            default:
+                return colors.white;
+        }
+    }
+    /**
+     * Format log entry as JSON
+     */
+    formatJSON(entry) {
+        const obj = {
+            timestamp: entry.timestamp.toISOString(),
+            level: this.getLevelName(entry.level),
+            message: entry.message,
+        };
+        if (entry.context) {
+            obj.context = entry.context;
+        }
+        if (entry.metadata && Object.keys(entry.metadata).length > 0) {
+            obj.metadata = entry.metadata;
+        }
+        if (entry.error) {
+            obj.error = {
+                name: entry.error.name,
+                message: entry.error.message,
+                stack: entry.error.stack,
+            };
+        }
+        return JSON.stringify(obj);
+    }
+    /**
+     * Format log entry as text
+     */
+    formatText(entry) {
+        const parts = [];
+        // Timestamp
+        if (this.config.enableTimestamp) {
+            const timestamp = this.formatTimestamp();
+            parts.push(this.config.enableColors ? `${colors.dim}${timestamp}${colors.reset}` : timestamp);
+        }
+        // Level
+        const levelName = this.getLevelName(entry.level);
+        const levelColor = this.getLevelColor(entry.level);
+        const formattedLevel = this.config.enableColors
+            ? `${levelColor}${levelName.padEnd(5)}${colors.reset}`
+            : levelName.padEnd(5);
+        parts.push(formattedLevel);
+        // Context
+        if (entry.context) {
+            const formattedContext = this.config.enableColors
+                ? `${colors.magenta}[${entry.context}]${colors.reset}`
+                : `[${entry.context}]`;
+            parts.push(formattedContext);
+        }
+        // Message
+        parts.push(entry.message);
+        // Metadata
+        if (entry.metadata && Object.keys(entry.metadata).length > 0) {
+            const metadataStr = JSON.stringify(entry.metadata);
+            const formattedMetadata = this.config.enableColors
+                ? `${colors.dim}${metadataStr}${colors.reset}`
+                : metadataStr;
+            parts.push(formattedMetadata);
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Core logging method
+     */
+    log(level, message, metadata, error) {
+        if (!this.isLevelEnabled(level)) {
+            return;
+        }
+        const entry = {
+            timestamp: new Date(),
+            level,
+            message,
+            context: this.config.context,
+            metadata,
+            error,
+        };
+        const output = this.config.enableJSON
+            ? this.formatJSON(entry)
+            : this.formatText(entry);
+        // Output to appropriate stream
+        if (level >= LogLevel.ERROR) {
+            console.error(output);
+            if (error?.stack) {
+                console.error(error.stack);
+            }
+        }
+        else if (level >= LogLevel.WARN) {
+            console.warn(output);
+        }
+        else {
+            // INFO and DEBUG go to stdout
+            // Using console.log here is intentional for the logger itself
+            // eslint-disable-next-line no-console
+            console.log(output);
+        }
+    }
+    /**
+     * Debug level logging
+     */
+    debug(message, metadata) {
+        this.log(LogLevel.DEBUG, message, metadata);
+    }
+    /**
+     * Info level logging
+     */
+    info(message, metadata) {
+        this.log(LogLevel.INFO, message, metadata);
+    }
+    /**
+     * Warning level logging
+     */
+    warn(message, metadata) {
+        this.log(LogLevel.WARN, message, metadata);
+    }
+    /**
+     * Error level logging
+     */
+    error(message, error, metadata) {
+        const err = error instanceof Error ? error : undefined;
+        const errorMetadata = error && !(error instanceof Error) ? { error } : undefined;
+        this.log(LogLevel.ERROR, message, { ...metadata, ...errorMetadata }, err);
+    }
+}
+/**
+ * Default logger instance
+ */
+export const logger = new Logger();
+/**
+ * Create a logger with a specific context
+ */
+export function createLogger(context, config) {
+    return new Logger({
+        ...config,
+        context,
+    });
+}
+/**
+ * Export for default usage
+ */
+export default logger;

package/dist/lib/lshrc-init.js

@@ -0,0 +1,177 @@
+/**
+ * .lshrc Initialization
+ * Creates and manages the user's .lshrc configuration file
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class LshrcManager {
+    lshrcPath;
+    constructor(lshrcPath) {
+        this.lshrcPath = lshrcPath || path.join(os.homedir(), '.lshrc');
+    }
+    /**
+     * Initialize .lshrc if it doesn't exist
+     */
+    initialize(options = {}) {
+        try {
+            // Check if .lshrc already exists
+            if (fs.existsSync(this.lshrcPath)) {
+                return false; // Already exists, no action needed
+            }
+            if (!options.createIfMissing) {
+                return false; // Don't create if not requested
+            }
+            // Copy template to user's home directory
+            const templatePath = path.join(__dirname, '../../templates/.lshrc.template');
+            if (!fs.existsSync(templatePath)) {
+                // Template not found, create basic .lshrc
+                this.createBasicLshrc(options);
+                return true;
+            }
+            // Copy template
+            let content = fs.readFileSync(templatePath, 'utf8');
+            // Enable auto-import if requested
+            if (options.autoImportZsh) {
+                const importCmd = `zsh-source${options.importOptions ? ' ' + options.importOptions.join(' ') : ''}`;
+                content = content.replace('# zsh-source', importCmd);
+            }
+            fs.writeFileSync(this.lshrcPath, content, 'utf8');
+            console.log(`✅ Created ${this.lshrcPath}`);
+            return true;
+        }
+        catch (error) {
+            console.error(`Failed to initialize .lshrc: ${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * Create basic .lshrc without template
+     */
+    createBasicLshrc(options) {
+        const content = `# LSH Configuration File
+# Location: ${this.lshrcPath}
+
+${options.autoImportZsh ? `# Auto-import ZSH configurations
+zsh-source${options.importOptions ? ' ' + options.importOptions.join(' ') : ''}
+` : '# Uncomment to auto-import ZSH configurations\n# zsh-source\n'}
+
+# Add your aliases, functions, and environment variables here
+`;
+        fs.writeFileSync(this.lshrcPath, content, 'utf8');
+        console.log(`✅ Created ${this.lshrcPath}`);
+    }
+    /**
+     * Check if .lshrc exists
+     */
+    exists() {
+        return fs.existsSync(this.lshrcPath);
+    }
+    /**
+     * Source .lshrc commands
+     */
+    async source(_executor) {
+        if (!this.exists()) {
+            return [];
+        }
+        try {
+            const content = fs.readFileSync(this.lshrcPath, 'utf8');
+            const commands = [];
+            for (const line of content.split('\n')) {
+                const trimmed = line.trim();
+                // Skip comments and empty lines
+                if (trimmed.startsWith('#') || trimmed === '') {
+                    continue;
+                }
+                commands.push(trimmed);
+            }
+            return commands;
+        }
+        catch (error) {
+            console.error(`Failed to source .lshrc: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * Enable auto-import in existing .lshrc
+     */
+    enableAutoImport(options = []) {
+        try {
+            if (!this.exists()) {
+                // Create new .lshrc with auto-import enabled
+                this.initialize({ autoImportZsh: true, importOptions: options, createIfMissing: true });
+                return true;
+            }
+            let content = fs.readFileSync(this.lshrcPath, 'utf8');
+            // Check if auto-import is already enabled
+            if (content.includes('zsh-source') && !content.match(/^#.*zsh-source/m)) {
+                console.log('Auto-import is already enabled in .lshrc');
+                return false;
+            }
+            // Add auto-import configuration
+            const autoImportBlock = `
+# ZSH Auto-Import (added by LSH)
+zsh-source${options.length > 0 ? ' ' + options.join(' ') : ''}
+`;
+            // Find the ZSH import section or add at the top
+            if (content.includes('# ZSH IMPORT CONFIGURATION')) {
+                content = content.replace(/# zsh-source/, `zsh-source${options.length > 0 ? ' ' + options.join(' ') : ''}`);
+            }
+            else {
+                content = autoImportBlock + '\n' + content;
+            }
+            fs.writeFileSync(this.lshrcPath, content, 'utf8');
+            console.log('✅ Auto-import enabled in .lshrc');
+            return true;
+        }
+        catch (error) {
+            console.error(`Failed to enable auto-import: ${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * Disable auto-import in .lshrc
+     */
+    disableAutoImport() {
+        try {
+            if (!this.exists()) {
+                return false;
+            }
+            let content = fs.readFileSync(this.lshrcPath, 'utf8');
+            // Comment out zsh-source lines
+            content = content.replace(/^(zsh-source.*)$/gm, '# $1');
+            // Remove auto-import blocks
+            content = content.replace(/# ZSH Auto-Import[\s\S]*?(?=\n#|\n\n|$)/g, '');
+            fs.writeFileSync(this.lshrcPath, content, 'utf8');
+            console.log('✅ Auto-import disabled in .lshrc');
+            return true;
+        }
+        catch (error) {
+            console.error(`Failed to disable auto-import: ${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * Get .lshrc path
+     */
+    getPath() {
+        return this.lshrcPath;
+    }
+}
+/**
+ * Initialize .lshrc on first run
+ */
+export function initializeLshrc(options = {}) {
+    const manager = new LshrcManager();
+    return manager.initialize(options);
+}
+/**
+ * Check if .lshrc exists
+ */
+export function lshrcExists() {
+    const manager = new LshrcManager();
+    return manager.exists();
+}

package/dist/lib/pathname-expansion.js

@@ -0,0 +1,216 @@
+/**
+ * POSIX Pathname Expansion Implementation
+ * Implements POSIX.1-2017 Section 2.13 Pathname Expansion (Globbing)
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+export class PathnameExpander {
+    cwd;
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+    }
+    async expandPathnames(pattern, options = {}) {
+        // If no glob characters, return as-is
+        if (!this.containsGlobChars(pattern)) {
+            return [pattern];
+        }
+        // Handle tilde expansion first
+        const expandedPattern = this.expandTilde(pattern);
+        // Perform pathname expansion
+        return this.glob(expandedPattern, options);
+    }
+    containsGlobChars(str) {
+        // Check for unescaped glob characters
+        return /[*?[\]{}~]/.test(str);
+    }
+    expandTilde(pattern) {
+        if (pattern.startsWith('~/')) {
+            const homeDir = process.env.HOME || '/';
+            return path.join(homeDir, pattern.slice(2));
+        }
+        if (pattern === '~') {
+            return process.env.HOME || '/';
+        }
+        return pattern;
+    }
+    async glob(pattern, options) {
+        const baseCwd = options.cwd || this.cwd;
+        // Handle absolute vs relative paths
+        const isAbsolute = path.isAbsolute(pattern);
+        const searchBase = isAbsolute ? '/' : baseCwd;
+        const relativePath = isAbsolute ? pattern.slice(1) : pattern;
+        // Split pattern into segments
+        const segments = relativePath.split('/').filter(seg => seg.length > 0);
+        if (segments.length === 0) {
+            return [searchBase];
+        }
+        // Start recursive matching
+        const results = await this.matchSegments(searchBase, segments, options);
+        // Sort results for consistent output
+        return results.sort();
+    }
+    async matchSegments(currentPath, remainingSegments, options) {
+        if (remainingSegments.length === 0) {
+            return [currentPath];
+        }
+        const [currentSegment, ...restSegments] = remainingSegments;
+        const results = [];
+        try {
+            const entries = await fs.promises.readdir(currentPath, { withFileTypes: true });
+            for (const entry of entries) {
+                // Skip hidden files unless explicitly included
+                if (!options.includeHidden && entry.name.startsWith('.')) {
+                    continue;
+                }
+                // Check if this entry matches the current segment pattern
+                if (this.matchSegment(entry.name, currentSegment)) {
+                    const fullPath = path.join(currentPath, entry.name);
+                    if (restSegments.length === 0) {
+                        // This is the final segment, add to results
+                        results.push(fullPath);
+                    }
+                    else if (entry.isDirectory()) {
+                        // Recurse into directory for remaining segments
+                        const subResults = await this.matchSegments(fullPath, restSegments, options);
+                        results.push(...subResults);
+                    }
+                }
+            }
+        }
+        catch (_error) {
+            // Directory doesn't exist or not readable, return empty
+            return [];
+        }
+        return results;
+    }
+    matchSegment(filename, pattern) {
+        // Convert glob pattern to regex
+        const regex = this.patternToRegex(pattern);
+        return regex.test(filename);
+    }
+    patternToRegex(pattern) {
+        let regexStr = '';
+        let i = 0;
+        while (i < pattern.length) {
+            const char = pattern[i];
+            switch (char) {
+                case '*':
+                    regexStr += '.*';
+                    break;
+                case '?':
+                    regexStr += '.';
+                    break;
+                case '[': {
+                    // Character class
+                    const closeIdx = this.findClosingBracket(pattern, i);
+                    if (closeIdx === -1) {
+                        // Invalid bracket, treat as literal
+                        regexStr += '\\[';
+                    }
+                    else {
+                        let charClass = pattern.slice(i + 1, closeIdx);
+                        // Handle negation
+                        if (charClass.startsWith('!') || charClass.startsWith('^')) {
+                            charClass = '^' + charClass.slice(1);
+                        }
+                        // Handle character ranges and classes
+                        charClass = this.processCharacterClass(charClass);
+                        regexStr += '[' + charClass + ']';
+                        i = closeIdx;
+                    }
+                    break;
+                }
+                case '{': {
+                    // Brace expansion - simplified implementation
+                    const braceEnd = this.findClosingBrace(pattern, i);
+                    if (braceEnd === -1) {
+                        regexStr += '\\{';
+                    }
+                    else {
+                        const braceContent = pattern.slice(i + 1, braceEnd);
+                        const alternatives = braceContent.split(',');
+                        regexStr += '(' + alternatives.map(alt => this.escapeRegex(alt)).join('|') + ')';
+                        i = braceEnd;
+                    }
+                    break;
+                }
+                case '\\':
+                    // Escape next character
+                    if (i + 1 < pattern.length) {
+                        regexStr += '\\' + pattern[i + 1];
+                        i++;
+                    }
+                    else {
+                        regexStr += '\\\\';
+                    }
+                    break;
+                default:
+                    // Literal character - escape regex special chars
+                    regexStr += this.escapeRegex(char);
+                    break;
+            }
+            i++;
+        }
+        return new RegExp('^' + regexStr + '$');
+    }
+    findClosingBracket(str, startIdx) {
+        let depth = 1;
+        for (let i = startIdx + 1; i < str.length; i++) {
+            if (str[i] === '[')
+                depth++;
+            else if (str[i] === ']') {
+                depth--;
+                if (depth === 0)
+                    return i;
+            }
+        }
+        return -1;
+    }
+    findClosingBrace(str, startIdx) {
+        let depth = 1;
+        for (let i = startIdx + 1; i < str.length; i++) {
+            if (str[i] === '{')
+                depth++;
+            else if (str[i] === '}') {
+                depth--;
+                if (depth === 0)
+                    return i;
+            }
+        }
+        return -1;
+    }
+    processCharacterClass(charClass) {
+        // Handle POSIX character classes like [:alpha:]
+        charClass = charClass.replace(/\[:alpha:\]/g, 'a-zA-Z');
+        charClass = charClass.replace(/\[:digit:\]/g, '0-9');
+        charClass = charClass.replace(/\[:alnum:\]/g, 'a-zA-Z0-9');
+        charClass = charClass.replace(/\[:lower:\]/g, 'a-z');
+        charClass = charClass.replace(/\[:upper:\]/g, 'A-Z');
+        charClass = charClass.replace(/\[:space:\]/g, ' \\t\\n\\r\\f\\v');
+        charClass = charClass.replace(/\[:blank:\]/g, ' \\t');
+        charClass = charClass.replace(/\[:punct:\]/g, '!-/:-@\\[-`{-~');
+        charClass = charClass.replace(/\[:cntrl:\]/g, '\\x00-\\x1F\\x7F');
+        charClass = charClass.replace(/\[:print:\]/g, '\\x20-\\x7E');
+        charClass = charClass.replace(/\[:graph:\]/g, '\\x21-\\x7E');
+        charClass = charClass.replace(/\[:xdigit:\]/g, '0-9A-Fa-f');
+        return charClass;
+    }
+    escapeRegex(str) {
+        return str.replace(/[.+^$()|[\]{}\\]/g, '\\$&');
+    }
+    // Utility method for expanding multiple patterns
+    async expandMultiplePatterns(patterns, options = {}) {
+        const results = [];
+        for (const pattern of patterns) {
+            const expanded = await this.expandPathnames(pattern, options);
+            results.push(...expanded);
+        }
+        // Remove duplicates and sort
+        return [...new Set(results)].sort();
+    }
+    // Check if a pattern would match any files (useful for error reporting)
+    async hasMatches(pattern, options = {}) {
+        const matches = await this.expandPathnames(pattern, options);
+        return matches.length > 0 && matches[0] !== pattern;
+    }
+}