lsh-framework 1.2.0 → 1.2.1

package/dist/lib/pathname-expansion.js

@@ -1,216 +0,0 @@
-/**
- * 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;
-    }
-}

package/dist/lib/script-runner.js

@@ -1,226 +0,0 @@
-/**
- * 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;