@garyr/pt-cli 0.40.1 → 0.42.0

package/dist/commands/template-utils.js

@@ -0,0 +1,565 @@
+import fs from 'fs';
+import path from 'path';
+import inquirer from 'inquirer';
+import { shouldIgnore, shouldExclude, shouldExcludeFile } from '../config.js';
+import chalk from 'chalk';
+/**
+ * Extract folder structure skeleton from a directory
+ * Only includes directories, with optional .info.md content
+ */
+export function extractStructure(dirPath, rootPath, ignorePatterns) {
+    const nodes = [];
+    try {
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dirPath, entry.name);
+            const relativePath = path.relative(rootPath, fullPath);
+            // Only include directories in the structure skeleton
+            const isDirectory = entry.isDirectory() || (entry.isSymbolicLink() && fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory());
+            if (!isDirectory)
+                continue;
+            if (shouldIgnore(entry.name, relativePath, ignorePatterns))
+                continue;
+            if (shouldExclude(dirPath, fullPath))
+                continue;
+            const children = extractStructure(fullPath, rootPath, ignorePatterns);
+            let info = '';
+            const gitkeepPath = path.join(fullPath, '.gitkeep.md');
+            const infoPath = path.join(fullPath, '.info.md');
+            if (fs.existsSync(infoPath))
+                info = fs.readFileSync(infoPath, 'utf-8').trim();
+            else if (fs.existsSync(gitkeepPath))
+                info = fs.readFileSync(gitkeepPath, 'utf-8').trim();
+            nodes.push({ name: entry.name, info, children });
+        }
+    }
+    catch (e) {
+        // Ignore directory read errors
+    }
+    return nodes;
+}
+/**
+ * Scan text files in top-level and 1st-level subdirectories for {{ variable_name }} placeholders.
+ */
+export function findVariablesInFiles(dirPath, rootPath, ignorePatterns) {
+    const variables = new Set();
+    const regex = /\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g;
+    const textExtensions = ['.md', '.txt', '.makerc', '.json', '.yaml', '.yml', '.ini', '.conf', '.config', '.sh', '.py', '.js', '.ts', '.html', '.css', '.makefile'];
+    const scan = (currentPath, depth) => {
+        if (depth > 1)
+            return; // Top level (0) and 1st level subfolders (1)
+        try {
+            const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(currentPath, entry.name);
+                const relativePath = path.relative(rootPath, fullPath);
+                if (entry.isDirectory()) {
+                    if (shouldIgnore(entry.name, relativePath, ignorePatterns))
+                        continue;
+                    if (shouldExclude(currentPath, fullPath))
+                        continue;
+                    scan(fullPath, depth + 1);
+                }
+                else if (entry.isFile()) {
+                    const ext = path.extname(entry.name).toLowerCase();
+                    const isMakefile = entry.name.toLowerCase() === 'makefile';
+                    if (textExtensions.includes(ext) || isMakefile || ext === '') {
+                        try {
+                            const content = fs.readFileSync(fullPath, 'utf-8');
+                            let match;
+                            regex.lastIndex = 0;
+                            while ((match = regex.exec(content)) !== null) {
+                                variables.add(match[1]);
+                            }
+                        }
+                        catch (e) {
+                            // Skip files that can't be read or aren't text
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) {
+            // Ignore directory read errors
+        }
+    };
+    scan(dirPath, 0);
+    return Array.from(variables);
+}
+/**
+ * Check if a file is executable (by extension or permissions)
+ */
+export function isExecutable(fullPath, fileName) {
+    if (shouldExcludeFile(fileName))
+        return false;
+    const ext = path.extname(fileName).toLowerCase();
+    if (['.sh', '.py', '.bash', '.bat', '.cmd'].includes(ext))
+        return true;
+    if (fileName.toLowerCase() === 'makefile')
+        return true;
+    try {
+        const stat = fs.statSync(fullPath);
+        return !!(stat.mode & 0o111);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Parse .info.md file for name and description
+ */
+export function parseInfoFile(infoPath) {
+    let name = '';
+    let description = '';
+    if (fs.existsSync(infoPath)) {
+        const content = fs.readFileSync(infoPath, 'utf-8');
+        const lines = content.split('\n');
+        for (const line of lines) {
+            if (line.startsWith('# ')) {
+                name = line.substring(2).trim();
+            }
+            else if (line.trim() !== '' && !description && !line.startsWith('#')) {
+                description = line.trim();
+            }
+        }
+    }
+    return { name, description };
+}
+/**
+ * Load JSON template config from .pt-template.json or template.json
+ */
+export function loadJsonTemplateConfig(dirPath) {
+    const jsonConfigPaths = [
+        path.join(dirPath, '.pt-template.json'),
+        path.join(dirPath, 'template.json')
+    ];
+    for (const jPath of jsonConfigPaths) {
+        if (fs.existsSync(jPath)) {
+            try {
+                const content = fs.readFileSync(jPath, 'utf-8');
+                return JSON.parse(content);
+            }
+            catch (e) {
+                console.warn(`Warning: Failed to parse ${path.basename(jPath)}: ${e.message}`);
+            }
+        }
+    }
+    return {};
+}
+/**
+ * Get root-level files and directories (for copy_files selection)
+ */
+export function getRootEntries(dirPath, ignorePatterns) {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true })
+        .filter(e => !shouldExclude(dirPath, path.join(dirPath, e.name), ignorePatterns))
+        .filter(e => !shouldIgnore(e.name, e.name, ignorePatterns));
+    const files = entries.filter(e => e.isFile()).map(e => e.name);
+    const dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
+    return { files, dirs };
+}
+/**
+ * Detect executable files at root level
+ */
+export function detectRootExecutables(dirPath, ignorePatterns) {
+    const { files } = getRootEntries(dirPath, ignorePatterns);
+    return files.filter(file => isExecutable(path.join(dirPath, file), file));
+}
+/**
+ * Parse post_config.sh/.bat scripts for tasks
+ */
+export function parsePostConfigScript(shPath, batPath) {
+    const tasks = [];
+    if (fs.existsSync(shPath)) {
+        const lines = fs.readFileSync(shPath, 'utf-8').split('\n');
+        let currentDesc = '';
+        for (const line of lines) {
+            if (line.startsWith('echo "Running: ')) {
+                currentDesc = line.substring(15, line.length - 1).replace(/"$/, '');
+            }
+            else if (line.trim() && !line.startsWith('#') && !line.startsWith('echo ')) {
+                tasks.push({ command: line.trim(), description: currentDesc || line.trim() });
+                currentDesc = '';
+            }
+        }
+    }
+    else if (fs.existsSync(batPath)) {
+        const lines = fs.readFileSync(batPath, 'utf-8').split('\n');
+        let currentDesc = '';
+        for (const line of lines) {
+            if (line.startsWith('echo Running: ')) {
+                currentDesc = line.substring(14).trim();
+            }
+            else if (line.trim() && !line.startsWith('::') && !line.startsWith('@echo') && !line.startsWith('echo ')) {
+                tasks.push({ command: line.trim(), description: currentDesc || line.trim() });
+                currentDesc = '';
+            }
+        }
+    }
+    return tasks;
+}
+/**
+ * Merge post_config tasks from existing, JSON file, and detected scripts
+ */
+export function mergePostConfigTasks(existingTasks, jsonTasks, detectedTasks) {
+    if (jsonTasks && Array.isArray(jsonTasks)) {
+        return [...jsonTasks];
+    }
+    return detectedTasks.length > 0 ? detectedTasks : existingTasks;
+}
+/**
+ * Merge post_copy files from existing, JSON file, and detected executables
+ */
+export function mergePostCopyFiles(existingPostCopy, jsonPostCopy, detectedExecutables) {
+    let post_copy = [...existingPostCopy];
+    if (jsonPostCopy && Array.isArray(jsonPostCopy)) {
+        for (const pc of jsonPostCopy) {
+            if (!post_copy.some(existing => existing.src === pc.src)) {
+                post_copy.push(pc);
+            }
+        }
+    }
+    const newExecutables = detectedExecutables.filter(file => !post_copy.some(existing => existing.src === file));
+    if (newExecutables.length > 0) {
+        // In interactive mode, we'd prompt to add these - for now just auto-add
+        for (const file of newExecutables) {
+            post_copy.push({ src: file, dest: file });
+        }
+    }
+    return post_copy;
+}
+/**
+ * Build copy_files array from selected files/folders and existing entries
+ */
+export function buildCopyFiles(selectedFiles, selectedFolders, existingCopyFiles) {
+    const copy_files = [...existingCopyFiles];
+    const existingSrcs = new Set(existingCopyFiles.map(e => e.src));
+    // Add new files
+    for (const f of selectedFiles) {
+        if (!existingSrcs.has(f)) {
+            copy_files.push({ src: f, dest: f, substitute_variables: true });
+        }
+    }
+    // Add new folder entries
+    for (const d of selectedFolders) {
+        if (!existingSrcs.has(d)) {
+            copy_files.push({ src: d, dest: d, substitute_variables: true });
+        }
+    }
+    return copy_files;
+}
+/**
+ * Prompt for template name with overwrite warning
+ */
+export async function promptTemplateName(targetName, existingNames, autoDetectedName, options) {
+    if (autoDetectedName && !options.json) {
+        if (options.yes) {
+            if (existingNames.includes(targetName)) {
+                console.warn(chalk.yellow(`⚠ Warning: "${targetName}" already exists. Using this name will overwrite the existing template.`));
+            }
+        }
+        else {
+            const { confirmName } = await inquirer.prompt({
+                type: 'confirm',
+                name: 'confirmName',
+                message: `Use "${targetName}" as the template name?`,
+                default: true
+            });
+            if (!confirmName) {
+                const { newName } = await inquirer.prompt({
+                    type: 'input',
+                    name: 'newName',
+                    message: 'Name this template:',
+                    default: targetName
+                });
+                targetName = newName;
+            }
+        }
+    }
+    return targetName;
+}
+/**
+ * Prompt for description
+ */
+export async function promptDescription(defaultDesc, options) {
+    if (options.yes || options.json)
+        return defaultDesc;
+    const { newDesc } = await inquirer.prompt({
+        type: 'input',
+        name: 'newDesc',
+        message: 'Purpose/Description of this template:',
+        default: defaultDesc
+    });
+    return newDesc;
+}
+/**
+ * Prompt for additional variables (new template mode)
+ */
+export async function promptAdditionalVariables(variables, options) {
+    if (options.yes || options.json)
+        return [];
+    const message = variables.length > 0
+        ? `Detected/Existing variables: ${variables.map(v => v.name).join(', ')}. Define more?`
+        : 'Define template variables (e.g., client_name, project_type)?';
+    const response = await inquirer.prompt({
+        type: 'confirm',
+        name: 'hasMoreVariables',
+        message: message,
+        default: false
+    });
+    if (!response.hasMoreVariables)
+        return [];
+    const { variableDefs } = await inquirer.prompt({
+        type: 'input',
+        name: 'variableDefs',
+        message: 'Define additional variables as comma-separated names:',
+    });
+    if (!variableDefs)
+        return [];
+    const additionalVars = variableDefs.split(',').map((v) => v.trim()).filter(Boolean);
+    return additionalVars
+        .filter(v => !variables.some(existing => existing.name === v))
+        .map(v => ({ name: v, prompt: `Enter ${v}:`, required: true }));
+}
+/**
+ * Prompt for new variables (additive mode)
+ */
+export async function promptNewVariables(newVariables, options) {
+    if (newVariables.length === 0)
+        return [];
+    console.log(chalk.cyan(`\n📊 New Variables:`));
+    console.log(chalk.green(`  + ${newVariables.length} new variable(s): ${newVariables.map(v => v.name).join(', ')}`));
+    if (options.yes || options.json)
+        return newVariables;
+    const { selectedVars } = await inquirer.prompt({
+        type: 'checkbox',
+        name: 'selectedVars',
+        message: 'Select variables to include (space to toggle):',
+        loop: false,
+        theme: {
+            icon: {
+                checked: chalk.green('[x] '),
+                unchecked: '[ ] ',
+            }
+        },
+        choices: newVariables.map(v => ({
+            name: v.name,
+            checked: true // Auto-select by default
+        }))
+    });
+    return newVariables.filter(v => selectedVars.includes(v.name));
+}
+/**
+ * Prompt for global variables
+ */
+export async function promptGlobalVariables(globalVars, options) {
+    if (globalVars.length === 0 || options.yes || options.json) {
+        return options.yes || options.json ? globalVars : [];
+    }
+    const { selectedGlobals } = await inquirer.prompt({
+        type: 'checkbox',
+        name: 'selectedGlobals',
+        message: 'Select default/global variables to include (space to toggle):',
+        loop: false,
+        theme: {
+            icon: {
+                checked: chalk.green('[x] '),
+                unchecked: '[ ] ',
+            }
+        },
+        choices: globalVars.map(v => ({ name: v.name, checked: true }))
+    });
+    return globalVars.filter(v => selectedGlobals.includes(v.name));
+}
+/**
+ * Print "no new variables" message
+ */
+export function printNoNewVariables() {
+    console.log(chalk.cyan("No new variables detected"));
+}
+/**
+ * Prompt for new folders (additive mode)
+ */
+export async function promptNewFolders(newFolders, options) {
+    if (newFolders.length === 0)
+        return [];
+    console.log(chalk.cyan(`\n📊 New Folders:`));
+    console.log(chalk.green(`  + ${newFolders.length} new folder(s): ${newFolders.map(f => f.name).join(', ')}`));
+    if (options.yes || options.json)
+        return newFolders;
+    const { selectedFolders } = await inquirer.prompt({
+        type: 'checkbox',
+        name: 'selectedFolders',
+        message: 'Select folders to include in template structure (space to toggle):',
+        loop: false,
+        theme: {
+            icon: {
+                checked: chalk.green('[x] '),
+                unchecked: '[ ] ',
+            }
+        },
+        choices: newFolders.map(f => ({
+            name: f.name,
+            checked: true // Auto-select by default
+        }))
+    });
+    return newFolders.filter(f => selectedFolders.includes(f.name));
+}
+/**
+ * Print "no new folders" message
+ */
+export function printNoNewFolders() {
+    console.log(chalk.cyan("No new folders detected"));
+}
+/**
+ * Print new files message
+ */
+export function printNewFiles(count, files) {
+    if (count > 0) {
+        console.log(chalk.cyan(`\n📊 New Files:`));
+        console.log(chalk.green(`  + ${count} new file(s): ${files.join(', ')}`));
+    }
+    else {
+        console.log(chalk.cyan("No new files detected"));
+    }
+}
+/**
+ * Prompt for new files (additive mode)
+ */
+export async function promptNewFiles(newFiles, options) {
+    if (newFiles.length === 0)
+        return [];
+    if (options.yes || options.json)
+        return newFiles;
+    const { selectedFileChoices } = await inquirer.prompt({
+        type: 'checkbox',
+        name: 'selectedFileChoices',
+        message: 'Select files to include (space to toggle):',
+        loop: false,
+        theme: {
+            icon: {
+                checked: chalk.green('[x] '),
+                unchecked: '[ ] ',
+            }
+        },
+        choices: newFiles.map(f => ({
+            name: f,
+            checked: true // Auto-select by default
+        }))
+    });
+    return newFiles.filter(f => selectedFileChoices.includes(f));
+}
+/**
+ * Prompt for root files (new template mode)
+ */
+export async function promptRootFiles(rootFiles, defaultFiles, options) {
+    if (rootFiles.length === 0)
+        return [];
+    if (options.yes || options.json) {
+        const defaults = ['.makerc', 'readme.md', 'README.md', '.gitattributes', '.gitignore', 'Makefile', 'makefile', 'package.json'];
+        return rootFiles.filter(f => defaults.some(p => f.toLowerCase() === p.toLowerCase()));
+    }
+    const filesResponse = await inquirer.prompt({
+        type: 'checkbox',
+        name: 'selectedFiles',
+        message: 'Select root files to include as boilerplate:',
+        loop: false,
+        theme: {
+            icon: {
+                checked: chalk.green('[x] '),
+                unchecked: '[ ] ',
+            }
+        },
+        choices: rootFiles.map(f => ({
+            name: f,
+            checked: ['.makerc', 'readme.md', 'README.md', '.gitattributes', '.gitignore', 'Makefile', 'makefile', 'package.json'].some(p => f.toLowerCase() === p.toLowerCase())
+        }))
+    });
+    return filesResponse.selectedFiles;
+}
+/**
+ * Prompt for structure folders (new template mode)
+ */
+export async function promptStructureFolders(rootDirs, options) {
+    if (rootDirs.length === 0)
+        return [];
+    if (options.yes || options.json)
+        return rootDirs;
+    const foldersResponse = await inquirer.prompt({
+        type: 'checkbox',
+        name: 'selectedStructure',
+        message: 'Select folders to include in the template structure (skeleton):',
+        loop: false,
+        theme: {
+            icon: {
+                checked: chalk.green('[x] '),
+                unchecked: '[ ] ',
+            }
+        },
+        choices: rootDirs.map(d => ({
+            name: d,
+            checked: true // Include all in structure by default
+        }))
+    });
+    return foldersResponse.selectedStructure;
+}
+/**
+ * Prompt for copy folders (new template mode)
+ */
+export async function promptCopyFolders(selectedStructure, defaultFolders, options) {
+    if (selectedStructure.length === 0)
+        return [];
+    if (options.yes || options.json) {
+        return selectedStructure.filter(d => ['APP', 'scripts', 'bin'].some(p => d === p));
+    }
+    const copyFoldersResponse = await inquirer.prompt({
+        type: 'checkbox',
+        name: 'selectedFolders',
+        message: 'Select folders to copy RECURSIVELY as boilerplate (with contents):',
+        loop: false,
+        theme: {
+            icon: {
+                checked: chalk.green('[x] '),
+                unchecked: '[ ] ',
+            }
+        },
+        choices: selectedStructure.map((d) => ({
+            name: d,
+            checked: ['APP', 'scripts', 'bin'].some(p => d === p)
+        }))
+    });
+    return copyFoldersResponse.selectedFolders;
+}
+/**
+ * Prompt for post-config tasks
+ */
+export async function promptPostConfigTasks(tasks, options) {
+    if (tasks.length === 0)
+        return [];
+    if (options.yes || options.json) {
+        return tasks.map(t => t.command || t.script || '');
+    }
+    const choices = [];
+    for (const t of tasks) {
+        const cmd = t.command || t.script || '(no command)';
+        const desc = t.description ? ` (${t.description})` : '';
+        choices.push({
+            name: `${cmd}${desc}`,
+            value: cmd,
+            checked: t.checked !== false
+        });
+    }
+    const response = await inquirer.prompt({
+        type: 'checkbox',
+        name: 'selected',
+        message: 'Select default post-config tasks to include in this template:',
+        loop: false,
+        theme: {
+            icon: {
+                checked: chalk.green('[x] '),
+                unchecked: '[ ] ',
+            }
+        },
+        choices
+    });
+    return response.selected || [];
+}