lsh-framework 1.1.0 → 1.2.1

package/dist/commands/zsh-import.js

@@ -1,240 +0,0 @@
-/**
- * ZSH Import Commands
- * CLI commands for importing ZSH configurations
- */
-import { ShellExecutor } from '../lib/shell-executor.js';
-import { ZshImportManager } from '../lib/zsh-import-manager.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-export function registerZshImportCommands(program) {
-    const zshCommand = program
-        .command('zsh-import')
-        .description('Import ZSH configurations (aliases, functions, exports)');
-    zshCommand
-        .command('all')
-        .description('Import all ZSH configurations from .zshrc')
-        .option('--skip-conflicts', 'Skip items that conflict with existing ones', false)
-        .option('--rename-conflicts', 'Rename conflicting items with _zsh suffix', false)
-        .option('--overwrite-conflicts', 'Overwrite existing items', false)
-        .option('--exclude <patterns...>', 'Exclude items matching patterns (supports wildcards)')
-        .option('--include <patterns...>', 'Only include items matching patterns')
-        .option('--no-aliases', 'Skip importing aliases')
-        .option('--no-exports', 'Skip importing environment variables')
-        .option('--no-functions', 'Skip importing functions')
-        .option('--no-options', 'Skip importing ZSH options (setopt/unsetopt)')
-        .option('--diagnostic-log <path>', 'Path to diagnostic log file')
-        .action(async (options) => {
-        const executor = new ShellExecutor();
-        // Determine conflict resolution strategy
-        let conflictResolution = 'skip';
-        if (options.renameConflicts)
-            conflictResolution = 'rename';
-        if (options.overwriteConflicts)
-            conflictResolution = 'overwrite';
-        const importOptions = {
-            conflictResolution,
-            includeAliases: options.aliases !== false,
-            includeExports: options.exports !== false,
-            includeFunctions: options.functions !== false,
-            includeOptions: options.options !== false,
-            includePlugins: true,
-            excludePatterns: options.exclude || [],
-            includePatterns: options.include || [],
-            diagnosticLog: options.diagnosticLog,
-        };
-        const manager = new ZshImportManager(executor, importOptions);
-        const result = await manager.importZshConfig();
-        console.log(result.message);
-        if (result.diagnostics.filter(d => d.status === 'failed').length > 0) {
-            console.log(`\n⚠️  Some imports failed. Check diagnostic log: ${importOptions.diagnosticLog || '~/.lsh/zsh-import.log'}`);
-        }
-        process.exit(result.success ? 0 : 1);
-    });
-    zshCommand
-        .command('aliases')
-        .description('Import only aliases from .zshrc')
-        .option('--exclude <patterns...>', 'Exclude aliases matching patterns')
-        .option('--include <patterns...>', 'Only include aliases matching patterns')
-        .option('--rename-conflicts', 'Rename conflicting aliases')
-        .action(async (options) => {
-        const executor = new ShellExecutor();
-        const importOptions = {
-            includeAliases: true,
-            includeExports: false,
-            includeFunctions: false,
-            includeOptions: false,
-            includePlugins: false,
-            conflictResolution: options.renameConflicts ? 'rename' : 'skip',
-            excludePatterns: options.exclude || [],
-            includePatterns: options.include || [],
-        };
-        const manager = new ZshImportManager(executor, importOptions);
-        const result = await manager.importZshConfig();
-        console.log(result.message);
-        process.exit(result.success ? 0 : 1);
-    });
-    zshCommand
-        .command('exports')
-        .description('Import only environment variables from .zshrc')
-        .option('--exclude <patterns...>', 'Exclude exports matching patterns')
-        .option('--include <patterns...>', 'Only include exports matching patterns')
-        .action(async (options) => {
-        const executor = new ShellExecutor();
-        const importOptions = {
-            includeAliases: false,
-            includeExports: true,
-            includeFunctions: false,
-            includeOptions: false,
-            includePlugins: false,
-            excludePatterns: options.exclude || [],
-            includePatterns: options.include || [],
-        };
-        const manager = new ZshImportManager(executor, importOptions);
-        const result = await manager.importZshConfig();
-        console.log(result.message);
-        process.exit(result.success ? 0 : 1);
-    });
-    zshCommand
-        .command('functions')
-        .description('Import only functions from .zshrc')
-        .option('--exclude <patterns...>', 'Exclude functions matching patterns')
-        .option('--include <patterns...>', 'Only include functions matching patterns')
-        .option('--rename-conflicts', 'Rename conflicting functions')
-        .action(async (options) => {
-        const executor = new ShellExecutor();
-        const importOptions = {
-            includeAliases: false,
-            includeExports: false,
-            includeFunctions: true,
-            includeOptions: false,
-            includePlugins: false,
-            conflictResolution: options.renameConflicts ? 'rename' : 'skip',
-            excludePatterns: options.exclude || [],
-            includePatterns: options.include || [],
-        };
-        const manager = new ZshImportManager(executor, importOptions);
-        const result = await manager.importZshConfig();
-        console.log(result.message);
-        process.exit(result.success ? 0 : 1);
-    });
-    zshCommand
-        .command('setup-auto-import')
-        .description('Configure auto-import of ZSH config on LSH startup')
-        .option('--disable', 'Disable auto-import')
-        .option('--aliases-only', 'Only auto-import aliases')
-        .option('--exports-only', 'Only auto-import exports')
-        .option('--rename-conflicts', 'Auto-rename conflicts')
-        .action(async (options) => {
-        const lshrcPath = path.join(os.homedir(), '.lshrc');
-        if (options.disable) {
-            // Remove auto-import from .lshrc
-            if (fs.existsSync(lshrcPath)) {
-                let content = fs.readFileSync(lshrcPath, 'utf8');
-                content = content.replace(/# ZSH Auto-Import[\s\S]*?# End ZSH Auto-Import\n*/g, '');
-                fs.writeFileSync(lshrcPath, content, 'utf8');
-                console.log('✅ Auto-import disabled');
-            }
-            process.exit(0);
-            return;
-        }
-        // Generate auto-import configuration
-        const importCommand = 'zsh-source';
-        const options_list = [];
-        if (options.aliasesOnly) {
-            options_list.push('--no-exports', '--no-functions', '--no-options');
-        }
-        else if (options.exportsOnly) {
-            options_list.push('--no-aliases', '--no-functions', '--no-options');
-        }
-        if (options.renameConflicts) {
-            options_list.push('--rename-conflicts');
-        }
-        const autoImportConfig = `
-# ZSH Auto-Import
-# Automatically import ZSH configurations on startup
-${importCommand}${options_list.length > 0 ? ' ' + options_list.join(' ') : ''}
-# End ZSH Auto-Import
-`;
-        // Read or create .lshrc
-        let lshrcContent = '';
-        if (fs.existsSync(lshrcPath)) {
-            lshrcContent = fs.readFileSync(lshrcPath, 'utf8');
-            // Remove existing auto-import config
-            lshrcContent = lshrcContent.replace(/# ZSH Auto-Import[\s\S]*?# End ZSH Auto-Import\n*/g, '');
-        }
-        // Append new auto-import config
-        lshrcContent += autoImportConfig;
-        fs.writeFileSync(lshrcPath, lshrcContent, 'utf8');
-        console.log('✅ Auto-import configured in ~/.lshrc');
-        console.log(`   ZSH config will be imported automatically on LSH startup`);
-        console.log(`\nConfiguration added:`);
-        console.log(autoImportConfig.trim());
-        process.exit(0);
-    });
-    zshCommand
-        .command('status')
-        .description('Show ZSH import status and diagnostics')
-        .action(async () => {
-        const executor = new ShellExecutor();
-        const manager = new ZshImportManager(executor);
-        const stats = manager.getLastImportStats();
-        if (!stats) {
-            console.log('No ZSH import has been performed yet.');
-            console.log('\nRun one of these commands to import:');
-            console.log('  lsh zsh-import all          # Import everything');
-            console.log('  lsh zsh-import aliases      # Import only aliases');
-            console.log('  lsh zsh-import exports      # Import only exports');
-            console.log('  lsh zsh-import functions    # Import only functions');
-            process.exit(0);
-            return;
-        }
-        console.log('📊 Last ZSH Import Status:\n');
-        console.log(`   Total Items: ${stats.total}`);
-        console.log(`   ✅ Succeeded: ${stats.succeeded}`);
-        console.log(`   ❌ Failed: ${stats.failed}`);
-        console.log(`   ⏭️  Skipped: ${stats.skipped}`);
-        console.log(`   ⚠️  Conflicts: ${stats.conflicts}\n`);
-        if (stats.byType) {
-            console.log('By Type:');
-            for (const [type, typeStats] of Object.entries(stats.byType)) {
-                const ts = typeStats;
-                console.log(`   ${type.padEnd(12)}: ${ts.succeeded}/${ts.total} succeeded, ${ts.failed} failed, ${ts.skipped} skipped`);
-            }
-        }
-        const diagnosticLog = path.join(os.homedir(), '.lsh', 'zsh-import.log');
-        if (fs.existsSync(diagnosticLog)) {
-            console.log(`\nDiagnostic log: ${diagnosticLog}`);
-            console.log('Run: cat ' + diagnosticLog + ' | tail -50');
-        }
-        process.exit(0);
-    });
-    zshCommand
-        .command('diagnose')
-        .description('Show failed imports from diagnostic log')
-        .option('-n <number>', 'Number of recent entries to show', '20')
-        .action((options) => {
-        const diagnosticLog = path.join(os.homedir(), '.lsh', 'zsh-import.log');
-        if (!fs.existsSync(diagnosticLog)) {
-            console.log('No diagnostic log found.');
-            console.log('Import ZSH config first: lsh zsh-import all');
-            process.exit(1);
-            return;
-        }
-        const content = fs.readFileSync(diagnosticLog, 'utf8');
-        const lines = content.trim().split('\n');
-        const numLines = parseInt(options.n, 10) || 20;
-        const recentLines = lines.slice(-numLines);
-        console.log(`📋 Recent ZSH Import Diagnostics (last ${numLines} entries):\n`);
-        const failedLines = recentLines.filter(line => line.includes('failed') || line.includes('disabled'));
-        if (failedLines.length === 0) {
-            console.log('✅ No failed imports found!');
-        }
-        else {
-            failedLines.forEach(line => {
-                console.log('   ' + line);
-            });
-        }
-        process.exit(0);
-    });
-}

package/dist/components/App.js

@@ -1 +0,0 @@
-"use strict";

package/dist/components/Divider.js

@@ -1,29 +0,0 @@
-// Divider
-import { Text } from 'ink';
-import React from 'react';
-import stringWidth from 'string-width';
-export const Divider = ({ title, width, padding, titlePadding, titleColor, dividerChar }) => {
-    const getSideDividerWidth = (width, titleWidth) => (width - titleWidth) / 2;
-    const getNumberOfCharsPerWidth = (char, width) => width / stringWidth(char);
-    const PAD = ' ';
-    const titleString = title ? `${PAD.repeat(titlePadding) + title + PAD.repeat(titlePadding)}` : '';
-    const titleWidth = stringWidth(titleString);
-    const dividerWidth = getSideDividerWidth(width, titleWidth);
-    const numberOfCharsPerSide = getNumberOfCharsPerWidth(dividerChar, dividerWidth);
-    const dividerSideString = dividerChar.repeat(numberOfCharsPerSide);
-    const paddingString = PAD.repeat(padding);
-    return (React.createElement(React.Fragment, null,
-        paddingString,
-        React.createElement(Text, { color: "grey" }, dividerSideString),
-        React.createElement(Text, { color: titleColor }, titleString),
-        React.createElement(Text, { color: "grey" }, dividerSideString),
-        paddingString));
-};
-Divider.defaultProps = {
-    title: "LSH REPL",
-    width: 60,
-    padding: 0,
-    titlePadding: 1,
-    titleColor: 'white',
-    dividerChar: '~'
-};

package/dist/components/REPL.js

@@ -1,43 +0,0 @@
-import chalk from 'chalk';
-import hljs from 'highlightjs';
-import { Box, Text, useApp, useInput } from 'ink';
-import TextInput from 'ink-text-input';
-import React, { useState } from 'react';
-import vm from 'vm';
-// REPL Component
-export const REPL = () => {
-    const { exit } = useApp();
-    const [input, setInput] = useState('');
-    const [history, setHistory] = useState([]);
-    useInput((input, key) => {
-        if (key.escape) {
-            exit();
-        }
-    });
-    const handleInput = (value) => {
-        setInput(value);
-    };
-    const executeCommand = () => {
-        try {
-            const script = new vm.Script(input);
-            const context = vm.createContext(global);
-            const result = script.runInContext(context);
-            const output = result === undefined || result === null ? 'undefined' : result.toString();
-            const highlightedOutput = chalk.green(highlight(output));
-            setHistory([...history, `> ${chalk.yellow(highlight(input))}`, `= ${highlightedOutput}`]);
-        }
-        catch (err) {
-            setHistory([...history, `> ${chalk.yellow(highlight(input))}`, `! Error: ${chalk.red(err.message)}`]);
-        }
-        finally {
-            setInput('');
-        }
-    };
-    return (React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
-        React.createElement(Box, { flexGrow: 1, flexDirection: "column", borderColor: "cyan", borderStyle: "round" },
-            React.createElement(Box, { marginBottom: 1, flexDirection: "column" }, history.map((entry, index) => (React.createElement(Text, { key: index }, entry)))),
-            React.createElement(TextInput, { value: input, onChange: handleInput, onSubmit: executeCommand, placeholder: "Type JavaScript code and press Enter..." }))));
-};
-const highlight = (code) => {
-    return hljs.highlight(code, { language: 'javascript' }).value;
-};

package/dist/components/Terminal.js

@@ -1,232 +0,0 @@
-import { Box, Text, useApp, useInput } from "ink";
-import TextInput from "ink-text-input";
-import { stdout } from "process";
-import React, { useEffect, useState } from "react";
-import { Script, createContext } from "vm";
-import { shell_exec } from "../lib/shell.lib.js";
-import { parseShellCommand } from "../lib/shell-parser.js";
-import { ShellExecutor } from "../lib/shell-executor.js";
-export const Terminal = () => {
-    const [input, setInput] = useState("");
-    const [lines, setLines] = useState([]);
-    const [_mode, _setMode] = useState("auto"); // auto, js, shell
-    const [workingDir, setWorkingDir] = useState(process.cwd());
-    const [shellExecutor] = useState(() => new ShellExecutor());
-    const { exit } = useApp();
-    // Check if raw mode is supported synchronously
-    const isRawModeSupported = process.stdin.isTTY && process.stdin.setRawMode !== undefined;
-    // Detect if input is a shell command or JavaScript
-    const detectInputType = (input) => {
-        const trimmed = input.trim();
-        // Check for common shell commands
-        const shellCommands = ["ls", "cd", "pwd", "mkdir", "rm", "cp", "mv", "cat", "grep", "find", "ps", "kill", "chmod", "chown", "git", "npm", "node", "python", "curl", "wget"];
-        const firstWord = trimmed.split(' ')[0];
-        // Check for JavaScript patterns
-        const jsPatterns = [
-            /^(const|let|var|function|class|\{|\[|if|for|while|try|async|await)/,
-            /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*[=]/,
-            /\.(map|filter|reduce|forEach)/,
-            /^Math\.|^JSON\.|^console\./,
-            /^[0-9]+(\.[0-9]+)?(\s*[+\-*/])/
-        ];
-        // Force modes
-        if (trimmed.startsWith("js:"))
-            return "js";
-        if (trimmed.startsWith("sh:") || trimmed.startsWith("$"))
-            return "shell";
-        // JavaScript detection
-        if (jsPatterns.some(pattern => pattern.test(trimmed)))
-            return "js";
-        // Shell command detection
-        if (shellCommands.includes(firstWord))
-            return "shell";
-        // Default to shell for most other cases
-        return "shell";
-    };
-    // Execute JavaScript code in a VM context with enhanced features
-    const executeScript = async (input) => {
-        try {
-            let code = input;
-            if (code.startsWith("js:"))
-                code = code.substring(3).trim();
-            // Create context with useful globals
-            const context = createContext({
-                console,
-                process,
-                __dirname: workingDir,
-                __filename: '',
-                global,
-                Buffer,
-                setTimeout,
-                setInterval,
-                clearTimeout,
-                clearInterval,
-                shell_exec, // Make shell_exec available in JS context
-                sh: shell_exec, // Short alias
-            });
-            const script = new Script(code);
-            const result = script.runInContext(context);
-            return `${result !== undefined ? result : '(undefined)'}`;
-        }
-        catch (error) {
-            return `JS Error: ${error.message}`;
-        }
-    };
-    // Execute shell command using POSIX parser and executor
-    const executeShell = async (input) => {
-        try {
-            let command = input.trim();
-            if (command.startsWith("sh:"))
-                command = command.substring(3).trim();
-            if (command.startsWith("$"))
-                command = command.substring(1).trim();
-            // Parse the command using POSIX grammar
-            const ast = parseShellCommand(command);
-            // Execute the parsed command
-            const result = await shellExecutor.execute(ast);
-            // Update working directory from executor context
-            const context = shellExecutor.getContext();
-            if (context.cwd !== workingDir) {
-                setWorkingDir(context.cwd);
-            }
-            if (!result.success && result.stderr) {
-                return `Shell Error: ${result.stderr}`;
-            }
-            let output = "";
-            if (result.stdout)
-                output += result.stdout;
-            if (result.stderr)
-                output += (output ? "\n" : "") + `stderr: ${result.stderr}`;
-            return output || "(no output)";
-        }
-        catch (error) {
-            // Fallback to old shell execution for unparseable commands
-            try {
-                let command = input.trim();
-                if (command.startsWith("sh:"))
-                    command = command.substring(3).trim();
-                if (command.startsWith("$"))
-                    command = command.substring(1).trim();
-                const result = await shell_exec(command);
-                if (result.error) {
-                    return `Shell Error: ${result.error}`;
-                }
-                let output = "";
-                if (result.stdout)
-                    output += result.stdout;
-                if (result.stderr)
-                    output += (output ? "\n" : "") + `stderr: ${result.stderr}`;
-                return output || "(no output)";
-            }
-            catch (_fallbackError) {
-                return `Shell Error: ${error.message}`;
-            }
-        }
-    };
-    // Handle input submission
-    const handleSubmit = async () => {
-        if (!input.trim())
-            return;
-        const inputType = detectInputType(input);
-        const prompt = `[${workingDir.split('/').pop() || '/'}] ${inputType === 'js' ? 'js>' : '$'} ${input}`;
-        setLines(prev => [...prev, prompt]);
-        try {
-            let result;
-            if (inputType === "js") {
-                result = await executeScript(input);
-            }
-            else {
-                result = await executeShell(input);
-            }
-            // Add result with proper formatting and spacing
-            setLines(prev => [...prev, result, ""]);
-        }
-        catch (error) {
-            // Add error and a blank line for spacing
-            setLines(prev => [...prev, `Error: ${error.message}`, ""]);
-        }
-        setInput("");
-    };
-    // Handle resizing of the terminal
-    const [size, setSize] = useState({
-        columns: stdout.columns,
-        rows: stdout.rows,
-    });
-    useEffect(() => {
-        const handleResize = () => {
-            setSize({
-                columns: stdout.columns,
-                rows: stdout.rows,
-            });
-        };
-        stdout.on("resize", handleResize);
-        return () => {
-            stdout.off("resize", handleResize);
-        };
-    }, []);
-    // Only use input if raw mode is supported
-    const [_isInteractive, setIsInteractive] = useState(false);
-    useEffect(() => {
-        // Check if raw mode is supported
-        setIsInteractive(process.stdin.isTTY && process.stdin.setRawMode !== undefined);
-    }, []);
-    useInput((input, key) => {
-        if (!isRawModeSupported)
-            return;
-        if (key.return) {
-            handleSubmit();
-        }
-        else if (key.ctrl && input === "c") {
-            exit();
-        }
-    });
-    // Initialize with welcome message
-    useEffect(() => {
-        setLines([
-            "🚀 LSH Interactive Shell",
-            "Mix shell commands and JavaScript seamlessly!",
-            "Examples:",
-            "  ls -la          (shell command)",
-            "  2 + 2           (JavaScript expression)",
-            "  js: console.log('Hello')  (force JS mode)",
-            "  sh: echo 'Hi'   (force shell mode)",
-            "  await sh('ls')  (call shell from JS)",
-            "---"
-        ]);
-    }, []);
-    const currentDir = workingDir.split('/').pop() || '/';
-    const nextInputType = detectInputType(input);
-    const promptSymbol = nextInputType === 'js' ? 'js>' : '$';
-    if (!isRawModeSupported) {
-        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-            React.createElement(Text, { color: "red", bold: true }, "\u26A0\uFE0F  Interactive mode not supported"),
-            React.createElement(Text, { color: "yellow" }, "Raw mode is not supported in this environment."),
-            React.createElement(Text, { color: "gray" }, "To use the interactive REPL, run this command in a proper terminal:"),
-            React.createElement(Text, { color: "cyan" }, "  npm start repl"),
-            React.createElement(Text, { color: "gray" }, "or"),
-            React.createElement(Text, { color: "cyan" }, "  node dist/app.js repl"),
-            React.createElement(Text, { color: "gray" }, "For testing, use the shell lib functions directly in your Node.js code.")));
-    }
-    return (React.createElement(Box, { flexDirection: "column", padding: 1, width: size.columns, height: size.rows },
-        React.createElement(Box, { flexDirection: "column", width: "100%" },
-            React.createElement(Text, { color: "cyan", bold: true }, "LSH - Interactive Shell with JavaScript"),
-            React.createElement(Text, { color: "gray" },
-                "Current directory: ",
-                workingDir),
-            React.createElement(Text, { color: "gray" },
-                "Mode: Auto-detect (",
-                nextInputType === 'js' ? 'JavaScript' : 'Shell',
-                ")"),
-            React.createElement(Box, { borderStyle: "round", borderColor: "blue", paddingX: 1, marginY: 1, height: size.rows - 8, flexDirection: "column", width: "100%" },
-                React.createElement(Box, { flexDirection: "column", flexGrow: 1, overflowY: "hidden", width: "100%" }, lines.slice(Math.max(0, lines.length - (size.rows - 15))).map((line, index) => (React.createElement(Text, { key: index, wrap: "wrap", width: size.columns - 6 }, line)))),
-                React.createElement(Box, { flexDirection: "row", marginTop: 1, width: "100%" },
-                    React.createElement(Text, { color: "green" },
-                        "[",
-                        currentDir,
-                        "] ",
-                        promptSymbol,
-                        " "),
-                    React.createElement(Box, { flexGrow: 1, width: size.columns - currentDir.length - 8 },
-                        React.createElement(TextInput, { value: input, onChange: setInput, placeholder: "Enter shell command or JavaScript..." }))))),
-        React.createElement(Text, { color: "grey" }, "Press Ctrl+C to exit. Use js: or sh: to force execution mode.")));
-};

package/dist/components/UserInput.js

@@ -1,30 +0,0 @@
-import { useInput, useStdout } from 'ink';
-import React, { useState } from 'react';
-import { Divider } from './Divider.js';
-export function UserInput({ ..._props }) {
-    const [_feature, _setFeature] = useState('');
-    const [_readData, _setReadData] = useState([]);
-    const [_writeData, _setWriteData] = useState([]);
-    const [_userInput, _setUserInput] = useState('');
-    const [_name, _setName] = useState('');
-    const _handleSubmit = (_query) => {
-        // Do something with query
-        console.log(_query);
-        _setUserInput('');
-    };
-    const { stdout: _stdout, write: _write } = useStdout();
-    const _handleChange = (_query) => {
-    };
-    useInput((input, _key) => {
-        console.log(input);
-        // console.log(key);
-        if (input === 'q') {
-            // Exit program
-        }
-        ;
-    });
-    const input = (React.createElement(React.Fragment, null,
-        React.createElement(Divider, null),
-        React.createElement(Divider, null)));
-    return input;
-}