@lenne.tech/cli 1.5.0 → 1.6.1

package/build/lib/nuxt-base-components.js

@@ -0,0 +1,249 @@
+"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.copyComposable = copyComposable;
+exports.copyFile = copyFile;
+exports.getConfig = getConfig;
+exports.getConfigForFile = getConfigForFile;
+exports.getFileInfo = getFileInfo;
+exports.installPackage = installPackage;
+exports.processConfig = processConfig;
+/**
+ * Shared utilities for blocks and components commands
+ * These functions handle downloading and installing Nuxt base components from GitHub
+ */
+const axios_1 = require("axios");
+const fs = require("fs");
+const glob = require("glob");
+const gluegun_1 = require("gluegun");
+const path = require("path");
+const GITHUB_BASE_URL = 'https://raw.githubusercontent.com/lenneTech/nuxt-base-components/main';
+const GITHUB_API_URL = 'https://api.github.com/repos/lenneTech/nuxt-base-components/contents';
+/**
+ * Copy a composable from GitHub to the local composables directory
+ */
+function copyComposable(composable_1, toolbox_1) {
+    return __awaiter(this, arguments, void 0, function* (composable, toolbox, noConfirm = false) {
+        const { print, prompt } = toolbox;
+        const apiUrl = `${GITHUB_BASE_URL}/composables/${composable}.ts`;
+        const response = yield axios_1.default.get(apiUrl);
+        if (response.status === 200) {
+            const sourceCode = response.data;
+            const cwd = process.cwd();
+            let targetDirectory;
+            if (fs.existsSync(path.resolve(cwd, 'composables'))) {
+                targetDirectory = path.resolve(cwd, 'composables');
+            }
+            else {
+                const directories = glob.sync('*/composables', { cwd });
+                if (directories.length > 0) {
+                    targetDirectory = path.join(cwd, directories[0]);
+                }
+                else {
+                    targetDirectory = cwd;
+                }
+            }
+            // Check if composable already exists
+            if (fs.existsSync(path.join(targetDirectory, `${composable}.ts`))) {
+                print.info(`The composable ${composable} already exists`);
+                return;
+            }
+            if (!noConfirm) {
+                const confirmAdd = yield prompt.confirm(`The composable ${composable} is required. Would you like to add it?`);
+                if (!confirmAdd) {
+                    return;
+                }
+            }
+            const targetPath = path.join(targetDirectory, `${composable}.ts`);
+            const spinner = print.spin(`Copy the composable ${composable} to ${targetPath}...`);
+            fs.writeFileSync(targetPath, sourceCode);
+            spinner.succeed(`The composable ${composable} was successfully copied to ${targetPath}`);
+        }
+        else {
+            print.error(`Error retrieving the file from GitHub: ${response.statusText}`);
+        }
+    });
+}
+/**
+ * Copy a file (block or component) from GitHub to local directory
+ */
+function copyFile(file_1, toolbox_1, type_1) {
+    return __awaiter(this, arguments, void 0, function* (file, toolbox, type, noConfirm = false) {
+        const { print } = toolbox;
+        const apiUrl = `${GITHUB_BASE_URL}/${type}/${file.name}`;
+        const targetDirName = type === 'blocks' ? 'pages' : 'components';
+        const config = yield getConfigForFile(file.name, toolbox, type === 'blocks' ? 'block' : 'component');
+        if (config) {
+            yield processConfig(config, toolbox, type, noConfirm);
+        }
+        const compSpinner = print.spin(`Load ${type.slice(0, -1)} ${file.name} from GitHub...`);
+        const response = yield axios_1.default.get(apiUrl);
+        compSpinner.succeed(`${type === 'blocks' ? 'Block' : 'Component'} ${file.name} successfully loaded from GitHub`);
+        if (response.status === 200) {
+            const sourceCode = response.data;
+            const cwd = process.cwd();
+            let targetDirectory;
+            if (fs.existsSync(path.resolve(cwd, targetDirName))) {
+                targetDirectory = path.resolve(cwd, targetDirName);
+            }
+            else {
+                const directories = glob.sync(`*/${targetDirName}`, { cwd });
+                if (directories.length > 0) {
+                    targetDirectory = path.join(cwd, directories[0]);
+                }
+                else {
+                    targetDirectory = cwd;
+                }
+            }
+            let targetName = file.name;
+            if (type === 'blocks') {
+                targetName = file.name
+                    .replace(/([a-z])([A-Z])/g, '$1-$2')
+                    .toLowerCase()
+                    .replace(/^block-/, '');
+            }
+            const targetPath = path.join(targetDirectory, targetName);
+            // Check if file already exists
+            if (fs.existsSync(targetPath)) {
+                print.info(`The ${type.slice(0, -1)} ${file.name} already exists`);
+                return targetPath;
+            }
+            if (!fs.existsSync(targetDirectory)) {
+                const targetDirSpinner = print.spin('Creating the target directory...');
+                fs.mkdirSync(targetDirectory, { recursive: true });
+                targetDirSpinner.succeed();
+            }
+            if (file.type === 'dir' || file.name.split('/').length > 1) {
+                const dirName = file.name.split('/')[0];
+                const dirPath = path.join(targetDirectory, dirName);
+                if (!fs.existsSync(dirPath)) {
+                    fs.mkdirSync(dirPath, { recursive: true });
+                }
+            }
+            const spinner = print.spin(`Copy the ${type.slice(0, -1)} ${targetName} to ${targetPath}...`);
+            fs.writeFileSync(targetPath, sourceCode);
+            spinner.succeed(`The ${type.slice(0, -1)} ${targetName} was successfully copied to ${targetPath}`);
+            return targetPath;
+        }
+        else {
+            throw new Error(`Error retrieving the file from GitHub: ${response.statusText}`);
+        }
+    });
+}
+/**
+ * Get the config.json from the nuxt-base-components repository
+ */
+function getConfig() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const githubApiUrl = `${GITHUB_BASE_URL}/config.json`;
+        const response = yield axios_1.default.get(githubApiUrl);
+        if (response.status === 200) {
+            return response.data;
+        }
+        else {
+            throw new Error(`Error when retrieving the configuration from GitHub: ${response.statusText}`);
+        }
+    });
+}
+/**
+ * Get configuration for a specific block or component
+ */
+function getConfigForFile(fileName, toolbox, type) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { print } = toolbox;
+        const configSpinner = print.spin(`Checking the config for ${type}...`);
+        const data = yield getConfig();
+        const name = fileName.split('.').slice(0, -1).join('.');
+        const rootName = name.split('/')[0];
+        configSpinner.succeed(`Config for ${rootName} loaded successfully`);
+        return data.config[rootName] || {};
+    });
+}
+/**
+ * Get file info from GitHub API for blocks or components
+ */
+function getFileInfo(type, subPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const githubApiUrl = `${GITHUB_API_URL}/${type}${subPath ? `/${subPath}` : ''}`;
+        const response = yield axios_1.default.get(githubApiUrl);
+        if (response.status === 200) {
+            return response.data.map((file) => ({
+                name: file.name,
+                type: file.type,
+            }));
+        }
+        else {
+            throw new Error(`Error when retrieving the file list from GitHub: ${response.statusText}`);
+        }
+    });
+}
+/**
+ * Install an npm package if not already installed
+ */
+function installPackage(packageName_1, toolbox_1) {
+    return __awaiter(this, arguments, void 0, function* (packageName, toolbox, noConfirm = false) {
+        const { print, prompt, system } = toolbox;
+        const nameWithoutVersion = packageName.split('@')[0] || packageName;
+        const packageJsonPath = path.resolve(process.cwd(), 'package.json');
+        const packageJson = gluegun_1.filesystem.read(packageJsonPath, 'json');
+        const isInstalled = (packageJson.dependencies && packageJson.dependencies[nameWithoutVersion])
+            || (packageJson.devDependencies && packageJson.devDependencies[nameWithoutVersion]);
+        if (!isInstalled) {
+            if (!noConfirm) {
+                const confirmInstall = yield prompt.confirm(`The npm package ${nameWithoutVersion} is required. Would you like to install it?`);
+                if (!confirmInstall) {
+                    return;
+                }
+            }
+            const installSpinner = print.spin(`Install npm package ${nameWithoutVersion}...`);
+            yield system.run(`npm install ${packageName} --save-exact`);
+            installSpinner.succeed(`npm package ${nameWithoutVersion} successfully installed`);
+        }
+        else {
+            print.info(`npm package ${nameWithoutVersion} is already installed`);
+        }
+    });
+}
+/**
+ * Process config dependencies (npm packages, composables, components)
+ */
+function processConfig(config_1, toolbox_1, type_1) {
+    return __awaiter(this, arguments, void 0, function* (config, toolbox, type, noConfirm = false) {
+        if (config === null || config === void 0 ? void 0 : config.npm) {
+            const npmPackages = config.npm;
+            for (const npmPackage of npmPackages) {
+                yield installPackage(npmPackage, toolbox, noConfirm);
+            }
+        }
+        if (config === null || config === void 0 ? void 0 : config.composables) {
+            const composables = config.composables;
+            for (const composable of composables) {
+                yield copyComposable(composable, toolbox, noConfirm);
+            }
+        }
+        if (config === null || config === void 0 ? void 0 : config.components) {
+            const components = config.components;
+            for (const component of components) {
+                if (component.endsWith('/*')) {
+                    const folderName = component.split('/')[0];
+                    const directoryFiles = yield getFileInfo('components', folderName);
+                    for (const file of directoryFiles) {
+                        yield copyFile({ name: `${folderName}/${file.name}`, type: 'dir' }, toolbox, 'components', noConfirm);
+                    }
+                }
+                else {
+                    yield copyFile({ name: `${component}.vue`, type: 'file' }, toolbox, 'components', noConfirm);
+                }
+            }
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nuxt-base-components.js","sourceRoot":"","sources":["../../src/lib/nuxt-base-components.ts"],"names":[],"mappings":"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"}

package/build/lib/validation.js

@@ -0,0 +1,204 @@
+"use strict";
+/**
+ * Input validation utilities for CLI commands
+ * Provides consistent validation patterns across all commands
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationRules = void 0;
+exports.sanitizeInput = sanitizeInput;
+exports.sanitizePath = sanitizePath;
+exports.toCamelCase = toCamelCase;
+exports.toKebabCase = toKebabCase;
+exports.toPascalCase = toPascalCase;
+exports.validateBranchName = validateBranchName;
+exports.validateClassName = validateClassName;
+exports.validateEmail = validateEmail;
+exports.validateFileName = validateFileName;
+exports.validateKebabCase = validateKebabCase;
+exports.validateLength = validateLength;
+exports.validateNpmPackage = validateNpmPackage;
+exports.validatePattern = validatePattern;
+exports.validatePropertyName = validatePropertyName;
+exports.validateRequired = validateRequired;
+/**
+ * Validation rules for common input types
+ */
+exports.ValidationRules = {
+    /**
+     * Valid branch name pattern (git-compatible)
+     */
+    branchName: /^(?![-./])(?!.*[-./]$)(?!.*[-./]{2})[a-zA-Z0-9._/-]+$/,
+    /**
+     * Valid module/class name (PascalCase)
+     */
+    className: /^[A-Z][a-zA-Z0-9]*$/,
+    /**
+     * Valid email address pattern
+     */
+    email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+    /**
+     * Valid file/directory name (no special chars)
+     */
+    fileName: /^[a-zA-Z0-9._-]+$/,
+    /**
+     * Valid kebab-case name
+     */
+    kebabCase: /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/,
+    /**
+     * Valid npm package name
+     */
+    npmPackage: /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/,
+    /**
+     * Valid property name (camelCase)
+     */
+    propertyName: /^[a-z][a-zA-Z0-9]*$/,
+    /**
+     * Valid semver version
+     */
+    semver: /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/,
+};
+/**
+ * Sanitize input by removing potentially dangerous characters
+ */
+function sanitizeInput(input) {
+    if (!input)
+        return '';
+    return input
+        .trim()
+        // Remove shell special characters
+        .replace(/[;&|`$(){}[\]<>\\'"]/g, '')
+        // Remove control characters
+        .replace(/[\x00-\x1F\x7F]/g, '')
+        // Collapse multiple spaces
+        .replace(/\s+/g, ' ');
+}
+/**
+ * Sanitize a file path to prevent directory traversal
+ */
+function sanitizePath(input) {
+    if (!input)
+        return '';
+    return input
+        .trim()
+        // Remove directory traversal attempts
+        .replace(/\.\./g, '')
+        // Remove double slashes
+        .replace(/\/+/g, '/')
+        // Remove leading slashes (make relative)
+        .replace(/^\/+/, '')
+        // Remove shell special characters
+        .replace(/[;&|`$(){}[\]<>\\'"]/g, '');
+}
+/**
+ * Convert string to camelCase
+ */
+function toCamelCase(input) {
+    if (!input)
+        return '';
+    const pascal = toPascalCase(input);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+/**
+ * Convert string to kebab-case
+ */
+function toKebabCase(input) {
+    if (!input)
+        return '';
+    return input
+        .trim()
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+/**
+ * Convert string to PascalCase
+ */
+function toPascalCase(input) {
+    if (!input)
+        return '';
+    return input
+        .trim()
+        .replace(/[-_\s]+(.)?/g, (_, char) => (char ? char.toUpperCase() : ''))
+        .replace(/^(.)/, (char) => char.toUpperCase());
+}
+/**
+ * Validate a branch name
+ */
+function validateBranchName(input) {
+    return validatePattern(input, exports.ValidationRules.branchName, 'Invalid branch name. Use alphanumeric characters, dots, underscores, or hyphens.');
+}
+/**
+ * Validate a module/class name (PascalCase)
+ */
+function validateClassName(input) {
+    return validatePattern(input, exports.ValidationRules.className, 'Invalid class name. Must start with uppercase letter and contain only alphanumeric characters.');
+}
+/**
+ * Validate an email address
+ */
+function validateEmail(input) {
+    return validatePattern(input, exports.ValidationRules.email, 'Invalid email address format.');
+}
+/**
+ * Validate a file/directory name
+ */
+function validateFileName(input) {
+    return validatePattern(input, exports.ValidationRules.fileName, 'Invalid file name. Use only alphanumeric characters, dots, underscores, or hyphens.');
+}
+/**
+ * Validate a kebab-case name
+ */
+function validateKebabCase(input) {
+    return validatePattern(input, exports.ValidationRules.kebabCase, 'Invalid name. Must be lowercase with hyphens (kebab-case).');
+}
+/**
+ * Validate input length
+ */
+function validateLength(input, min, max, fieldName = 'Input') {
+    if (!input || input.trim() === '') {
+        return { error: `${fieldName} is required`, valid: false };
+    }
+    const trimmed = input.trim();
+    if (trimmed.length < min) {
+        return { error: `${fieldName} must be at least ${min} characters`, valid: false };
+    }
+    if (trimmed.length > max) {
+        return { error: `${fieldName} must be at most ${max} characters`, valid: false };
+    }
+    return { valid: true, value: trimmed };
+}
+/**
+ * Validate an npm package name
+ */
+function validateNpmPackage(input) {
+    return validatePattern(input, exports.ValidationRules.npmPackage, 'Invalid npm package name.');
+}
+/**
+ * Validate input against a pattern
+ */
+function validatePattern(input, pattern, errorMessage) {
+    if (!input || input.trim() === '') {
+        return { error: 'Input is required', valid: false };
+    }
+    const trimmed = input.trim();
+    if (!pattern.test(trimmed)) {
+        return { error: errorMessage, valid: false };
+    }
+    return { valid: true, value: trimmed };
+}
+/**
+ * Validate a property name (camelCase)
+ */
+function validatePropertyName(input) {
+    return validatePattern(input, exports.ValidationRules.propertyName, 'Invalid property name. Must start with lowercase letter (camelCase).');
+}
+/**
+ * Validate required input with custom validator
+ */
+function validateRequired(value, fieldName) {
+    if (value === null || value === undefined || value === '') {
+        return { error: `${fieldName} is required`, valid: false };
+    }
+    return { valid: true, value: String(value) };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/templates/completion/bash.sh.ejs

@@ -0,0 +1,92 @@
+# lt completion for Bash shell
+# Auto-generated by lt CLI - supports arbitrary nesting depth
+
+<%
+// Helper to generate safe variable name from path
+function varName(path) {
+  return path.replace(/-/g, '_') + '_cmds';
+}
+
+// Recursively collect all nodes that have children
+function collectNodesWithChildren(nodes, result = []) {
+  for (const node of nodes) {
+    if (node.children.length > 0) {
+      result.push(node);
+      collectNodesWithChildren(node.children, result);
+    }
+  }
+  return result;
+}
+
+// Get command names from children
+function getCommandNames(children) {
+  return children.map(c => c.name).join(' ');
+}
+
+const nodesWithChildren = collectNodesWithChildren(props.commandTree);
+-%>
+_lt_completions() {
+    local cur prev words cword
+    _init_completion || return
+
+    # Root level commands
+    local root_cmds="<%- getCommandNames(props.commandTree) %>"
+
+<% for (const node of nodesWithChildren) { -%>
+    # <%- node.path %> subcommands
+    local <%- varName(node.path) %>="<%- getCommandNames(node.children) %>"
+
+<% } -%>
+    case "${cword}" in
+        1)
+            COMPREPLY=( $(compgen -W "${root_cmds}" -- "${cur}") )
+            ;;
+<% for (let depth = 2; depth <= props.maxDepth; depth++) { -%>
+        <%- depth %>)
+<%
+  // Generate nested case statements for this depth
+  function generateBashCases(nodes, currentDepth, targetDepth, wordIndex) {
+    let output = '';
+    const indent = '            ' + '    '.repeat(currentDepth - 2);
+
+    if (currentDepth === targetDepth) {
+      // We're at the target depth, provide completions
+      for (const node of nodes) {
+        if (node.children.length > 0) {
+          output += `${indent}${node.name})\n`;
+          output += `${indent}    COMPREPLY=( $(compgen -W "\${${varName(node.path)}}" -- "\${cur}") )\n`;
+          output += `${indent}    ;;\n`;
+        }
+      }
+    } else {
+      // Need to go deeper with nested case
+      for (const node of nodes) {
+        if (node.children.length > 0) {
+          const hasGrandchildren = node.children.some(c => c.children.length > 0);
+          if (hasGrandchildren || currentDepth + 1 === targetDepth) {
+            output += `${indent}${node.name})\n`;
+            output += `${indent}    case "\${words[${currentDepth}]}" in\n`;
+            output += generateBashCases(node.children, currentDepth + 1, targetDepth, wordIndex);
+            output += `${indent}    esac\n`;
+            output += `${indent}    ;;\n`;
+          }
+        }
+      }
+    }
+    return output;
+  }
+-%>
+            case "${words[1]}" in
+<%- generateBashCases(props.commandTree, 2, depth, 1) -%>
+            esac
+            ;;
+<% } -%>
+        *)
+            # Complete common flags
+            local flags="--help --version --noConfirm --dry-run"
+            COMPREPLY=( $(compgen -W "${flags}" -- "${cur}") )
+            ;;
+    esac
+}
+
+complete -F _lt_completions lt

package/build/templates/completion/fish.sh.ejs

@@ -0,0 +1,77 @@
+# lt completion for Fish shell
+# Auto-generated by lt CLI - supports arbitrary nesting depth
+
+<%
+// Recursively collect all nodes for completion generation
+function collectAllNodes(nodes, result = [], parentPath = []) {
+  for (const node of nodes) {
+    result.push({ node, parentPath: [...parentPath] });
+    if (node.children.length > 0) {
+      collectAllNodes(node.children, result, [...parentPath, node.name]);
+    }
+  }
+  return result;
+}
+
+// Escape single quotes in description for Fish
+function escapeDesc(desc) {
+  return desc.replace(/'/g, "\\'");
+}
+
+const allNodes = collectAllNodes(props.commandTree);
+const rootCommands = props.commandTree.map(n => n.name).join(' ');
+-%>
+# Helper function to check command depth
+function __lt_using_command
+    set -l cmd (commandline -opc)
+    set -l cmd_count (count $cmd)
+
+    if test $cmd_count -eq 1
+        return 0
+    end
+
+    for arg in $argv
+        if contains -- $arg $cmd
+            return 0
+        end
+    end
+    return 1
+end
+
+# Helper to check exact command path
+function __lt_at_path
+    set -l cmd (commandline -opc)
+    set -l expected_len (math (count $argv) + 1)
+
+    if test (count $cmd) -ne $expected_len
+        return 1
+    end
+
+    set -l i 2
+    for expected in $argv
+        if test "$cmd[$i]" != "$expected"
+            return 1
+        end
+        set i (math $i + 1)
+    end
+    return 0
+end
+
+# Root level commands
+set -l root_cmds <%- rootCommands %>
+
+<% for (const { node, parentPath } of allNodes) { -%>
+<% if (parentPath.length === 0) { -%>
+# <%- node.name %> command
+complete -f -c lt -n "not __fish_seen_subcommand_from $root_cmds" -a "<%- node.name %>" -d '<%- escapeDesc(node.description) %>'
+<% } else { -%>
+# <%- [...parentPath, node.name].join(' ') %> command
+complete -f -c lt -n "__lt_at_path <%- parentPath.join(' ') %>" -a "<%- node.name %>" -d '<%- escapeDesc(node.description) %>'
+<% } -%>
+
+<% } -%>
+# Common flags (available at any depth)
+complete -f -c lt -l help -d 'Show help'
+complete -f -c lt -l version -d 'Show version'
+complete -f -c lt -l noConfirm -d 'Skip confirmations'
+complete -f -c lt -l dry-run -d 'Show what would be done'