@lenne.tech/cli 0.0.125 → 1.0.1

package/bin/lt

@@ -2,20 +2,151 @@
 
 
 /* tslint:disable */
-// check if we're running in dev mode
-var devMode = require('fs').existsSync(`${__dirname}/../src`);
-// or want to "force" running the compiled version with --compiled-build
-var wantsCompiled = process.argv.indexOf('--compiled-build') >= 0;
-
-if (wantsCompiled || !devMode) {
-  // this runs from the compiled javascript source
-  require(`${__dirname}/../build/cli`).run(process.argv);
-} else {
-  // this runs from the typescript source (for dev only)
-  // hook into ts-node so we can run typescript on the fly
-  require('ts-node').register({ project: `${__dirname}/../tsconfig.json` });
-  // run the CLI with the current process arguments
-  require(`${__dirname}/../src/cli`).run(process.argv);
+
+// Handle case where current working directory no longer exists
+try {
+  process.cwd();
+} catch (err) {
+  // Current directory doesn't exist - offer interactive solutions
+  var fs = require('fs');
+  var path = require('path');
+  var os = require('os');
+  var readline = require('readline');
+
+  console.error('\nError: Current working directory no longer exists.');
+  console.error('The directory you were in has been deleted or is no longer accessible.\n');
+
+  // Try to find the next existing parent directory
+  var originalPath = process.env.PWD || process.env.OLDPWD || '';
+  var parentDir = null;
+
+  if (originalPath) {
+    var testPath = path.dirname(originalPath);
+    while (testPath && testPath !== '/' && testPath !== '.') {
+      try {
+        if (fs.existsSync(testPath) && fs.statSync(testPath).isDirectory()) {
+          parentDir = testPath;
+          break;
+        }
+      } catch (e) {
+        // Continue searching
+      }
+      testPath = path.dirname(testPath);
+    }
+  }
+
+  // Build options
+  var options = [];
+  if (parentDir) {
+    options.push({ key: '1', label: 'Change to nearest existing parent directory: ' + parentDir, action: parentDir });
+  }
+  options.push({ key: parentDir ? '2' : '1', label: 'Change to home directory: ' + os.homedir(), action: os.homedir() });
+  options.push({ key: parentDir ? '3' : '2', label: 'Enter a custom directory path', action: 'custom' });
+  options.push({ key: parentDir ? '4' : '3', label: 'Cancel and exit', action: 'exit' });
+
+  // Display options
+  console.log('Please choose an option:\n');
+  options.forEach(function(opt) {
+    console.log('  ' + opt.key + ') ' + opt.label);
+  });
+  console.log('');
+
+  // Read user input
+  var rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  rl.question('Enter your choice: ', function(answer) {
+    var choice = options.find(function(opt) { return opt.key === answer.trim(); });
+
+    if (!choice) {
+      console.error('\nInvalid choice. Exiting.\n');
+      rl.close();
+      process.exit(1);
+      return;
+    }
+
+    if (choice.action === 'exit') {
+      console.log('\nCancelled.\n');
+      rl.close();
+      process.exit(0);
+      return;
+    }
+
+    if (choice.action === 'custom') {
+      rl.question('Enter directory path (absolute or relative to ' + (parentDir || os.homedir()) + '): ', function(customPath) {
+        var targetPath = customPath.trim();
+
+        // If relative path, resolve it relative to parent or home
+        if (!path.isAbsolute(targetPath)) {
+          targetPath = path.resolve(parentDir || os.homedir(), targetPath);
+        }
+
+        try {
+          if (!fs.existsSync(targetPath)) {
+            console.error('\nError: Directory does not exist: ' + targetPath + '\n');
+            rl.close();
+            process.exit(1);
+            return;
+          }
+
+          process.chdir(targetPath);
+          console.log('\nChanged to: ' + targetPath + '\n');
+          rl.close();
+          continueExecution();
+        } catch (e) {
+          console.error('\nError: Cannot change to directory: ' + targetPath);
+          console.error(e.message + '\n');
+          rl.close();
+          process.exit(1);
+        }
+      });
+      return;
+    }
+
+    // Change to selected directory
+    try {
+      process.chdir(choice.action);
+      console.log('\nChanged to: ' + choice.action + '\n');
+      rl.close();
+      continueExecution();
+    } catch (e) {
+      console.error('\nError: Cannot change to directory: ' + choice.action);
+      console.error(e.message + '\n');
+      rl.close();
+      process.exit(1);
+    }
+  });
+
+  // Function to continue CLI execution after directory change
+  function continueExecution() {
+    runCLI();
+  }
+
+  // Don't continue execution here - wait for user choice
+  return;
+}
+
+// Normal execution path
+runCLI();
+
+function runCLI() {
+  // check if we're running in dev mode
+  var devMode = require('fs').existsSync(`${__dirname}/../src`);
+  // or want to "force" running the compiled version with --compiled-build
+  var wantsCompiled = process.argv.indexOf('--compiled-build') >= 0;
+
+  if (wantsCompiled || !devMode) {
+    // this runs from the compiled javascript source
+    require(`${__dirname}/../build/cli`).run(process.argv);
+  } else {
+    // this runs from the typescript source (for dev only)
+    // hook into ts-node so we can run typescript on the fly
+    require('ts-node').register({ project: `${__dirname}/../tsconfig.json` });
+    // run the CLI with the current process arguments
+    require(`${__dirname}/../src/cli`).run(process.argv);
+  }
 }
 
 

package/build/commands/claude/install-commands.js

@@ -0,0 +1,332 @@
+"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 });
+const os_1 = require("os");
+const path_1 = require("path");
+/**
+ * Get command description from .md frontmatter
+ */
+function getCommandDescription(commandPath, filesystem) {
+    if (!filesystem.exists(commandPath)) {
+        return 'No description available';
+    }
+    const content = filesystem.read(commandPath);
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+        return 'No description available';
+    }
+    const frontmatter = frontmatterMatch[1];
+    const descMatch = frontmatter.match(/description:\s*([^\n]+)/);
+    return descMatch ? descMatch[1].trim() : 'No description available';
+}
+/**
+ * Compare semantic versions
+ * Returns true if sourceVersion >= targetVersion
+ */
+function isVersionNewer(sourceVersion, targetVersion) {
+    const parseSemver = (version) => {
+        return version.split('.').map(n => parseInt(n, 10) || 0);
+    };
+    const source = parseSemver(sourceVersion);
+    const target = parseSemver(targetVersion);
+    // Compare major, minor, patch
+    for (let i = 0; i < 3; i++) {
+        if (source[i] > target[i]) {
+            return true;
+        }
+        if (source[i] < target[i]) {
+            return false;
+        }
+    }
+    // Versions are equal
+    return true;
+}
+/**
+ * Parse frontmatter from markdown file and extract version
+ */
+function parseVersion(content) {
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+        return null;
+    }
+    const frontmatter = frontmatterMatch[1];
+    const versionMatch = frontmatter.match(/version:\s*([^\n]+)/);
+    return versionMatch ? versionMatch[1].trim() : null;
+}
+/**
+ * Install Claude Commands to ~/.claude/commands/ or .claude/commands/
+ */
+const NewCommand = {
+    alias: ['commands', 'ic'],
+    description: 'Installs Claude Custom Commands to ~/.claude/commands/ or .claude/commands/ for Claude Code integration. Use --global for global installation, --project for project-specific installation.',
+    hidden: false,
+    name: 'install-commands',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        // Retrieve the tools we need
+        const { filesystem, parameters, print: { error, info, spin, success }, prompt, } = toolbox;
+        try {
+            // Get the CLI installation directory
+            const cliRoot = (0, path_1.join)(__dirname, '..', '..');
+            const commandsTemplateDir = (0, path_1.join)(cliRoot, 'templates', 'claude-commands');
+            // Check if claude-commands directory exists
+            if (!filesystem.exists(commandsTemplateDir)) {
+                error('Claude commands directory not found in CLI installation.');
+                info(`Expected location: ${commandsTemplateDir}`);
+                info('Please reinstall the CLI or report this issue.');
+                return;
+            }
+            // Get all available commands (*.md files, excluding README.md)
+            const allFiles = filesystem.list(commandsTemplateDir) || [];
+            const availableCommands = allFiles.filter(file => file.endsWith('.md') && file !== 'README.md');
+            if (availableCommands.length === 0) {
+                error('No commands found in CLI installation.');
+                return;
+            }
+            // Determine installation scope
+            const cwd = filesystem.cwd();
+            let scope = 'global';
+            let commandsDir = (0, path_1.join)((0, os_1.homedir)(), '.claude', 'commands');
+            const skipInteractive = parameters.options.y || parameters.options.yes || parameters.options['no-interactive'];
+            // Check if user specified scope
+            if (parameters.options.global) {
+                scope = 'global';
+                commandsDir = (0, path_1.join)((0, os_1.homedir)(), '.claude', 'commands');
+            }
+            else if (parameters.options.project) {
+                scope = 'project';
+                commandsDir = (0, path_1.join)(cwd, '.claude', 'commands');
+            }
+            else {
+                // Detect if we're in a project
+                let packageJsonPath = null;
+                let searchDir = cwd;
+                // Search up to 3 levels for package.json
+                for (let i = 0; i < 3; i++) {
+                    const testPath = (0, path_1.join)(searchDir, 'package.json');
+                    if (filesystem.exists(testPath)) {
+                        packageJsonPath = testPath;
+                        break;
+                    }
+                    const parent = (0, path_1.join)(searchDir, '..');
+                    if (parent === searchDir)
+                        break; // Reached root
+                    searchDir = parent;
+                }
+                // If in a project, ask where to install
+                if (packageJsonPath && !skipInteractive) {
+                    info('');
+                    info(`Detected project at: ${searchDir}`);
+                    const installToProject = yield prompt.confirm('Install commands to this project only? (No = install globally for all projects)', true);
+                    scope = installToProject ? 'project' : 'global';
+                    if (scope === 'project') {
+                        commandsDir = (0, path_1.join)(searchDir, '.claude', 'commands');
+                    }
+                }
+                else if (packageJsonPath && skipInteractive) {
+                    // In non-interactive mode with project detected, default to global
+                    scope = 'global';
+                }
+            }
+            // Create commands directory if it doesn't exist
+            if (!filesystem.exists(commandsDir)) {
+                filesystem.dir(commandsDir);
+            }
+            info('');
+            info('Available commands:');
+            info('');
+            // Show all available commands with descriptions
+            availableCommands.forEach(cmd => {
+                const cmdPath = (0, path_1.join)(commandsTemplateDir, cmd);
+                const desc = getCommandDescription(cmdPath, filesystem);
+                const cmdName = cmd.replace('.md', '');
+                info(`  • /${cmdName}`);
+                info(`    ${desc}`);
+                info('');
+            });
+            let commandsToInstall = [];
+            // Check if specific commands provided as parameters
+            if (parameters.first && parameters.first !== 'all') {
+                // Non-interactive mode: install specific command(s)
+                const requestedCommands = parameters.array || [parameters.first];
+                // Add .md extension if not present
+                const requestedWithExt = requestedCommands.map(c => c.endsWith('.md') ? c : `${c}.md`);
+                // Validate requested commands
+                const invalidCommands = requestedWithExt.filter(c => !availableCommands.includes(c));
+                if (invalidCommands.length > 0) {
+                    error(`Invalid command(s): ${invalidCommands.map(c => c.replace('.md', '')).join(', ')}`);
+                    info('');
+                    info('Available commands:');
+                    availableCommands.forEach(c => {
+                        const cmdName = c.replace('.md', '');
+                        info(`  • ${cmdName}`);
+                    });
+                    return;
+                }
+                commandsToInstall = requestedWithExt;
+            }
+            else if (parameters.first === 'all' || skipInteractive) {
+                // Install all commands without prompting
+                commandsToInstall = availableCommands;
+                if (skipInteractive) {
+                    info('Installing all commands (non-interactive mode)...');
+                }
+            }
+            else {
+                // Interactive mode: ask if user wants all or select individually
+                const installAll = yield prompt.confirm('Install all commands?', true);
+                if (installAll) {
+                    commandsToInstall = availableCommands;
+                }
+                else {
+                    // Ask for each command
+                    info('');
+                    info('Select which commands to install:');
+                    info('');
+                    for (const cmd of availableCommands) {
+                        const cmdName = cmd.replace('.md', '');
+                        const shouldInstall = yield prompt.confirm(`Install /${cmdName}?`, true);
+                        if (shouldInstall) {
+                            commandsToInstall.push(cmd);
+                        }
+                    }
+                    if (commandsToInstall.length === 0) {
+                        info('No commands selected. Installation cancelled.');
+                        return;
+                    }
+                }
+            }
+            const installSpinner = spin(`Installing ${commandsToInstall.length} command(s) to ${scope === 'global' ? '~/.claude/commands/' : '.claude/commands/'}...`);
+            let copiedCount = 0;
+            let skippedCount = 0;
+            let updatedCount = 0;
+            const skippedFiles = [];
+            // Install each command
+            for (const cmd of commandsToInstall) {
+                const sourcePath = (0, path_1.join)(commandsTemplateDir, cmd);
+                const targetPath = (0, path_1.join)(commandsDir, cmd);
+                const sourceContent = filesystem.read(sourcePath);
+                // Check if target file exists
+                if (filesystem.exists(targetPath)) {
+                    const targetContent = filesystem.read(targetPath);
+                    // Parse versions from both files
+                    const sourceVersion = parseVersion(sourceContent);
+                    const targetVersion = parseVersion(targetContent);
+                    // If both have versions, compare them
+                    if (sourceVersion && targetVersion) {
+                        if (isVersionNewer(sourceVersion, targetVersion)) {
+                            // Source is newer or equal, update
+                            filesystem.write(targetPath, sourceContent);
+                            updatedCount++;
+                            copiedCount++;
+                        }
+                        else {
+                            // Target is newer, skip
+                            skippedCount++;
+                            const reason = `local version ${targetVersion} is newer than ${sourceVersion}`;
+                            skippedFiles.push({ file: cmd, reason });
+                        }
+                    }
+                    else if (sourceVersion && !targetVersion) {
+                        // Source has version, target doesn't - update
+                        filesystem.write(targetPath, sourceContent);
+                        updatedCount++;
+                        copiedCount++;
+                    }
+                    else {
+                        // No version info, always update (backward compatibility)
+                        filesystem.write(targetPath, sourceContent);
+                        updatedCount++;
+                        copiedCount++;
+                    }
+                }
+                else {
+                    // Target doesn't exist, create new
+                    filesystem.write(targetPath, sourceContent);
+                    copiedCount++;
+                }
+            }
+            if (copiedCount === 0 && skippedCount === 0) {
+                installSpinner.fail();
+                error('No command files were processed.');
+                return;
+            }
+            if (copiedCount === 0 && skippedCount > 0) {
+                installSpinner.succeed('All selected commands are already up to date!');
+                info('');
+                info(`Skipped: ${skippedCount} file(s)`);
+                info(`Location: ${commandsDir}`);
+                return;
+            }
+            installSpinner.succeed(`Successfully installed ${commandsToInstall.length} command(s)!`);
+            info('');
+            if (updatedCount > 0 && skippedCount > 0) {
+                success(`Updated ${updatedCount} file(s), skipped ${skippedCount} file(s)`);
+            }
+            else if (updatedCount > 0) {
+                success(`Updated ${updatedCount} file(s)`);
+            }
+            else {
+                success(`Created ${copiedCount} file(s)`);
+            }
+            info('');
+            info('Installed commands:');
+            commandsToInstall.forEach(cmd => {
+                const cmdPath = (0, path_1.join)(commandsTemplateDir, cmd);
+                const desc = getCommandDescription(cmdPath, filesystem);
+                const cmdName = cmd.replace('.md', '');
+                info(`  • /${cmdName}`);
+                info(`    ${desc.substring(0, 80)}${desc.length > 80 ? '...' : ''}`);
+            });
+            info('');
+            info('These commands are now available in Claude Code!');
+            // Show first installed command as example
+            const firstCmd = (_a = commandsToInstall[0]) === null || _a === void 0 ? void 0 : _a.replace('.md', '');
+            info(`Use them by typing the command name with a leading slash, e.g., /${firstCmd || 'command-name'}`);
+            info('');
+            info('Examples:');
+            // Show up to 5 commands as examples (or all if less than 5)
+            const exampleCount = Math.min(commandsToInstall.length, 5);
+            for (let i = 0; i < exampleCount; i++) {
+                const cmd = commandsToInstall[i];
+                const cmdPath = (0, path_1.join)(commandsTemplateDir, cmd);
+                const desc = getCommandDescription(cmdPath, filesystem);
+                const cmdName = cmd.replace('.md', '');
+                info(`  • /${cmdName} - ${desc}`);
+            }
+            info('');
+            info(`Location: ${commandsDir}`);
+            info(`Scope: ${scope === 'global' ? 'Global (all projects)' : 'Project-specific'}`);
+            if (skippedCount > 0) {
+                info('');
+                info(`Note: ${skippedCount} file(s) were skipped because your local versions are newer:`);
+                skippedFiles.forEach(({ file, reason }) => {
+                    info(`  • ${file} (${reason})`);
+                });
+                info('');
+                info('To force update, manually delete the files and run this command again.');
+            }
+        }
+        catch (err) {
+            error(`Failed to install command(s): ${err.message}`);
+            info('');
+            info('Troubleshooting:');
+            info('  • Ensure .claude directory exists and is writable');
+            info('  • Check file permissions');
+            info('  • Try running with sudo if permission issues persist');
+            return;
+        }
+        // For tests
+        return `claude install-commands`;
+    }),
+};
+exports.default = NewCommand;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"install-commands.js","sourceRoot":"","sources":["../../../src/commands/claude/install-commands.ts"],"names":[],"mappings":"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"}