lsh-framework 0.5.4

package/dist/commands/theme.js

@@ -0,0 +1,257 @@
+/**
+ * Theme Commands
+ * Import, preview, and apply ZSH themes
+ */
+import { ThemeManager } from '../lib/theme-manager.js';
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+export function registerThemeCommands(program) {
+    const themeCommand = program
+        .command('theme')
+        .description('Manage shell themes (import Oh-My-Zsh themes, apply built-in themes)');
+    themeCommand
+        .command('list')
+        .description('List available themes')
+        .option('--ohmyzsh', 'Show only Oh-My-Zsh themes')
+        .option('--builtin', 'Show only built-in themes')
+        .option('--custom', 'Show only custom themes')
+        .action(async (options) => {
+        const manager = new ThemeManager();
+        const themes = manager.listThemes();
+        console.log(chalk.bold('\n🎨 Available Themes\n'));
+        if (!options.ohmyzsh && !options.custom || options.builtin) {
+            console.log(chalk.cyan('Built-in Themes:'));
+            themes.builtin.forEach(name => {
+                console.log(`  ${chalk.green('✓')} ${name}`);
+            });
+            console.log('');
+        }
+        if (!options.builtin && !options.custom || options.ohmyzsh) {
+            if (themes.ohmyzsh.length > 0) {
+                console.log(chalk.cyan('Oh-My-Zsh Themes:'));
+                themes.ohmyzsh.slice(0, 20).forEach(name => {
+                    console.log(`  ${chalk.yellow('◆')} ${name}`);
+                });
+                if (themes.ohmyzsh.length > 20) {
+                    console.log(chalk.dim(`  ... and ${themes.ohmyzsh.length - 20} more`));
+                }
+                console.log('');
+            }
+            else {
+                console.log(chalk.dim('No Oh-My-Zsh themes found. Install Oh-My-Zsh first.'));
+                console.log('');
+            }
+        }
+        if (!options.builtin && !options.ohmyzsh || options.custom) {
+            if (themes.custom.length > 0) {
+                console.log(chalk.cyan('Custom Themes:'));
+                themes.custom.forEach(name => {
+                    console.log(`  ${chalk.magenta('●')} ${name}`);
+                });
+            }
+            else {
+                console.log(chalk.dim('No custom themes found.'));
+            }
+            console.log('');
+        }
+        console.log(chalk.dim('Usage:'));
+        console.log(chalk.dim('  lsh theme preview <name>'));
+        console.log(chalk.dim('  lsh theme import <name>    # For Oh-My-Zsh themes'));
+        console.log(chalk.dim('  lsh theme apply <name>'));
+        console.log('');
+        process.exit(0);
+    });
+    themeCommand
+        .command('import <name>')
+        .description('Import Oh-My-Zsh theme')
+        .option('--preview', 'Preview before importing')
+        .action(async (name, options) => {
+        try {
+            const manager = new ThemeManager();
+            console.log(chalk.dim(`Importing theme: ${name}...`));
+            const theme = await manager.importOhMyZshTheme(name);
+            console.log(chalk.green(`✓ Successfully imported theme: ${name}`));
+            if (options.preview) {
+                manager.previewTheme(theme);
+            }
+            console.log(chalk.dim('\nTo apply this theme:'));
+            console.log(chalk.cyan(`  lsh theme apply ${name}`));
+            console.log('');
+            process.exit(0);
+        }
+        catch (error) {
+            console.error(chalk.red(`✗ Failed to import theme: ${error.message}`));
+            process.exit(1);
+        }
+    });
+    themeCommand
+        .command('preview <name>')
+        .description('Preview theme without applying')
+        .action(async (name) => {
+        try {
+            const manager = new ThemeManager();
+            // Try to load theme
+            let theme;
+            try {
+                theme = await manager.importOhMyZshTheme(name);
+            }
+            catch {
+                // Try built-in
+                theme = manager.getBuiltinTheme(name);
+            }
+            manager.previewTheme(theme);
+            console.log(chalk.dim('To apply this theme:'));
+            console.log(chalk.cyan(`  lsh theme apply ${name}`));
+            console.log('');
+            process.exit(0);
+        }
+        catch (_error) {
+            console.error(chalk.red(`✗ Theme not found: ${name}`));
+            console.log(chalk.dim('\nAvailable themes:'));
+            console.log(chalk.dim('  lsh theme list'));
+            process.exit(1);
+        }
+    });
+    themeCommand
+        .command('apply <name>')
+        .description('Apply theme to current shell')
+        .option('--save', 'Save to ~/.lshrc for persistent use')
+        .action(async (name, options) => {
+        try {
+            const manager = new ThemeManager();
+            // Try to import/load theme
+            let theme;
+            try {
+                // Try as Oh-My-Zsh theme first
+                theme = await manager.importOhMyZshTheme(name);
+            }
+            catch {
+                // Try as built-in theme
+                theme = manager.getBuiltinTheme(name);
+            }
+            const commands = manager.applyTheme(theme);
+            console.log(chalk.green(`✓ Applied theme: ${name}`));
+            console.log('');
+            console.log(chalk.dim('Theme settings:'));
+            console.log(commands);
+            console.log('');
+            if (options.save) {
+                const lshrcPath = path.join(os.homedir(), '.lshrc');
+                let lshrcContent = '';
+                if (fs.existsSync(lshrcPath)) {
+                    lshrcContent = fs.readFileSync(lshrcPath, 'utf8');
+                    // Remove old theme settings
+                    lshrcContent = lshrcContent.replace(/# LSH Theme[\s\S]*?# End LSH Theme\n*/g, '');
+                }
+                const themeBlock = `
+# LSH Theme: ${name}
+${commands}
+# End LSH Theme
+`;
+                lshrcContent += themeBlock;
+                fs.writeFileSync(lshrcPath, lshrcContent, 'utf8');
+                console.log(chalk.green('✓ Theme saved to ~/.lshrc'));
+                console.log(chalk.dim('  Theme will be applied automatically on next shell start'));
+            }
+            else {
+                console.log(chalk.dim('To save permanently:'));
+                console.log(chalk.cyan(`  lsh theme apply ${name} --save`));
+            }
+            console.log('');
+            process.exit(0);
+        }
+        catch (error) {
+            console.error(chalk.red(`✗ Failed to apply theme: ${error.message}`));
+            process.exit(1);
+        }
+    });
+    themeCommand
+        .command('current')
+        .description('Show current theme')
+        .action(() => {
+        const lshrcPath = path.join(os.homedir(), '.lshrc');
+        if (!fs.existsSync(lshrcPath)) {
+            console.log(chalk.dim('No theme configured (using default)'));
+            process.exit(0);
+            return;
+        }
+        const content = fs.readFileSync(lshrcPath, 'utf8');
+        const themeMatch = content.match(/# LSH Theme: (.+)/);
+        if (themeMatch) {
+            console.log(chalk.bold(`Current theme: ${chalk.cyan(themeMatch[1])}`));
+        }
+        else {
+            console.log(chalk.dim('No theme configured (using default)'));
+        }
+        process.exit(0);
+    });
+    themeCommand
+        .command('reset')
+        .description('Reset to default theme')
+        .action(() => {
+        const lshrcPath = path.join(os.homedir(), '.lshrc');
+        if (fs.existsSync(lshrcPath)) {
+            let content = fs.readFileSync(lshrcPath, 'utf8');
+            content = content.replace(/# LSH Theme[\s\S]*?# End LSH Theme\n*/g, '');
+            fs.writeFileSync(lshrcPath, content, 'utf8');
+        }
+        console.log(chalk.green('✓ Reset to default theme'));
+        console.log(chalk.dim('Restart shell to see changes'));
+        process.exit(0);
+    });
+    themeCommand
+        .command('from-zshrc')
+        .description('Import current ZSH theme from ~/.zshrc')
+        .option('--apply', 'Apply after importing')
+        .action(async (options) => {
+        try {
+            const zshrcPath = path.join(os.homedir(), '.zshrc');
+            if (!fs.existsSync(zshrcPath)) {
+                console.error(chalk.red('✗ ~/.zshrc not found'));
+                process.exit(1);
+                return;
+            }
+            const zshrcContent = fs.readFileSync(zshrcPath, 'utf8');
+            const themeMatch = zshrcContent.match(/ZSH_THEME="([^"]+)"/);
+            if (!themeMatch) {
+                console.error(chalk.red('✗ No theme found in ~/.zshrc'));
+                process.exit(1);
+                return;
+            }
+            const themeName = themeMatch[1];
+            console.log(chalk.dim(`Found ZSH theme: ${themeName}`));
+            const manager = new ThemeManager();
+            const theme = await manager.importOhMyZshTheme(themeName);
+            console.log(chalk.green(`✓ Imported theme: ${themeName}`));
+            if (options.apply) {
+                const commands = manager.applyTheme(theme);
+                const lshrcPath = path.join(os.homedir(), '.lshrc');
+                let lshrcContent = '';
+                if (fs.existsSync(lshrcPath)) {
+                    lshrcContent = fs.readFileSync(lshrcPath, 'utf8');
+                    lshrcContent = lshrcContent.replace(/# LSH Theme[\s\S]*?# End LSH Theme\n*/g, '');
+                }
+                const themeBlock = `
+# LSH Theme: ${themeName}
+${commands}
+# End LSH Theme
+`;
+                lshrcContent += themeBlock;
+                fs.writeFileSync(lshrcPath, lshrcContent, 'utf8');
+                console.log(chalk.green('✓ Theme applied and saved to ~/.lshrc'));
+            }
+            else {
+                console.log(chalk.dim('\nTo apply:'));
+                console.log(chalk.cyan(`  lsh theme apply ${themeName} --save`));
+            }
+            console.log('');
+            process.exit(0);
+        }
+        catch (error) {
+            console.error(chalk.red(`✗ Failed to import theme: ${error.message}`));
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/zsh-import.js

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

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

package/dist/components/Divider.js

@@ -0,0 +1,29 @@
+// 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

@@ -0,0 +1,43 @@
+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;
+};