lsh-framework 0.5.4

package/dist/lib/brace-expansion.js

@@ -0,0 +1,160 @@
+/**
+ * POSIX Brace Expansion Implementation
+ * Handles patterns like {a,b,c}, {1..5}, {a..z}, etc.
+ */
+export class BraceExpander {
+    maxExpansions;
+    constructor(options = {}) {
+        this.maxExpansions = options.maxExpansions || 10000;
+    }
+    expandBraces(pattern) {
+        // If no braces, return as-is
+        if (!pattern.includes('{') || !pattern.includes('}')) {
+            return [pattern];
+        }
+        try {
+            const results = this.expandPattern(pattern);
+            // Safety check to prevent excessive expansions
+            if (results.length > this.maxExpansions) {
+                return [pattern]; // Return original if too many expansions
+            }
+            return results;
+        }
+        catch (_error) {
+            // If expansion fails, return original pattern
+            return [pattern];
+        }
+    }
+    expandPattern(pattern) {
+        // Find the first complete brace expression
+        const braceMatch = this.findBraceExpression(pattern);
+        if (!braceMatch) {
+            return [pattern];
+        }
+        const { start, end, content } = braceMatch;
+        const prefix = pattern.substring(0, start);
+        const suffix = pattern.substring(end + 1);
+        // Expand the brace content
+        const expansions = this.expandBraceContent(content);
+        // Combine prefix + expansion + suffix
+        const results = [];
+        for (const expansion of expansions) {
+            const combined = prefix + expansion + suffix;
+            // Recursively expand any remaining braces
+            const furtherExpanded = this.expandPattern(combined);
+            results.push(...furtherExpanded);
+        }
+        return results;
+    }
+    findBraceExpression(pattern) {
+        let braceCount = 0;
+        let start = -1;
+        for (let i = 0; i < pattern.length; i++) {
+            const char = pattern[i];
+            if (char === '{') {
+                if (braceCount === 0) {
+                    start = i;
+                }
+                braceCount++;
+            }
+            else if (char === '}') {
+                braceCount--;
+                if (braceCount === 0 && start !== -1) {
+                    const content = pattern.substring(start + 1, i);
+                    return { start, end: i, content };
+                }
+            }
+        }
+        return null;
+    }
+    expandBraceContent(content) {
+        // Handle sequence expansion first (e.g., 1..5, a..z)
+        const sequenceMatch = content.match(/^(.+?)\.\.(.+?)(?:\.\.(.+))?$/);
+        if (sequenceMatch) {
+            return this.expandSequence(sequenceMatch[1], sequenceMatch[2], sequenceMatch[3]);
+        }
+        // Handle comma-separated list (e.g., a,b,c)
+        if (content.includes(',')) {
+            return this.expandCommaList(content);
+        }
+        // Not a valid brace expression
+        return ['{' + content + '}'];
+    }
+    expandSequence(start, end, step) {
+        const results = [];
+        // Determine if numeric or alphabetic sequence
+        const startNum = parseInt(start, 10);
+        const endNum = parseInt(end, 10);
+        const stepNum = step ? parseInt(step, 10) : 1;
+        if (!isNaN(startNum) && !isNaN(endNum)) {
+            // Numeric sequence
+            if (stepNum <= 0)
+                return ['{' + start + '..' + end + '}'];
+            if (startNum <= endNum) {
+                for (let i = startNum; i <= endNum; i += stepNum) {
+                    results.push(i.toString());
+                }
+            }
+            else {
+                for (let i = startNum; i >= endNum; i -= stepNum) {
+                    results.push(i.toString());
+                }
+            }
+        }
+        else if (start.length === 1 && end.length === 1) {
+            // Alphabetic sequence
+            const startCode = start.charCodeAt(0);
+            const endCode = end.charCodeAt(0);
+            if (startCode <= endCode) {
+                for (let i = startCode; i <= endCode; i += stepNum) {
+                    results.push(String.fromCharCode(i));
+                }
+            }
+            else {
+                for (let i = startCode; i >= endCode; i -= stepNum) {
+                    results.push(String.fromCharCode(i));
+                }
+            }
+        }
+        else {
+            // Invalid sequence
+            return ['{' + start + '..' + end + '}'];
+        }
+        return results;
+    }
+    expandCommaList(content) {
+        const results = [];
+        let current = '';
+        let braceCount = 0;
+        for (let i = 0; i < content.length; i++) {
+            const char = content[i];
+            if (char === '{') {
+                braceCount++;
+                current += char;
+            }
+            else if (char === '}') {
+                braceCount--;
+                current += char;
+            }
+            else if (char === ',' && braceCount === 0) {
+                results.push(current.trim());
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current) {
+            results.push(current.trim());
+        }
+        return results;
+    }
+    // Utility method for expanding multiple patterns
+    expandMultiplePatterns(patterns) {
+        const results = [];
+        for (const pattern of patterns) {
+            results.push(...this.expandBraces(pattern));
+        }
+        return results;
+    }
+}

package/dist/lib/builtin-commands.js

@@ -0,0 +1,439 @@
+/**
+ * Shell Builtin Commands
+ * Extracted from shell-executor.ts for better maintainability
+ * Contains all POSIX and ZSH builtin command implementations
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { PathnameExpander } from './pathname-expansion.js';
+/**
+ * Manages all shell builtin commands
+ */
+export class BuiltinCommands {
+    context;
+    pathExpander;
+    jobBuiltins;
+    updateExpander;
+    constructor(context, pathExpander, jobBuiltins, updateExpander) {
+        this.context = context;
+        this.pathExpander = pathExpander;
+        this.jobBuiltins = jobBuiltins;
+        this.updateExpander = updateExpander;
+    }
+    /**
+     * Update the path expander reference (called after cd)
+     */
+    setPathExpander(expander) {
+        this.pathExpander = expander;
+    }
+    /**
+     * Execute a builtin command by name
+     */
+    async execute(name, args) {
+        switch (name) {
+            case 'cd':
+                return this.builtin_cd(args);
+            case 'pwd':
+                return this.builtin_pwd(args);
+            case 'echo':
+                return this.builtin_echo(args);
+            case 'exit':
+                return this.builtin_exit(args);
+            case 'export':
+                return this.builtin_export(args);
+            case 'unset':
+                return this.builtin_unset(args);
+            case 'set':
+                return this.builtin_set(args);
+            case 'test':
+            case '[':
+                return this.builtin_test(args);
+            case 'shift':
+                return this.builtin_shift(args);
+            case 'source':
+            case '.':
+                return this.builtin_source(args);
+            case 'alias':
+                return this.builtin_alias(args);
+            case 'unalias':
+                return this.builtin_unalias(args);
+            case 'readonly':
+                return this.builtin_readonly(args);
+            case 'local':
+                return this.builtin_local(args);
+            case 'return':
+                return this.builtin_return(args);
+            case 'typeset':
+                return this.builtin_typeset(args);
+            case 'setopt':
+                return this.builtin_setopt(args);
+            case 'unsetopt':
+                return this.builtin_unsetopt(args);
+            case 'read':
+                return this.builtin_read(args);
+            case 'getopts':
+                return this.builtin_getopts(args);
+            case 'printf':
+                return this.builtin_printf(args);
+            case 'exec':
+                return this.builtin_exec(args);
+            case 'eval':
+                return this.builtin_eval(args);
+            case 'trap':
+                return this.builtin_trap(args);
+            case 'hash':
+                return this.builtin_hash(args);
+            case 'type':
+                return this.builtin_type(args);
+            // Job control builtins - Placeholder implementations
+            // TODO: Integrate with JobBuiltins properly
+            case 'jobs':
+            case 'fg':
+            case 'bg':
+            case 'kill':
+            case 'wait':
+                return { stdout: '', stderr: `${name}: not yet implemented`, exitCode: 1, success: false };
+            // History builtins
+            case 'history':
+                return this.builtin_history(args);
+            case 'fc':
+                return this.builtin_fc(args);
+            case 'r':
+                return this.builtin_r(args);
+            // Installation builtins
+            case 'install':
+                return this.builtin_install(args);
+            case 'uninstall':
+                return this.builtin_uninstall(args);
+            // ZSH migration builtins
+            case 'zsh-source':
+                return this.builtin_zsh_source(args);
+            case 'zsh-migrate':
+                return this.builtin_zsh_migrate(args);
+            default:
+                return null; // Not a builtin
+        }
+    }
+    /**
+     * Adapt JobBuiltins result format to ExecutionResult
+     */
+    adaptJobBuiltinResult(result) {
+        return {
+            ...result,
+            success: result.exitCode === 0,
+        };
+    }
+    // ========================================
+    // Core Builtin Implementations
+    // ========================================
+    async builtin_cd(args) {
+        const target = args[0] || this.context.env.HOME || '/';
+        try {
+            const resolvedPath = path.resolve(this.context.cwd, target);
+            // Check if directory exists
+            if (!fs.existsSync(resolvedPath)) {
+                return {
+                    stdout: '',
+                    stderr: `cd: ${target}: No such file or directory`,
+                    exitCode: 1,
+                    success: false,
+                };
+            }
+            const stats = fs.statSync(resolvedPath);
+            if (!stats.isDirectory()) {
+                return {
+                    stdout: '',
+                    stderr: `cd: ${target}: Not a directory`,
+                    exitCode: 1,
+                    success: false,
+                };
+            }
+            // Update context
+            this.context.cwd = resolvedPath;
+            process.chdir(resolvedPath);
+            // Update path expander with new working directory
+            this.pathExpander = new PathnameExpander(this.context.cwd);
+            return { stdout: '', stderr: '', exitCode: 0, success: true };
+        }
+        catch (error) {
+            return {
+                stdout: '',
+                stderr: `cd: ${target}: ${error.message}`,
+                exitCode: 1,
+                success: false,
+            };
+        }
+    }
+    async builtin_pwd(_args) {
+        return {
+            stdout: this.context.cwd,
+            stderr: '',
+            exitCode: 0,
+            success: true,
+        };
+    }
+    async builtin_echo(args) {
+        let message = args.join(' ');
+        let newline = true;
+        if (args[0] === '-n') {
+            newline = false;
+            message = args.slice(1).join(' ');
+        }
+        return {
+            stdout: message + (newline ? '\n' : ''),
+            stderr: '',
+            exitCode: 0,
+            success: true,
+        };
+    }
+    async builtin_exit(args) {
+        const exitCode = args.length > 0 ? parseInt(args[0], 10) : this.context.lastExitCode;
+        process.exit(isNaN(exitCode) ? 1 : exitCode);
+        return { stdout: '', stderr: '', exitCode: 0, success: true };
+    }
+    async builtin_export(args) {
+        for (const arg of args) {
+            if (arg.includes('=')) {
+                const [key, value] = arg.split('=', 2);
+                this.context.env[key] = value;
+                this.context.variables[key] = value;
+            }
+            else {
+                if (arg in this.context.variables) {
+                    this.context.env[arg] = this.context.variables[arg];
+                }
+            }
+        }
+        this.updateExpander();
+        return { stdout: '', stderr: '', exitCode: 0, success: true };
+    }
+    async builtin_unset(args) {
+        for (const name of args) {
+            delete this.context.variables[name];
+            delete this.context.env[name];
+        }
+        this.updateExpander();
+        return { stdout: '', stderr: '', exitCode: 0, success: true };
+    }
+    async builtin_set(args) {
+        if (args.length === 0) {
+            // Print all variables
+            const output = Object.entries(this.context.variables)
+                .map(([key, value]) => `${key}=${value}`)
+                .join('\n');
+            return {
+                stdout: output,
+                stderr: '',
+                exitCode: 0,
+                success: true,
+            };
+        }
+        for (const arg of args) {
+            if (arg.startsWith('-')) {
+                // Enable options
+                for (let i = 1; i < arg.length; i++) {
+                    const option = arg[i];
+                    switch (option) {
+                        case 'e':
+                            this.context.options.errexit = true;
+                            break;
+                        case 'u':
+                            this.context.options.nounset = true;
+                            break;
+                        case 'x':
+                            this.context.options.xtrace = true;
+                            break;
+                        case 'v':
+                            this.context.options.verbose = true;
+                            break;
+                        case 'f':
+                            this.context.options.noglob = true;
+                            break;
+                        case 'm':
+                            this.context.options.monitor = true;
+                            break;
+                        case 'C':
+                            this.context.options.noclobber = true;
+                            break;
+                        case 'a':
+                            this.context.options.allexport = true;
+                            break;
+                    }
+                }
+            }
+            else if (arg.startsWith('+')) {
+                // Disable options
+                for (let i = 1; i < arg.length; i++) {
+                    const option = arg[i];
+                    switch (option) {
+                        case 'e':
+                            this.context.options.errexit = false;
+                            break;
+                        case 'u':
+                            this.context.options.nounset = false;
+                            break;
+                        case 'x':
+                            this.context.options.xtrace = false;
+                            break;
+                        case 'v':
+                            this.context.options.verbose = false;
+                            break;
+                        case 'f':
+                            this.context.options.noglob = false;
+                            break;
+                        case 'm':
+                            this.context.options.monitor = false;
+                            break;
+                        case 'C':
+                            this.context.options.noclobber = false;
+                            break;
+                        case 'a':
+                            this.context.options.allexport = false;
+                            break;
+                    }
+                }
+            }
+            else {
+                // Set positional parameters
+                this.context.positionalParams = args;
+                break;
+            }
+        }
+        return { stdout: '', stderr: '', exitCode: 0, success: true };
+    }
+    // Placeholder implementations for remaining builtins
+    // These will be extracted from shell-executor.ts in the next phase
+    async builtin_test(args) {
+        const result = this.evaluateTestExpression(args);
+        return {
+            stdout: '',
+            stderr: '',
+            exitCode: result ? 0 : 1,
+            success: result,
+        };
+    }
+    evaluateTestExpression(args) {
+        // Simplified test implementation - full version to be extracted
+        if (args.length === 0)
+            return false;
+        if (args[args.length - 1] === ']')
+            args = args.slice(0, -1);
+        if (args.length === 1)
+            return args[0] !== '';
+        // More complex test logic to be extracted
+        return true;
+    }
+    async builtin_shift(args) {
+        const n = args.length > 0 ? parseInt(args[0], 10) : 1;
+        this.context.positionalParams = this.context.positionalParams.slice(n);
+        return { stdout: '', stderr: '', exitCode: 0, success: true };
+    }
+    async builtin_source(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'source: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_alias(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'alias: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_unalias(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'unalias: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_readonly(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'readonly: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_local(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'local: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_return(args) {
+        const code = args.length > 0 ? parseInt(args[0], 10) : this.context.lastReturnCode;
+        return { stdout: '', stderr: '', exitCode: isNaN(code) ? 0 : code, success: true };
+    }
+    async builtin_typeset(args) {
+        const result = this.context.arrays.parseTypesetCommand(args);
+        return {
+            stdout: '',
+            stderr: result.success ? '' : result.message,
+            exitCode: result.success ? 0 : 1,
+            success: result.success,
+        };
+    }
+    async builtin_setopt(_args) {
+        // TODO: ZshOptionsManager doesn't have setOption method yet
+        // for (const opt of args) {
+        //   this.context.zshOptions.setOption(opt, true);
+        // }
+        return { stdout: '', stderr: 'setopt: not yet fully implemented', exitCode: 1, success: false };
+    }
+    async builtin_unsetopt(_args) {
+        // TODO: ZshOptionsManager doesn't have setOption method yet
+        // for (const opt of args) {
+        //   this.context.zshOptions.setOption(opt, false);
+        // }
+        return { stdout: '', stderr: 'unsetopt: not yet fully implemented', exitCode: 1, success: false };
+    }
+    async builtin_read(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'read: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_getopts(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'getopts: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_printf(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'printf: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_exec(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'exec: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_eval(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'eval: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_trap(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'trap: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_hash(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'hash: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_type(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'type: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_history(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'history: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_fc(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'fc: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_r(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'r: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_install(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'install: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_uninstall(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'uninstall: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_zsh_source(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'zsh-source: not yet implemented', exitCode: 1, success: false };
+    }
+    async builtin_zsh_migrate(_args) {
+        // Placeholder - full implementation to be extracted
+        return { stdout: '', stderr: 'zsh-migrate: not yet implemented', exitCode: 1, success: false };
+    }
+}
+export default BuiltinCommands;