lsh-framework 0.5.4

package/dist/lib/prompt-system.js

@@ -0,0 +1,328 @@
+/**
+ * Advanced Prompt System Implementation
+ * Provides ZSH-compatible prompt customization
+ */
+import * as os from 'os';
+import * as path from 'path';
+export class PromptSystem {
+    themes = new Map();
+    currentTheme = 'default';
+    context;
+    constructor() {
+        this.context = this.createDefaultContext();
+        this.setupDefaultThemes();
+    }
+    /**
+     * Expand prompt string with ZSH-style sequences
+     */
+    expandPrompt(prompt, context) {
+        const ctx = { ...this.context, ...context };
+        let result = prompt;
+        // Basic sequences
+        result = result.replace(/%n/g, ctx.user); // Username
+        result = result.replace(/%m/g, ctx.host); // Hostname
+        result = result.replace(/%M/g, ctx.host.split('.')[0]); // Hostname without domain
+        result = result.replace(/%~/g, this.formatPath(ctx.cwd, ctx.home)); // Current directory
+        result = result.replace(/%d/g, ctx.cwd); // Full path
+        result = result.replace(/%c/g, path.basename(ctx.cwd)); // Basename of current directory
+        result = result.replace(/%C/g, path.basename(ctx.cwd)); // Same as %c
+        result = result.replace(/%h/g, ctx.jobCount.toString()); // Number of jobs
+        result = result.replace(/%j/g, ctx.jobCount.toString()); // Number of jobs
+        result = result.replace(/%L/g, ctx.exitCode.toString()); // Exit code of last command
+        result = result.replace(/%\?/g, ctx.exitCode.toString()); // Exit code of last command
+        result = result.replace(/%#/g, ctx.user === 'root' ? '#' : '$'); // Prompt character
+        result = result.replace(/%\$/g, ctx.user === 'root' ? '#' : '$'); // Prompt character
+        result = result.replace(/%%/g, '%'); // Literal %
+        // Time sequences
+        result = result.replace(/%T/g, this.formatTime(ctx.time, 'HH:MM')); // 24-hour time
+        result = result.replace(/%t/g, this.formatTime(ctx.time, 'h:mm')); // 12-hour time
+        result = result.replace(/%D/g, this.formatTime(ctx.time, 'yyyy-MM-dd')); // Date
+        result = result.replace(/%w/g, this.formatTime(ctx.time, 'EEE')); // Day of week
+        result = result.replace(/%W/g, this.formatTime(ctx.time, 'MM/dd')); // Date
+        // Git sequences
+        if (ctx.git) {
+            result = result.replace(/%b/g, ctx.git.branch); // Git branch
+            result = result.replace(/%B/g, ctx.git.branch); // Git branch
+            result = result.replace(/%r/g, this.formatGitStatus(ctx.git.status)); // Git status
+        }
+        // Conditional sequences
+        result = this.expandConditionalSequences(result, ctx);
+        // Color sequences
+        result = this.expandColorSequences(result);
+        return result;
+    }
+    /**
+     * Set current theme
+     */
+    setTheme(themeName) {
+        if (this.themes.has(themeName)) {
+            this.currentTheme = themeName;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get current theme
+     */
+    getCurrentTheme() {
+        return this.currentTheme;
+    }
+    /**
+     * Get current prompt
+     */
+    getCurrentPrompt(context) {
+        const theme = this.themes.get(this.currentTheme);
+        if (!theme)
+            return '$ ';
+        return this.expandPrompt(theme.prompt, context);
+    }
+    /**
+     * Get current right prompt
+     */
+    getCurrentRPrompt(context) {
+        const theme = this.themes.get(this.currentTheme);
+        if (!theme || !theme.rprompt)
+            return '';
+        return this.expandPrompt(theme.rprompt, context);
+    }
+    /**
+     * Add a custom theme
+     */
+    addTheme(theme) {
+        this.themes.set(theme.name, theme);
+    }
+    /**
+     * Get all available themes
+     */
+    getAvailableThemes() {
+        return Array.from(this.themes.keys());
+    }
+    /**
+     * Get theme information
+     */
+    getThemeInfo(themeName) {
+        return this.themes.get(themeName);
+    }
+    /**
+     * Update prompt context
+     */
+    updateContext(updates) {
+        this.context = { ...this.context, ...updates };
+    }
+    /**
+     * Create default context
+     */
+    createDefaultContext() {
+        return {
+            user: os.userInfo().username,
+            host: os.hostname(),
+            cwd: process.cwd(),
+            home: os.homedir(),
+            exitCode: 0,
+            jobCount: 0,
+            time: new Date(),
+        };
+    }
+    /**
+     * Setup default themes
+     */
+    setupDefaultThemes() {
+        // Default theme
+        this.addTheme({
+            name: 'default',
+            description: 'Simple default prompt',
+            prompt: '%n@%m:%~$ ',
+        });
+        // Minimal theme
+        this.addTheme({
+            name: 'minimal',
+            description: 'Minimal prompt',
+            prompt: '$ ',
+        });
+        // Detailed theme
+        this.addTheme({
+            name: 'detailed',
+            description: 'Detailed prompt with time and exit code',
+            prompt: '[%T] %n@%m:%~ %?$ ',
+            rprompt: '%h jobs',
+        });
+        // Git theme
+        this.addTheme({
+            name: 'git',
+            description: 'Git-aware prompt',
+            prompt: '%n@%m:%~ %b$ ',
+            rprompt: '%r',
+        });
+        // Powerline-style theme
+        this.addTheme({
+            name: 'powerline',
+            description: 'Powerline-style prompt',
+            prompt: '%n@%m %~ %# ',
+            colors: {
+                user: '32', // Green
+                host: '34', // Blue
+                path: '35', // Magenta
+                git: '33', // Yellow
+                error: '31', // Red
+                success: '32', // Green
+            },
+        });
+        // Oh My Zsh-style theme
+        this.addTheme({
+            name: 'ohmyzsh',
+            description: 'Oh My Zsh-style prompt',
+            prompt: '%n@%m %~ %# ',
+            rprompt: '%T',
+        });
+        // Fish-style theme
+        this.addTheme({
+            name: 'fish',
+            description: 'Fish shell-style prompt',
+            prompt: '%n@%m %~ > ',
+        });
+        // Bash-style theme
+        this.addTheme({
+            name: 'bash',
+            description: 'Bash-style prompt',
+            prompt: '\\u@\\h:\\w\\$ ',
+        });
+    }
+    /**
+     * Format path with tilde expansion
+     */
+    formatPath(cwd, home) {
+        if (cwd.startsWith(home)) {
+            return '~' + cwd.substring(home.length);
+        }
+        return cwd;
+    }
+    /**
+     * Format time according to pattern
+     */
+    formatTime(time, pattern) {
+        const hours = time.getHours();
+        const minutes = time.getMinutes();
+        const seconds = time.getSeconds();
+        const day = time.getDate();
+        const month = time.getMonth() + 1;
+        const year = time.getFullYear();
+        const dayOfWeek = time.getDay();
+        const dayNames = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+        return pattern
+            .replace(/HH/g, hours.toString().padStart(2, '0'))
+            .replace(/H/g, hours.toString())
+            .replace(/h/g, (hours % 12 || 12).toString())
+            .replace(/mm/g, minutes.toString().padStart(2, '0'))
+            .replace(/m/g, minutes.toString())
+            .replace(/ss/g, seconds.toString().padStart(2, '0'))
+            .replace(/s/g, seconds.toString())
+            .replace(/dd/g, day.toString().padStart(2, '0'))
+            .replace(/d/g, day.toString())
+            .replace(/MM/g, month.toString().padStart(2, '0'))
+            .replace(/M/g, month.toString())
+            .replace(/yyyy/g, year.toString())
+            .replace(/yy/g, year.toString().slice(-2))
+            .replace(/EEE/g, dayNames[dayOfWeek]);
+    }
+    /**
+     * Format git status
+     */
+    formatGitStatus(status) {
+        switch (status) {
+            case 'clean': return '✓';
+            case 'dirty': return '●';
+            case 'ahead': return '↑';
+            case 'behind': return '↓';
+            case 'diverged': return '↕';
+            default: return '';
+        }
+    }
+    /**
+     * Expand conditional sequences
+     */
+    expandConditionalSequences(prompt, context) {
+        // Handle %(condition.true-text.false-text)
+        const conditionalRegex = /%\(([^)]+)\)/g;
+        return prompt.replace(conditionalRegex, (match, condition) => {
+            const parts = condition.split('.');
+            if (parts.length < 2)
+                return match;
+            const [cond, trueText, falseText = ''] = parts;
+            const isTrue = this.evaluateCondition(cond, context);
+            return isTrue ? trueText : falseText;
+        });
+    }
+    /**
+     * Evaluate condition for conditional sequences
+     */
+    evaluateCondition(condition, context) {
+        switch (condition) {
+            case '?': return context.exitCode === 0;
+            case '!': return context.exitCode !== 0;
+            case 'j': return context.jobCount > 0;
+            case 'n': return context.user !== 'root';
+            case 'root': return context.user === 'root';
+            case 'git': return context.git !== undefined;
+            default: return false;
+        }
+    }
+    /**
+     * Expand color sequences
+     */
+    expandColorSequences(prompt) {
+        // Handle %F{color} and %f
+        const colorRegex = /%F\{([^}]+)\}/g;
+        prompt = prompt.replace(colorRegex, (match, color) => {
+            return this.getColorCode(color);
+        });
+        prompt = prompt.replace(/%f/g, '\x1b[0m'); // Reset color
+        // Handle %K{color} and %k (background colors)
+        const bgColorRegex = /%K\{([^}]+)\}/g;
+        prompt = prompt.replace(bgColorRegex, (match, color) => {
+            return this.getBackgroundColorCode(color);
+        });
+        prompt = prompt.replace(/%k/g, '\x1b[49m'); // Reset background
+        // Handle %B and %b (bold)
+        prompt = prompt.replace(/%B/g, '\x1b[1m');
+        prompt = prompt.replace(/%b/g, '\x1b[22m');
+        // Handle %U and %u (underline)
+        prompt = prompt.replace(/%U/g, '\x1b[4m');
+        prompt = prompt.replace(/%u/g, '\x1b[24m');
+        return prompt;
+    }
+    /**
+     * Get color code for color name
+     */
+    getColorCode(color) {
+        const 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',
+            default: '\x1b[39m',
+        };
+        return colors[color.toLowerCase()] || '\x1b[39m';
+    }
+    /**
+     * Get background color code for color name
+     */
+    getBackgroundColorCode(color) {
+        const colors = {
+            black: '\x1b[40m',
+            red: '\x1b[41m',
+            green: '\x1b[42m',
+            yellow: '\x1b[43m',
+            blue: '\x1b[44m',
+            magenta: '\x1b[45m',
+            cyan: '\x1b[46m',
+            white: '\x1b[47m',
+            default: '\x1b[49m',
+        };
+        return colors[color.toLowerCase()] || '\x1b[49m';
+    }
+}
+export default PromptSystem;

package/dist/lib/script-runner.js

@@ -0,0 +1,226 @@
+/**
+ * Shell Script Runner
+ * Executes shell scripts with LSH
+ */
+import { ShellExecutor } from './shell-executor.js';
+import { parseShellCommand } from './shell-parser.js';
+import * as fs from 'fs';
+export class ScriptRunner {
+    executor;
+    constructor(options) {
+        this.executor = new ShellExecutor({
+            cwd: options?.cwd || process.cwd(),
+            env: {
+                ...Object.fromEntries(Object.entries(process.env).filter(([_, v]) => v !== undefined)),
+                ...options?.env
+            },
+        });
+    }
+    /**
+     * Execute a shell script file
+     */
+    async executeScript(scriptPath, options = {}) {
+        try {
+            // Read script file
+            const scriptContent = fs.readFileSync(scriptPath, 'utf8');
+            // Set up script context
+            if (options.args) {
+                this.executor.setPositionalParams(options.args);
+            }
+            // Parse and execute script
+            const ast = parseShellCommand(scriptContent);
+            const result = await this.executor.execute(ast);
+            return {
+                success: result.success,
+                exitCode: result.exitCode,
+                output: result.stdout,
+                errors: result.stderr,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                exitCode: 1,
+                output: '',
+                errors: `Script execution failed: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * Execute shell commands from string
+     */
+    async executeCommands(commands, options = {}) {
+        try {
+            // Set up context
+            if (options.args) {
+                this.executor.setPositionalParams(options.args);
+            }
+            // Parse and execute commands
+            const ast = parseShellCommand(commands);
+            const result = await this.executor.execute(ast);
+            return {
+                success: result.success,
+                exitCode: result.exitCode,
+                output: result.stdout,
+                errors: result.stderr,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                exitCode: 1,
+                output: '',
+                errors: `Command execution failed: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * Execute script with shebang detection
+     */
+    async executeWithShebang(scriptPath, options = {}) {
+        try {
+            const scriptContent = fs.readFileSync(scriptPath, 'utf8');
+            // Check for shebang
+            const lines = scriptContent.split('\n');
+            const firstLine = lines[0];
+            if (firstLine.startsWith('#!')) {
+                const interpreter = firstLine.substring(2).trim();
+                // Handle different interpreters
+                if (interpreter.includes('sh') || interpreter.includes('bash') || interpreter.includes('zsh')) {
+                    // Execute as shell script
+                    return await this.executeScript(scriptPath, options);
+                }
+                else {
+                    // For other interpreters, delegate to system
+                    return await this.executeSystemScript(scriptPath, options);
+                }
+            }
+            else {
+                // No shebang, execute as shell script
+                return await this.executeScript(scriptPath, options);
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                exitCode: 1,
+                output: '',
+                errors: `Script execution failed: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * Execute system script (fallback)
+     */
+    async executeSystemScript(scriptPath, options) {
+        const { spawn } = await import('child_process');
+        return new Promise((resolve) => {
+            const child = spawn('sh', [scriptPath], {
+                cwd: options.cwd || process.cwd(),
+                env: { ...process.env, ...options.env },
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            child.on('close', (code) => {
+                resolve({
+                    success: code === 0,
+                    exitCode: code || 0,
+                    output: stdout,
+                    errors: stderr,
+                });
+            });
+            child.on('error', (error) => {
+                resolve({
+                    success: false,
+                    exitCode: 1,
+                    output: '',
+                    errors: error.message,
+                });
+            });
+        });
+    }
+    /**
+     * Validate shell script syntax
+     */
+    validateScript(scriptPath) {
+        try {
+            const scriptContent = fs.readFileSync(scriptPath, 'utf8');
+            const _ast = parseShellCommand(scriptContent);
+            // Basic validation - if parsing succeeds, syntax is valid
+            return { valid: true, errors: [] };
+        }
+        catch (error) {
+            return { valid: false, errors: [error.message] };
+        }
+    }
+    /**
+     * Get script information
+     */
+    getScriptInfo(scriptPath) {
+        try {
+            const stats = fs.statSync(scriptPath);
+            const content = fs.readFileSync(scriptPath, 'utf8');
+            const firstLine = content.split('\n')[0];
+            let shebang;
+            let interpreter;
+            if (firstLine.startsWith('#!')) {
+                shebang = firstLine;
+                interpreter = firstLine.substring(2).trim();
+            }
+            return {
+                exists: true,
+                executable: stats.mode & 0o111 ? true : false,
+                size: stats.size,
+                shebang,
+                interpreter,
+            };
+        }
+        catch {
+            return {
+                exists: false,
+                executable: false,
+                size: 0,
+            };
+        }
+    }
+    /**
+     * Make script executable
+     */
+    makeExecutable(scriptPath) {
+        try {
+            const stats = fs.statSync(scriptPath);
+            fs.chmodSync(scriptPath, stats.mode | 0o111);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Create a simple shell script
+     */
+    createScript(scriptPath, content, makeExecutable = true) {
+        try {
+            // Add shebang if not present
+            if (!content.startsWith('#!')) {
+                content = '#!/bin/sh\n' + content;
+            }
+            fs.writeFileSync(scriptPath, content, 'utf8');
+            if (makeExecutable) {
+                this.makeExecutable(scriptPath);
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export default ScriptRunner;