@lenne.tech/cli 1.6.3 → 1.6.5

package/build/lib/plugin-utils.js

@@ -0,0 +1,453 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_POST_INSTALL = exports.MAX_COMMANDS_TO_SHOW = exports.EMPTY_PLUGIN_CONTENTS = void 0;
+exports.findMarkdownFiles = findMarkdownFiles;
+exports.handleMissingEnvVars = handleMissingEnvVars;
+exports.printPluginSummary = printPluginSummary;
+exports.processPostInstall = processPostInstall;
+exports.readPluginContents = readPluginContents;
+exports.setupPermissions = setupPermissions;
+/**
+ * Plugin utilities for Claude Code plugin management
+ * Handles reading plugin contents, permissions, and post-installation setup
+ */
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const claude_cli_1 = require("./claude-cli");
+const json_utils_1 = require("./json-utils");
+const shell_config_1 = require("./shell-config");
+/**
+ * Empty plugin contents constant (used for failed installations)
+ */
+exports.EMPTY_PLUGIN_CONTENTS = {
+    agents: [],
+    commands: [],
+    hooks: 0,
+    mcpServers: [],
+    permissions: [],
+    skills: [],
+};
+/**
+ * Maximum number of commands to show in plugin summary before truncating
+ */
+exports.MAX_COMMANDS_TO_SHOW = 5;
+/**
+ * Post-installation configurations for specific plugins
+ * These define additional setup steps needed after plugin installation
+ */
+exports.PLUGIN_POST_INSTALL = {
+    'typescript-lsp': {
+        envVars: [
+            {
+                description: 'Enable LSP tools in Claude Code (required for LSP features)',
+                name: 'ENABLE_LSP_TOOL',
+                value: '1',
+            },
+        ],
+        requirements: [
+            {
+                checkCommand: 'which typescript-language-server',
+                description: 'TypeScript language server',
+                installCommand: 'npm install -g typescript-language-server typescript',
+            },
+        ],
+    },
+};
+/**
+ * Recursively find all .md files in a directory and convert to command names
+ * @param dir - Directory to search
+ * @param basePath - Base path for relative path calculation
+ * @returns Array of command names (e.g., '/git:commit-message')
+ */
+function findMarkdownFiles(dir, basePath = '') {
+    const results = [];
+    if (!(0, fs_1.existsSync)(dir))
+        return results;
+    try {
+        const entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = (0, path_1.join)(dir, entry.name);
+            const relativePath = basePath ? `${basePath}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                results.push(...findMarkdownFiles(fullPath, relativePath));
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                // Convert path to command name (e.g., "git/commit-message.md" -> "/git:commit-message")
+                const commandName = relativePath
+                    .replace(/\.md$/, '')
+                    .replace(/\//g, ':');
+                results.push(`/${commandName}`);
+            }
+        }
+    }
+    catch (_a) {
+        // Directory read failed, return empty results
+    }
+    return results;
+}
+/**
+ * Handle missing environment variables from plugin installations
+ * Checks shell config, prompts user to add missing vars, and provides manual instructions
+ * @param missingEnvVars - Map of env var name to PluginEnvVar
+ * @param toolbox - Toolbox with print and prompt functions
+ * @returns Result indicating if vars were needed and if they were configured
+ */
+function handleMissingEnvVars(missingEnvVars, toolbox) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { print: { error, info, success, warning }, prompt, } = toolbox;
+        const result = {
+            configured: false,
+            needed: false,
+        };
+        if (missingEnvVars.size === 0) {
+            return result;
+        }
+        // Get preferred shell config
+        const targetConfig = (0, shell_config_1.getPreferredShellConfig)();
+        // Check which env vars are truly missing (not in file either)
+        const envVarsToAdd = [];
+        const envVarsAlreadyInFile = [];
+        for (const envVar of missingEnvVars.values()) {
+            if (targetConfig && (0, shell_config_1.checkEnvVarInFile)(targetConfig.path, envVar.name, envVar.value)) {
+                envVarsAlreadyInFile.push(envVar);
+            }
+            else {
+                envVarsToAdd.push(envVar);
+            }
+        }
+        // Show already configured vars
+        if (envVarsAlreadyInFile.length > 0) {
+            info('');
+            for (const envVar of envVarsAlreadyInFile) {
+                info(`${envVar.name} already configured in ${targetConfig === null || targetConfig === void 0 ? void 0 : targetConfig.path}`);
+            }
+            info(`Run 'source ${targetConfig === null || targetConfig === void 0 ? void 0 : targetConfig.path}' or restart your terminal to apply.`);
+        }
+        // Handle vars that need to be added
+        if (envVarsToAdd.length > 0) {
+            result.needed = true;
+            info('');
+            warning('Environment variables required:');
+            for (const envVar of envVarsToAdd) {
+                info(`  ${envVar.name}=${envVar.value}`);
+                info(`    ${envVar.description}`);
+            }
+            if (targetConfig) {
+                // Ask user if they want to add the env vars automatically
+                const shouldAdd = yield prompt.confirm(`Add ${envVarsToAdd.length > 1 ? 'these variables' : envVarsToAdd[0].name} to ${targetConfig.path}?`, true);
+                if (shouldAdd) {
+                    let allAdded = true;
+                    for (const envVar of envVarsToAdd) {
+                        const added = (0, shell_config_1.addEnvVarToShellConfig)(targetConfig.path, envVar.name, envVar.value);
+                        if (added) {
+                            success(`  Added ${envVar.name}=${envVar.value} to ${targetConfig.path}`);
+                        }
+                        else {
+                            error(`  Failed to add ${envVar.name} to ${targetConfig.path}`);
+                            allAdded = false;
+                        }
+                    }
+                    if (allAdded) {
+                        result.configured = true;
+                        info('');
+                        info(`Run 'source ${targetConfig.path}' or restart your terminal to apply changes.`);
+                    }
+                }
+                else {
+                    info('');
+                    info('To add manually, run:');
+                    for (const envVar of envVarsToAdd) {
+                        info(`  echo 'export ${envVar.name}=${envVar.value}' >> ${targetConfig.path}`);
+                    }
+                }
+            }
+            else {
+                info('');
+                info('Add manually to your shell profile:');
+                for (const envVar of envVarsToAdd) {
+                    info(`  export ${envVar.name}=${envVar.value}`);
+                }
+            }
+        }
+        return result;
+    });
+}
+/**
+ * Print plugin summary with skills, commands, agents, etc.
+ * @param pluginName - Name of the plugin
+ * @param contents - Plugin contents
+ * @param info - Info print function from toolbox
+ */
+function printPluginSummary(pluginName, contents, info) {
+    const isLspPlugin = pluginName.endsWith('-lsp');
+    const hasContent = contents.skills.length > 0 || contents.commands.length > 0 || contents.agents.length > 0;
+    if (hasContent || isLspPlugin) {
+        info('');
+        info(`${pluginName}:`);
+        // Show LSP indicator for LSP plugins
+        if (isLspPlugin) {
+            info(`  Type: Language Server (LSP)`);
+        }
+        // Alphabetical order: Agents, Commands, Hooks, MCP Servers, Skills
+        if (contents.agents.length > 0) {
+            info(`  Agents (${contents.agents.length}): ${contents.agents.join(', ')}`);
+        }
+        if (contents.commands.length > 0) {
+            const shown = contents.commands.slice(0, exports.MAX_COMMANDS_TO_SHOW);
+            const remaining = contents.commands.length - exports.MAX_COMMANDS_TO_SHOW;
+            const commandsStr = remaining > 0
+                ? `${shown.join(', ')} and ${remaining} more`
+                : shown.join(', ');
+            info(`  Commands (${contents.commands.length}): ${commandsStr}`);
+        }
+        if (contents.hooks > 0) {
+            info(`  Hooks: ${contents.hooks} auto-detection hooks`);
+        }
+        if (contents.mcpServers.length > 0) {
+            info(`  MCP Servers (${contents.mcpServers.length}): ${contents.mcpServers.join(', ')}`);
+        }
+        if (contents.skills.length > 0) {
+            info(`  Skills (${contents.skills.length}): ${contents.skills.join(', ')}`);
+        }
+    }
+}
+/**
+ * Process post-installation requirements for a plugin
+ * Checks and installs required dependencies, reports missing env vars
+ * @param pluginName - Name of the plugin
+ * @param toolbox - Extended Gluegun toolbox
+ * @returns Post-install result with success status and details
+ */
+function processPostInstall(pluginName, toolbox) {
+    const { print: { spin, warning }, } = toolbox;
+    const result = {
+        envVarsMissing: [],
+        requirementsInstalled: [],
+        requirementsMissing: [],
+        success: true,
+    };
+    const postInstall = exports.PLUGIN_POST_INSTALL[pluginName];
+    if (!postInstall) {
+        return result;
+    }
+    // Check and install requirements
+    if (postInstall.requirements) {
+        for (const req of postInstall.requirements) {
+            // If checkCommand is provided, verify if requirement is already met
+            if (req.checkCommand) {
+                const checkSpinner = spin(`Checking ${req.description}`);
+                if ((0, claude_cli_1.checkCommandExists)(req.checkCommand)) {
+                    checkSpinner.succeed(`${req.description} already installed`);
+                    continue;
+                }
+                // Try to install
+                checkSpinner.text = `Installing ${req.description}`;
+                try {
+                    (0, child_process_1.execSync)(req.installCommand, {
+                        encoding: 'utf-8',
+                        stdio: ['pipe', 'pipe', 'pipe'],
+                    });
+                    // Verify installation
+                    if ((0, claude_cli_1.checkCommandExists)(req.checkCommand)) {
+                        checkSpinner.succeed(`${req.description} installed`);
+                        result.requirementsInstalled.push(req.description);
+                    }
+                    else {
+                        checkSpinner.fail(`${req.description} installation may have failed`);
+                        result.requirementsMissing.push(req.description);
+                        result.success = false;
+                    }
+                }
+                catch (err) {
+                    checkSpinner.fail(`Failed to install ${req.description}`);
+                    warning(`  Command: ${req.installCommand}`);
+                    warning(`  Error: ${err.message}`);
+                    result.requirementsMissing.push(req.description);
+                    result.success = false;
+                }
+            }
+            else {
+                // No checkCommand provided - always run installCommand
+                const installSpinner = spin(`Running ${req.description}`);
+                try {
+                    (0, child_process_1.execSync)(req.installCommand, {
+                        encoding: 'utf-8',
+                        stdio: ['pipe', 'pipe', 'pipe'],
+                    });
+                    installSpinner.succeed(`${req.description} completed`);
+                    result.requirementsInstalled.push(req.description);
+                }
+                catch (err) {
+                    installSpinner.fail(`Failed: ${req.description}`);
+                    warning(`  Command: ${req.installCommand}`);
+                    warning(`  Error: ${err.message}`);
+                    result.requirementsMissing.push(req.description);
+                    result.success = false;
+                }
+            }
+        }
+    }
+    // Check environment variables
+    if (postInstall.envVars) {
+        for (const envVar of postInstall.envVars) {
+            const currentValue = process.env[envVar.name];
+            if (currentValue !== envVar.value) {
+                result.envVarsMissing.push(envVar);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Read plugin contents from installed plugin directory
+ * @param marketplaceName - Name of the marketplace
+ * @param pluginName - Name of the plugin
+ * @returns Plugin contents with skills, commands, agents, hooks, etc.
+ */
+function readPluginContents(marketplaceName, pluginName) {
+    const pluginDir = (0, path_1.join)((0, os_1.homedir)(), '.claude', 'plugins', 'marketplaces', marketplaceName, 'plugins', pluginName);
+    const result = {
+        agents: [],
+        commands: [],
+        hooks: 0,
+        mcpServers: [],
+        permissions: [],
+        skills: [],
+    };
+    // Read skills
+    const skillsDir = (0, path_1.join)(pluginDir, 'skills');
+    if ((0, fs_1.existsSync)(skillsDir)) {
+        try {
+            result.skills = (0, fs_1.readdirSync)(skillsDir, { withFileTypes: true })
+                .filter(dirent => dirent.isDirectory())
+                .map(dirent => dirent.name);
+        }
+        catch (_a) {
+            // Skills directory read failed
+        }
+    }
+    // Read agents
+    const agentsDir = (0, path_1.join)(pluginDir, 'agents');
+    if ((0, fs_1.existsSync)(agentsDir)) {
+        try {
+            result.agents = (0, fs_1.readdirSync)(agentsDir, { withFileTypes: true })
+                .filter(dirent => dirent.isFile() && dirent.name.endsWith('.md'))
+                .map(dirent => dirent.name.replace(/\.md$/, ''));
+        }
+        catch (_b) {
+            // Agents directory read failed
+        }
+    }
+    // Read commands
+    const commandsDir = (0, path_1.join)(pluginDir, 'commands');
+    result.commands = findMarkdownFiles(commandsDir);
+    // Read hooks
+    const hooksPath = (0, path_1.join)(pluginDir, 'hooks', 'hooks.json');
+    const hooksContent = safeReadJson(hooksPath);
+    if (hooksContent === null || hooksContent === void 0 ? void 0 : hooksContent.hooks) {
+        // Count hooks across all event types
+        for (const eventHooks of Object.values(hooksContent.hooks)) {
+            if (Array.isArray(eventHooks)) {
+                for (const hookGroup of eventHooks) {
+                    if (hookGroup.hooks && Array.isArray(hookGroup.hooks)) {
+                        result.hooks += hookGroup.hooks.length;
+                    }
+                }
+            }
+        }
+    }
+    // Read MCP servers
+    const mcpPath = (0, path_1.join)(pluginDir, '.mcp.json');
+    const mcpContent = safeReadJson(mcpPath);
+    if (mcpContent === null || mcpContent === void 0 ? void 0 : mcpContent.mcpServers) {
+        result.mcpServers = Object.keys(mcpContent.mcpServers);
+    }
+    // Read permissions
+    const permissionsPath = (0, path_1.join)(pluginDir, 'permissions.json');
+    const pluginPerms = safeReadJson(permissionsPath);
+    if (pluginPerms === null || pluginPerms === void 0 ? void 0 : pluginPerms.permissions) {
+        result.permissions = pluginPerms.permissions.map(p => p.pattern);
+    }
+    return result;
+}
+/**
+ * Setup permissions in settings.json
+ * Only adds new permissions, does not remove existing ones
+ * (User may have customized permissions that should be preserved)
+ * @param requiredPermissions - Array of permission patterns to add
+ * @param error - Error print function from toolbox
+ * @returns Result with added and existing permissions
+ */
+function setupPermissions(requiredPermissions, error) {
+    const settingsPath = (0, path_1.join)((0, os_1.homedir)(), '.claude', 'settings.json');
+    try {
+        // Read existing settings
+        let settings = {};
+        if ((0, fs_1.existsSync)(settingsPath)) {
+            const content = (0, fs_1.readFileSync)(settingsPath, 'utf-8');
+            const parsed = (0, json_utils_1.safeJsonParse)(content);
+            if (parsed) {
+                settings = parsed;
+            }
+        }
+        // Ensure permissions.allow exists
+        if (!settings.permissions) {
+            settings.permissions = {};
+        }
+        const perms = settings.permissions;
+        if (!perms.allow) {
+            perms.allow = [];
+        }
+        const currentAllowList = perms.allow;
+        // Determine what to add
+        const added = [];
+        const existing = [];
+        requiredPermissions.forEach(perm => {
+            if (currentAllowList.includes(perm)) {
+                existing.push(perm);
+            }
+            else {
+                added.push(perm);
+            }
+        });
+        // Add new permissions
+        if (added.length > 0) {
+            perms.allow = [...currentAllowList, ...added];
+            (0, fs_1.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2));
+        }
+        return { added, existing, success: true };
+    }
+    catch (err) {
+        error(`Could not configure permissions: ${err.message}`);
+        return { added: [], existing: [], success: false };
+    }
+}
+/**
+ * Safely read and parse a JSON file
+ * @param filePath - Path to the JSON file
+ * @returns Parsed object or null if reading/parsing fails
+ */
+function safeReadJson(filePath) {
+    try {
+        if (!(0, fs_1.existsSync)(filePath)) {
+            return null;
+        }
+        const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+        return (0, json_utils_1.safeJsonParse)(content);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-utils.js","sourceRoot":"","sources":["../../src/lib/plugin-utils.ts"],"names":[],"mappings":"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"}

package/build/lib/shell-config.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addAliasBlockToShellConfig = addAliasBlockToShellConfig;
+exports.addAliasToShellConfig = addAliasToShellConfig;
+exports.addEnvVarToShellConfig = addEnvVarToShellConfig;
+exports.checkAliasInFile = checkAliasInFile;
+exports.checkEnvVarInFile = checkEnvVarInFile;
+exports.detectShellConfigs = detectShellConfigs;
+exports.getPreferredShellConfig = getPreferredShellConfig;
+/**
+ * Shell configuration utilities for CLI commands
+ * Handles detection and modification of shell config files (.zshrc, .bashrc, etc.)
+ */
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+/**
+ * Known shell configuration files in order of preference
+ */
+const SHELL_CONFIG_FILES = [
+    { file: '.zshrc', shell: 'zsh' },
+    { file: '.bashrc', shell: 'bash' },
+    { file: '.bash_profile', shell: 'bash' },
+    { file: '.profile', shell: 'sh' },
+];
+/**
+ * Add multiple aliases to a shell config file as a block
+ * @param configPath - Full path to the shell config file
+ * @param aliases - Array of alias definitions
+ * @param blockComment - Comment header for the block
+ * @returns true if successful, false otherwise
+ */
+function addAliasBlockToShellConfig(configPath, aliases, blockComment = 'Claude Code shortcuts - Added by lenne.tech CLI') {
+    try {
+        const lines = [`\n# ${blockComment}`];
+        for (const { alias, command } of aliases) {
+            lines.push(`alias ${alias}='${command}'`);
+        }
+        lines.push('');
+        (0, fs_1.appendFileSync)(configPath, lines.join('\n'), 'utf-8');
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Add an alias to a shell config file
+ * @param configPath - Full path to the shell config file
+ * @param alias - Alias name
+ * @param command - Command the alias expands to
+ * @param comment - Optional comment to add before the alias
+ * @returns true if successful, false otherwise
+ */
+function addAliasToShellConfig(configPath, alias, command, comment = 'Added by lenne.tech CLI') {
+    try {
+        const lineToAdd = `\n# ${comment}\nalias ${alias}='${command}'\n`;
+        (0, fs_1.appendFileSync)(configPath, lineToAdd, 'utf-8');
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Add an environment variable export to a shell config file
+ * @param configPath - Full path to the shell config file
+ * @param envName - Name of the environment variable
+ * @param envValue - Value to set
+ * @param comment - Optional comment to add before the export
+ * @returns true if successful, false otherwise
+ */
+function addEnvVarToShellConfig(configPath, envName, envValue, comment = 'Added by lenne.tech CLI') {
+    try {
+        const lineToAdd = `\n# ${comment}\nexport ${envName}=${envValue}\n`;
+        (0, fs_1.appendFileSync)(configPath, lineToAdd, 'utf-8');
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Check if an alias is already defined in a shell config file
+ * @param configPath - Full path to the shell config file
+ * @param alias - Alias name to check
+ * @returns true if the alias exists in the file
+ */
+function checkAliasInFile(configPath, alias) {
+    try {
+        if (!(0, fs_1.existsSync)(configPath)) {
+            return false;
+        }
+        const content = (0, fs_1.readFileSync)(configPath, 'utf-8');
+        // Check for alias definition (with single or double quotes)
+        const patterns = [
+            `alias ${alias}=`,
+            `alias ${alias} =`,
+        ];
+        return patterns.some(p => content.includes(p));
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Check if an environment variable is already set in a shell config file
+ * Checks for common export formats (with/without quotes)
+ * @param configPath - Full path to the shell config file
+ * @param envName - Name of the environment variable
+ * @param envValue - Expected value
+ * @returns true if the export exists in the file
+ */
+function checkEnvVarInFile(configPath, envName, envValue) {
+    try {
+        if (!(0, fs_1.existsSync)(configPath)) {
+            return false;
+        }
+        const content = (0, fs_1.readFileSync)(configPath, 'utf-8');
+        // Check for existing export (with or without quotes)
+        const patterns = [
+            `export ${envName}=${envValue}`,
+            `export ${envName}="${envValue}"`,
+            `export ${envName}='${envValue}'`,
+        ];
+        return patterns.some(p => content.includes(p));
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Detect available shell configuration files for the current user
+ * Prioritizes the current shell's config file
+ * @returns Array of shell config file info, sorted by preference
+ */
+function detectShellConfigs() {
+    const home = (0, os_1.homedir)();
+    const configs = [];
+    // Check current shell from environment
+    const currentShell = process.env.SHELL ? (0, path_1.basename)(process.env.SHELL) : null;
+    for (const { file, shell } of SHELL_CONFIG_FILES) {
+        const fullPath = (0, path_1.join)(home, file);
+        const fileExists = (0, fs_1.existsSync)(fullPath);
+        // Prioritize current shell's config
+        if (fileExists || (currentShell && currentShell === shell)) {
+            configs.push({
+                exists: fileExists,
+                path: fullPath,
+                shell,
+            });
+        }
+    }
+    // If no configs found, suggest creating .zshrc or .bashrc based on current shell
+    if (configs.length === 0) {
+        const defaultShell = currentShell || 'zsh';
+        const defaultFile = defaultShell === 'bash' ? '.bashrc' : '.zshrc';
+        configs.push({
+            exists: false,
+            path: (0, path_1.join)(home, defaultFile),
+            shell: defaultShell,
+        });
+    }
+    return configs;
+}
+/**
+ * Get the preferred shell config file for the current user
+ * Returns the first existing config, or suggests a default
+ * @returns The preferred shell config file info, or null if none found
+ */
+function getPreferredShellConfig() {
+    const configs = detectShellConfigs();
+    return configs.find(c => c.exists) || configs[0] || null;
+}
+//# sourceMappingURL=data:application/json;base64,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