lsh-framework 1.2.0 → 1.2.1

package/dist/lib/zsh-import-manager.js

@@ -1,707 +0,0 @@
-/**
- * Enhanced ZSH Import Manager
- * Handles importing ZSH configurations with conflict resolution, diagnostics, and selective import
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { parseShellCommand } from './shell-parser.js';
-export class ZshImportManager {
-    executor;
-    options;
-    diagnostics = [];
-    existingAliases = new Set();
-    existingExports = new Set();
-    existingFunctions = new Set();
-    constructor(executor, options = {}) {
-        this.executor = executor;
-        this.options = {
-            autoImport: false,
-            selective: false,
-            conflictResolution: 'skip',
-            diagnosticLog: path.join(os.homedir(), '.lsh', 'zsh-import.log'),
-            includeAliases: true,
-            includeExports: true,
-            includeFunctions: true,
-            includeOptions: true,
-            includePlugins: true,
-            excludePatterns: [],
-            includePatterns: [],
-            ...options,
-        };
-        // Ensure diagnostic log directory exists
-        this.ensureLogDirectory();
-    }
-    ensureLogDirectory() {
-        const logDir = path.dirname(this.options.diagnosticLog);
-        if (!fs.existsSync(logDir)) {
-            fs.mkdirSync(logDir, { recursive: true });
-        }
-    }
-    /**
-     * Import ZSH configuration from .zshrc
-     */
-    async importZshConfig(zshrcPath) {
-        const configPath = zshrcPath || path.join(os.homedir(), '.zshrc');
-        this.diagnostics = [];
-        this.log({ type: 'alias', name: 'IMPORT_START', status: 'success', reason: `Starting import from ${configPath}` });
-        try {
-            // Check if .zshrc exists
-            if (!fs.existsSync(configPath)) {
-                const result = {
-                    success: false,
-                    message: `ZSH configuration not found: ${configPath}`,
-                    diagnostics: this.diagnostics,
-                    stats: { total: 0, succeeded: 0, failed: 0, skipped: 0, conflicts: 0 },
-                };
-                this.writeDiagnosticLog();
-                return result;
-            }
-            // Load existing items to detect conflicts
-            await this.loadExistingItems();
-            // Read and parse .zshrc
-            const zshrcContent = fs.readFileSync(configPath, 'utf8');
-            const parsed = this.parseZshrc(zshrcContent);
-            // Apply configurations based on options
-            const stats = {
-                total: 0,
-                succeeded: 0,
-                failed: 0,
-                skipped: 0,
-                conflicts: 0,
-            };
-            if (this.options.includeAliases) {
-                const result = await this.importAliases(parsed.aliases);
-                stats.total += result.total;
-                stats.succeeded += result.succeeded;
-                stats.failed += result.failed;
-                stats.skipped += result.skipped;
-                stats.conflicts += result.conflicts;
-            }
-            if (this.options.includeExports) {
-                const result = await this.importExports(parsed.exports);
-                stats.total += result.total;
-                stats.succeeded += result.succeeded;
-                stats.failed += result.failed;
-                stats.skipped += result.skipped;
-                stats.conflicts += result.conflicts;
-            }
-            if (this.options.includeFunctions) {
-                const result = await this.importFunctions(parsed.functions);
-                stats.total += result.total;
-                stats.succeeded += result.succeeded;
-                stats.failed += result.failed;
-                stats.skipped += result.skipped;
-                stats.conflicts += result.conflicts;
-            }
-            if (this.options.includeOptions) {
-                const result = await this.importSetopts(parsed.setopts);
-                stats.total += result.total;
-                stats.succeeded += result.succeeded;
-                stats.failed += result.failed;
-                stats.skipped += result.skipped;
-            }
-            if (this.options.includePlugins) {
-                const result = await this.importPlugins(parsed.plugins);
-                stats.total += result.total;
-                stats.succeeded += result.succeeded;
-                stats.failed += result.failed;
-                stats.skipped += result.skipped;
-            }
-            this.log({
-                type: 'alias',
-                name: 'IMPORT_COMPLETE',
-                status: 'success',
-                reason: `Imported ${stats.succeeded}/${stats.total} items`
-            });
-            const result = {
-                success: true,
-                message: this.formatImportMessage(stats),
-                diagnostics: this.diagnostics,
-                stats,
-            };
-            this.writeDiagnosticLog();
-            return result;
-        }
-        catch (error) {
-            const err = error;
-            this.log({
-                type: 'error',
-                name: 'IMPORT_ERROR',
-                status: 'failed',
-                reason: err.message
-            });
-            const result = {
-                success: false,
-                message: `Import failed: ${err.message}`,
-                diagnostics: this.diagnostics,
-                stats: { total: 0, succeeded: 0, failed: 1, skipped: 0, conflicts: 0 },
-            };
-            this.writeDiagnosticLog();
-            return result;
-        }
-    }
-    /**
-     * Parse .zshrc with enhanced function parsing
-     */
-    parseZshrc(content) {
-        const lines = content.split('\n');
-        const config = {
-            aliases: [],
-            functions: [],
-            exports: [],
-            setopts: [],
-            completions: [],
-            plugins: [],
-        };
-        let inFunction = false;
-        let functionName = '';
-        let functionBody = '';
-        let functionStartLine = 0;
-        let braceCount = 0;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const trimmed = line.trim();
-            // Skip comments and empty lines
-            if (trimmed.startsWith('#') || trimmed === '') {
-                continue;
-            }
-            // Handle function definitions (multiple formats)
-            // Format 1: name() { ... }
-            // Format 2: function name { ... }
-            // Format 3: function name() { ... }
-            const funcMatch = trimmed.match(/^(?:function\s+)?([a-zA-Z_][a-zA-Z0-9_]*)\s*\(\s*\)\s*\{?/) ||
-                trimmed.match(/^function\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\{?/);
-            if (funcMatch && !inFunction) {
-                inFunction = true;
-                functionName = funcMatch[1];
-                functionBody = line;
-                functionStartLine = i + 1;
-                braceCount = (line.match(/\{/g) || []).length - (line.match(/\}/g) || []).length;
-                if (braceCount === 0 && line.includes('{') && line.includes('}')) {
-                    // Single-line function
-                    inFunction = false;
-                    config.functions.push({
-                        name: functionName,
-                        body: functionBody,
-                        line: functionStartLine,
-                    });
-                    functionName = '';
-                    functionBody = '';
-                }
-                continue;
-            }
-            if (inFunction) {
-                functionBody += '\n' + line;
-                braceCount += (line.match(/\{/g) || []).length;
-                braceCount -= (line.match(/\}/g) || []).length;
-                if (braceCount <= 0) {
-                    inFunction = false;
-                    config.functions.push({
-                        name: functionName,
-                        body: functionBody,
-                        line: functionStartLine,
-                    });
-                    functionName = '';
-                    functionBody = '';
-                }
-                continue;
-            }
-            // Parse aliases
-            const aliasMatch = trimmed.match(/^alias\s+([^=]+)=(.+)$/);
-            if (aliasMatch) {
-                config.aliases.push({
-                    name: aliasMatch[1].trim(),
-                    value: aliasMatch[2].replace(/^['"]|['"]$/g, ''),
-                    line: i + 1,
-                });
-                continue;
-            }
-            // Parse exports (handle various formats)
-            const exportMatch = trimmed.match(/^export\s+([^=]+)(?:=(.+))?$/);
-            if (exportMatch) {
-                config.exports.push({
-                    name: exportMatch[1].trim(),
-                    value: exportMatch[2] ? exportMatch[2].replace(/^['"]|['"]$/g, '') : '',
-                    line: i + 1,
-                });
-                continue;
-            }
-            // Parse setopt
-            const setoptMatch = trimmed.match(/^setopt\s+(.+)$/);
-            if (setoptMatch) {
-                const options = setoptMatch[1].split(/\s+/);
-                for (const option of options) {
-                    config.setopts.push({
-                        option: option.trim(),
-                        enabled: true,
-                        line: i + 1,
-                    });
-                }
-                continue;
-            }
-            // Parse unsetopt
-            const unsetoptMatch = trimmed.match(/^unsetopt\s+(.+)$/);
-            if (unsetoptMatch) {
-                const options = unsetoptMatch[1].split(/\s+/);
-                for (const option of options) {
-                    config.setopts.push({
-                        option: option.trim(),
-                        enabled: false,
-                        line: i + 1,
-                    });
-                }
-                continue;
-            }
-            // Parse completions
-            if (trimmed.includes('compinit') || trimmed.includes('autoload')) {
-                config.completions.push({
-                    config: trimmed,
-                    line: i + 1,
-                });
-                continue;
-            }
-            // Parse plugins
-            const pluginMatch = trimmed.match(/plugins?=\(([^)]+)\)/);
-            if (pluginMatch) {
-                const plugins = pluginMatch[1].split(/\s+/).filter(p => p.trim());
-                for (const plugin of plugins) {
-                    config.plugins.push({
-                        name: plugin.trim(),
-                        line: i + 1,
-                    });
-                }
-                continue;
-            }
-        }
-        return config;
-    }
-    /**
-     * Load existing items to detect conflicts
-     */
-    async loadExistingItems() {
-        // Get existing aliases from context
-        const context = this.executor.getContext();
-        if (context && context.variables) {
-            for (const key in context.variables) {
-                if (key.startsWith('alias_')) {
-                    this.existingAliases.add(key.substring(6));
-                }
-                else {
-                    this.existingExports.add(key);
-                }
-            }
-        }
-        // TODO: Load existing functions when function storage is implemented
-    }
-    /**
-     * Import aliases with conflict resolution
-     */
-    async importAliases(aliases) {
-        const stats = { total: aliases.length, succeeded: 0, failed: 0, skipped: 0, conflicts: 0 };
-        for (const alias of aliases) {
-            // Check include/exclude patterns
-            if (!this.shouldImport(alias.name)) {
-                this.log({
-                    type: 'alias',
-                    name: alias.name,
-                    status: 'skipped',
-                    reason: 'Excluded by pattern',
-                    source: `line ${alias.line}`,
-                });
-                stats.skipped++;
-                continue;
-            }
-            // Check for conflicts
-            if (this.existingAliases.has(alias.name)) {
-                stats.conflicts++;
-                const action = await this.resolveConflict('alias', alias.name);
-                if (action === 'skip') {
-                    this.log({
-                        type: 'alias',
-                        name: alias.name,
-                        status: 'skipped',
-                        reason: 'Conflict - alias already exists',
-                        source: `line ${alias.line}`,
-                        action: 'skipped',
-                    });
-                    stats.skipped++;
-                    continue;
-                }
-                else if (action === 'rename') {
-                    alias.name = `${alias.name}_zsh`;
-                    this.log({
-                        type: 'alias',
-                        name: alias.name,
-                        status: 'success',
-                        reason: 'Conflict - renamed to avoid collision',
-                        source: `line ${alias.line}`,
-                        action: 'renamed',
-                    });
-                }
-            }
-            // Import alias
-            try {
-                const ast = parseShellCommand(`alias ${alias.name}="${alias.value}"`);
-                await this.executor.execute(ast);
-                this.existingAliases.add(alias.name);
-                this.log({
-                    type: 'alias',
-                    name: alias.name,
-                    status: 'success',
-                    source: `line ${alias.line}`,
-                });
-                stats.succeeded++;
-            }
-            catch (error) {
-                const err = error;
-                this.log({
-                    type: 'alias',
-                    name: alias.name,
-                    status: 'failed',
-                    reason: err.message,
-                    source: `line ${alias.line}`,
-                });
-                stats.failed++;
-            }
-        }
-        return stats;
-    }
-    /**
-     * Import environment variables with conflict resolution
-     */
-    async importExports(exports) {
-        const stats = { total: exports.length, succeeded: 0, failed: 0, skipped: 0, conflicts: 0 };
-        for (const export_ of exports) {
-            // Check include/exclude patterns
-            if (!this.shouldImport(export_.name)) {
-                this.log({
-                    type: 'export',
-                    name: export_.name,
-                    status: 'skipped',
-                    reason: 'Excluded by pattern',
-                    source: `line ${export_.line}`,
-                });
-                stats.skipped++;
-                continue;
-            }
-            // Check for conflicts
-            if (this.existingExports.has(export_.name) || process.env[export_.name]) {
-                stats.conflicts++;
-                const action = await this.resolveConflict('export', export_.name);
-                if (action === 'skip') {
-                    this.log({
-                        type: 'export',
-                        name: export_.name,
-                        status: 'skipped',
-                        reason: 'Conflict - variable already exists',
-                        source: `line ${export_.line}`,
-                        action: 'skipped',
-                    });
-                    stats.skipped++;
-                    continue;
-                }
-            }
-            // Import export
-            try {
-                const value = export_.value || '';
-                const ast = parseShellCommand(`export ${export_.name}="${value}"`);
-                await this.executor.execute(ast);
-                this.existingExports.add(export_.name);
-                this.log({
-                    type: 'export',
-                    name: export_.name,
-                    status: 'success',
-                    source: `line ${export_.line}`,
-                });
-                stats.succeeded++;
-            }
-            catch (error) {
-                const err = error;
-                this.log({
-                    type: 'export',
-                    name: export_.name,
-                    status: 'failed',
-                    reason: err.message,
-                    source: `line ${export_.line}`,
-                });
-                stats.failed++;
-            }
-        }
-        return stats;
-    }
-    /**
-     * Import functions with enhanced parsing
-     */
-    async importFunctions(functions) {
-        const stats = { total: functions.length, succeeded: 0, failed: 0, skipped: 0, conflicts: 0 };
-        for (const func of functions) {
-            // Check include/exclude patterns
-            if (!this.shouldImport(func.name)) {
-                this.log({
-                    type: 'function',
-                    name: func.name,
-                    status: 'skipped',
-                    reason: 'Excluded by pattern',
-                    source: `line ${func.line}`,
-                });
-                stats.skipped++;
-                continue;
-            }
-            // Check for conflicts
-            if (this.existingFunctions.has(func.name)) {
-                stats.conflicts++;
-                const action = await this.resolveConflict('function', func.name);
-                if (action === 'skip') {
-                    this.log({
-                        type: 'function',
-                        name: func.name,
-                        status: 'skipped',
-                        reason: 'Conflict - function already exists',
-                        source: `line ${func.line}`,
-                        action: 'skipped',
-                    });
-                    stats.skipped++;
-                    continue;
-                }
-                else if (action === 'rename') {
-                    // Rename function in body
-                    const oldName = func.name;
-                    func.name = `${func.name}_zsh`;
-                    func.body = func.body.replace(new RegExp(`^(function\\s+)?${oldName}`, 'm'), `$1${func.name}`);
-                    this.log({
-                        type: 'function',
-                        name: func.name,
-                        status: 'success',
-                        reason: 'Conflict - renamed to avoid collision',
-                        source: `line ${func.line}`,
-                        action: 'renamed',
-                    });
-                }
-            }
-            // Import function
-            try {
-                const ast = parseShellCommand(func.body);
-                await this.executor.execute(ast);
-                this.existingFunctions.add(func.name);
-                this.log({
-                    type: 'function',
-                    name: func.name,
-                    status: 'success',
-                    source: `line ${func.line}`,
-                });
-                stats.succeeded++;
-            }
-            catch (error) {
-                const err = error;
-                this.log({
-                    type: 'function',
-                    name: func.name,
-                    status: 'disabled',
-                    reason: `Parse error: ${err.message}`,
-                    source: `line ${func.line}`,
-                });
-                stats.failed++;
-            }
-        }
-        return stats;
-    }
-    /**
-     * Import ZSH options
-     */
-    async importSetopts(setopts) {
-        const stats = { total: setopts.length, succeeded: 0, failed: 0, skipped: 0, conflicts: 0 };
-        for (const setopt of setopts) {
-            try {
-                const command = setopt.enabled ? 'setopt' : 'unsetopt';
-                const ast = parseShellCommand(`${command} ${setopt.option}`);
-                await this.executor.execute(ast);
-                this.log({
-                    type: 'setopt',
-                    name: setopt.option,
-                    status: 'success',
-                    source: `line ${setopt.line}`,
-                });
-                stats.succeeded++;
-            }
-            catch (error) {
-                const err = error;
-                this.log({
-                    type: 'setopt',
-                    name: setopt.option,
-                    status: 'disabled',
-                    reason: err.message,
-                    source: `line ${setopt.line}`,
-                });
-                stats.failed++;
-            }
-        }
-        return stats;
-    }
-    /**
-     * Import Oh-My-Zsh plugins
-     */
-    async importPlugins(plugins) {
-        const stats = { total: plugins.length, succeeded: 0, failed: 0, skipped: 0, conflicts: 0 };
-        for (const plugin of plugins) {
-            this.log({
-                type: 'plugin',
-                name: plugin.name,
-                status: 'disabled',
-                reason: 'Oh-My-Zsh plugin support not yet implemented',
-                source: `line ${plugin.line}`,
-            });
-            stats.skipped++;
-        }
-        return stats;
-    }
-    /**
-     * Check if item should be imported based on include/exclude patterns
-     */
-    shouldImport(name) {
-        // Check exclude patterns first
-        if (this.options.excludePatterns.length > 0) {
-            for (const pattern of this.options.excludePatterns) {
-                if (this.matchPattern(name, pattern)) {
-                    return false;
-                }
-            }
-        }
-        // Check include patterns
-        if (this.options.includePatterns.length > 0) {
-            for (const pattern of this.options.includePatterns) {
-                if (this.matchPattern(name, pattern)) {
-                    return true;
-                }
-            }
-            return false; // If include patterns specified, only import matching items
-        }
-        return true; // No patterns specified, import everything
-    }
-    /**
-     * Match name against pattern (supports wildcards)
-     */
-    matchPattern(name, pattern) {
-        const regexPattern = pattern
-            .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex special chars
-            .replace(/\*/g, '.*') // Convert * to .*
-            .replace(/\?/g, '.'); // Convert ? to .
-        return new RegExp(`^${regexPattern}$`).test(name);
-    }
-    /**
-     * Resolve naming conflicts
-     */
-    async resolveConflict(_type, _name) {
-        switch (this.options.conflictResolution) {
-            case 'skip':
-                return 'skip';
-            case 'overwrite':
-                return 'overwrite';
-            case 'rename':
-                return 'rename';
-            case 'prompt':
-                // TODO: Implement interactive prompt for CLI
-                return 'skip'; // Default to skip for now
-            default:
-                return 'skip';
-        }
-    }
-    /**
-     * Log diagnostic entry
-     */
-    log(entry) {
-        this.diagnostics.push({
-            timestamp: new Date(),
-            ...entry,
-        });
-    }
-    /**
-     * Write diagnostic log to file
-     */
-    writeDiagnosticLog() {
-        try {
-            const logContent = this.diagnostics
-                .map(d => {
-                const parts = [
-                    d.timestamp.toISOString(),
-                    d.type.padEnd(10),
-                    d.status.padEnd(10),
-                    d.name.padEnd(30),
-                ];
-                if (d.source)
-                    parts.push(`[${d.source}]`);
-                if (d.reason)
-                    parts.push(d.reason);
-                if (d.action)
-                    parts.push(`(${d.action})`);
-                return parts.join(' ');
-            })
-                .join('\n');
-            fs.appendFileSync(this.options.diagnosticLog, logContent + '\n\n', 'utf8');
-        }
-        catch (error) {
-            const err = error;
-            console.error(`Failed to write diagnostic log: ${err.message}`);
-        }
-    }
-    /**
-     * Format import summary message
-     */
-    formatImportMessage(stats) {
-        const lines = [
-            `ZSH Import Complete:`,
-            `  ✅ Succeeded: ${stats.succeeded}`,
-            `  ❌ Failed: ${stats.failed}`,
-            `  ⏭️  Skipped: ${stats.skipped}`,
-            `  ⚠️  Conflicts: ${stats.conflicts}`,
-            `  📊 Total: ${stats.total}`,
-        ];
-        if (stats.failed > 0) {
-            lines.push(`\nSee diagnostic log: ${this.options.diagnosticLog}`);
-        }
-        return lines.join('\n');
-    }
-    /**
-     * Get import statistics from last run
-     */
-    getLastImportStats() {
-        if (this.diagnostics.length === 0) {
-            return null;
-        }
-        const stats = {
-            total: 0,
-            succeeded: 0,
-            failed: 0,
-            skipped: 0,
-            conflicts: 0,
-            byType: {},
-        };
-        for (const diagnostic of this.diagnostics) {
-            if (diagnostic.name === 'IMPORT_START' || diagnostic.name === 'IMPORT_COMPLETE' || diagnostic.name === 'IMPORT_ERROR') {
-                continue;
-            }
-            stats.total++;
-            if (diagnostic.status === 'success')
-                stats.succeeded++;
-            if (diagnostic.status === 'failed')
-                stats.failed++;
-            if (diagnostic.status === 'skipped')
-                stats.skipped++;
-            if (diagnostic.status === 'conflict')
-                stats.conflicts++;
-            if (!stats.byType[diagnostic.type]) {
-                stats.byType[diagnostic.type] = { total: 0, succeeded: 0, failed: 0, skipped: 0, conflicts: 0 };
-            }
-            stats.byType[diagnostic.type].total++;
-            if (diagnostic.status === 'success')
-                stats.byType[diagnostic.type].succeeded++;
-            if (diagnostic.status === 'failed')
-                stats.byType[diagnostic.type].failed++;
-            if (diagnostic.status === 'skipped')
-                stats.byType[diagnostic.type].skipped++;
-            if (diagnostic.status === 'conflict')
-                stats.byType[diagnostic.type].conflicts++;
-        }
-        return stats;
-    }
-}