@garyr/pt-cli 0.40.1 → 0.42.0

package/dist/commands/updateCommand.js

@@ -1,64 +1,11 @@
 import fs from 'fs';
 import path from 'path';
 import inquirer from 'inquirer';
-import { loadConfig, saveConfig, shouldExclude, shouldIgnore, shouldExcludeFile, getDefaultPostConfig } from '../config.js';
+import { loadConfig, saveConfig, getTemplateNames, shouldExclude, shouldIgnore, shouldExcludeFile, getDefaultPostConfig } from '../config.js';
 import chalk from 'chalk';
 import { downloadAndExtract } from '../remote.js';
-function getNewFolders(storedStructure, targetPath, ignorePatterns) {
-    const added = [];
-    const getStructureMap = (nodes) => {
-        const map = new Map();
-        for (const node of nodes) {
-            map.set(node.name, node);
-        }
-        return map;
-    };
-    const storedMap = getStructureMap(storedStructure);
-    const targetStructure = extractStructure(targetPath, targetPath, ignorePatterns);
-    const targetMap = getStructureMap(targetStructure);
-    // Find only new folders
-    for (const [name, targetNode] of targetMap) {
-        if (!storedMap.has(name)) {
-            added.push(targetNode);
-        }
-    }
-    return { added };
-}
-function getNewFiles(storedTemplate, targetPath) {
-    const newFiles = [];
-    // Get current files in target
-    const currentFiles = fs.readdirSync(targetPath, { withFileTypes: true })
-        .filter(e => e.isFile())
-        .map(e => e.name);
-    // Get files from stored template
-    const storedFiles = storedTemplate.copy_files?.map(f => f.src) || [];
-    // Find only new files
-    for (const file of currentFiles) {
-        if (!storedFiles.includes(file)) {
-            newFiles.push(file);
-        }
-    }
-    return { newFiles };
-}
-function getNewVariables(storedVariables, targetPath) {
-    const newVariables = [];
-    // Get variables from target directory
-    const targetVars = findVariablesInFiles(targetPath, targetPath);
-    const storedVarMap = new Set(storedVariables.map(v => v.name));
-    // Find only new variables
-    for (const varName of targetVars) {
-        if (!storedVarMap.has(varName)) {
-            newVariables.push({
-                name: varName,
-                prompt: `Enter ${varName}:`,
-                required: true
-            });
-        }
-    }
-    return { newVariables };
-}
+import { extractStructure, findVariablesInFiles, isExecutable, parseInfoFile, loadJsonTemplateConfig, parsePostConfigScript, mergePostConfigTasks, mergePostCopyFiles, promptAdditionalVariables, promptNewVariables, promptGlobalVariables, printNoNewVariables, promptNewFolders, printNoNewFolders, printNewFiles, promptNewFiles, promptRootFiles, promptStructureFolders, promptCopyFolders, promptPostConfigTasks } from './template-utils.js';
 export async function update(sourcePath, templateName, options = {}) {
-    // Determine if additive mode is disabled
     const isFullMode = options.noDiff;
     let resolvedPath;
     // Phase 1: Remote Check
@@ -83,46 +30,27 @@ export async function update(sourcePath, templateName, options = {}) {
         process.exit(1);
     }
     const config = loadConfig();
+    const existingNames = getTemplateNames(config);
     if (!config.templates[templateName]) {
         console.error(chalk.red(`Template "${templateName}" not found.`));
         process.exit(1);
     }
-    // Check for template configuration JSON file (.pt-template.json or template.json)
-    let fileTemplateConfig = {};
-    const jsonConfigPaths = [
-        path.join(resolvedPath, '.pt-template.json'),
-        path.join(resolvedPath, 'template.json')
-    ];
-    for (const jPath of jsonConfigPaths) {
-        if (fs.existsSync(jPath)) {
-            try {
-                const fileContent = fs.readFileSync(jPath, 'utf-8');
-                fileTemplateConfig = JSON.parse(fileContent);
-                if (!options.json)
-                    console.log(chalk.cyan(`Auto-detected template configurations from ${path.basename(jPath)}`));
+    // Check for template configuration JSON file
+    const fileTemplateConfig = loadJsonTemplateConfig(resolvedPath);
+    if (fileTemplateConfig && !options.json) {
+        const jsonConfigPaths = [
+            path.join(resolvedPath, '.pt-template.json'),
+            path.join(resolvedPath, 'template.json')
+        ];
+        for (const jPath of jsonConfigPaths) {
+            if (fs.existsSync(jPath)) {
+                console.log(chalk.cyan(`Auto-detected template configurations from ${path.basename(jPath)}`));
                 break;
             }
-            catch (e) {
-                console.warn(chalk.yellow(`Warning: Failed to parse ${path.basename(jPath)}: ${e.message}`));
-            }
         }
     }
     // Check for .info.md
-    let infoName = '';
-    let infoDesc = '';
-    const infoPath = path.join(resolvedPath, '.info.md');
-    if (fs.existsSync(infoPath)) {
-        const infoContent = fs.readFileSync(infoPath, 'utf-8');
-        const lines = infoContent.split('\n');
-        for (const line of lines) {
-            if (line.startsWith('# ')) {
-                infoName = line.substring(2).trim();
-            }
-            else if (line.trim() !== '' && !infoDesc && !line.startsWith('#')) {
-                infoDesc = line.trim();
-            }
-        }
-    }
+    const { name: infoName, description: infoDesc } = parseInfoFile(path.join(resolvedPath, '.info.md'));
     let description = config.templates[templateName].description || '';
     let templateRoot = config.templates[templateName].templateRoot || resolvedPath;
     if (!options.yes && !options.json) {
@@ -176,11 +104,9 @@ export async function update(sourcePath, templateName, options = {}) {
         for (const v of fileTemplateConfig.variables) {
             const existingIndex = variables.findIndex(existing => existing.name === v.name);
             if (existingIndex !== -1) {
-                // Update existing variable with JSON values (but preserve other fields)
                 variables[existingIndex] = { ...variables[existingIndex], ...v };
             }
             else {
-                // Add new variable
                 variables.push({ ...v });
             }
         }
@@ -198,49 +124,29 @@ export async function update(sourcePath, templateName, options = {}) {
     // Variable handling - additive mode
     if (!isFullMode) {
         // Additive mode: only present new variables for selection
-        const variableDiff = getNewVariables(config.templates[templateName].variables || [], resolvedPath);
+        const existingVarNames = new Set(config.templates[templateName].variables?.map(v => v.name) || []);
+        const newVars = variables.filter(v => !existingVarNames.has(v.name));
+        if (newVars.length > 0) {
+            console.log(chalk.cyan(`\n📊 New Variables:`));
+            console.log(chalk.green(`  + ${newVars.length} new variable(s): ${newVars.map(v => v.name).join(', ')}`));
+            const selectedNewVars = await promptNewVariables(newVars, options);
+            variables.push(...selectedNewVars);
+        }
+        else {
+            printNoNewVariables();
+        }
         // Also include default/global variables that are not already in the template
         const globalVarsToPrompt = [];
         if (config.variables && Array.isArray(config.variables)) {
             for (const v of config.variables) {
-                if (!variables.some(existing => existing.name === v.name) &&
-                    !variableDiff.newVariables.some(existing => existing.name === v.name)) {
+                if (!variables.some(existing => existing.name === v.name)) {
                     globalVarsToPrompt.push({ ...v });
                 }
             }
         }
-        const combinedNewVars = [...variableDiff.newVariables, ...globalVarsToPrompt];
-        if (combinedNewVars.length > 0) {
-            console.log(chalk.cyan(`\n📊 New Variables:`));
-            console.log(chalk.green(`  + ${combinedNewVars.length} new variable(s): ${combinedNewVars.map(v => v.name).join(', ')}`));
-            // Show interactive checkbox for new variables
-            if (!options.yes && !options.json) {
-                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: combinedNewVars.map(v => ({
-                        name: v.name,
-                        checked: true // Auto-select by default
-                    }))
-                });
-                // Only add selected variables
-                variables.push(...combinedNewVars.filter(v => selectedVars.includes(v.name)));
-            }
-            else {
-                // In --yes or --json mode, auto-add all
-                variables.push(...combinedNewVars);
-            }
-        }
-        else {
-            console.log(chalk.cyan("No new variables detected"));
+        if (globalVarsToPrompt.length > 0) {
+            const selectedGlobals = await promptGlobalVariables(globalVarsToPrompt, options);
+            variables.push(...selectedGlobals);
         }
     }
     else {
@@ -254,96 +160,30 @@ export async function update(sourcePath, templateName, options = {}) {
             }
         }
         if (globalVarsToPrompt.length > 0) {
-            if (!options.yes && !options.json) {
-                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: globalVarsToPrompt.map(v => ({ name: v.name, checked: true }))
-                });
-                variables.push(...globalVarsToPrompt.filter(v => selectedGlobals.includes(v.name)));
-            }
-            else {
-                variables.push(...globalVarsToPrompt);
-            }
-        }
-        let hasMoreVariables = false;
-        if (!options.yes && !options.json) {
-            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
-            });
-            hasMoreVariables = response.hasMoreVariables;
-        }
-        if (hasMoreVariables) {
-            const { variableDefs } = await inquirer.prompt({
-                type: 'input',
-                name: 'variableDefs',
-                message: 'Define additional variables as comma-separated names:',
-            });
-            if (variableDefs) {
-                const additionalVars = variableDefs.split(',').map((v) => v.trim()).filter(Boolean);
-                for (const v of additionalVars) {
-                    if (!variables.some(existing => existing.name === v)) {
-                        variables.push({
-                            name: v,
-                            prompt: `Enter ${v}:`,
-                            required: true
-                        });
-                    }
-                }
-            }
+            const selectedGlobals = await promptGlobalVariables(globalVarsToPrompt, options);
+            variables.push(...selectedGlobals);
         }
+        const additionalVars = await promptAdditionalVariables(variables, options);
+        variables.push(...additionalVars);
     }
     // 1. Structure (skeleton) - Additive mode
     let folders = [];
     if (!isFullMode) {
         // Additive mode: only add new folders
-        const structureDiff = getNewFolders(config.templates[templateName].folders, resolvedPath, ignorePatterns);
-        if (structureDiff.added.length > 0) {
+        const detectedFolders = fileTemplateConfig.folders && Array.isArray(fileTemplateConfig.folders)
+            ? fileTemplateConfig.folders
+            : extractStructure(resolvedPath, resolvedPath, ignorePatterns);
+        const existingFolders = config.templates[templateName].folders || [];
+        const newFolders = detectedFolders.filter(f => !existingFolders.some(ef => ef.name === f.name));
+        if (newFolders.length > 0) {
             console.log(chalk.cyan(`\n📊 New Folders:`));
-            console.log(chalk.green(`  + ${structureDiff.added.length} new folder(s): ${structureDiff.added.map(f => f.name).join(', ')}`));
-            // Show interactive checkbox for new folders
-            if (!options.yes && !options.json) {
-                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: structureDiff.added.map(f => ({
-                        name: f.name,
-                        checked: true // Auto-select by default
-                    }))
-                });
-                // Only add selected folders
-                folders = [...config.templates[templateName].folders, ...structureDiff.added.filter(f => selectedFolders.includes(f.name))];
-            }
-            else {
-                // In --yes or --json mode, auto-add all
-                folders = [...config.templates[templateName].folders, ...structureDiff.added];
-            }
+            console.log(chalk.green(`  + ${newFolders.length} new folder(s): ${newFolders.map(f => f.name).join(', ')}`));
+            const addedFolders = await promptNewFolders(newFolders, options);
+            folders = [...existingFolders, ...addedFolders];
         }
         else {
-            console.log(chalk.cyan("No new folders detected"));
-            folders = config.templates[templateName].folders;
+            printNoNewFolders();
+            folders = existingFolders;
         }
     }
     else {
@@ -352,7 +192,7 @@ export async function update(sourcePath, templateName, options = {}) {
             ? fileTemplateConfig.folders
             : extractStructure(resolvedPath, resolvedPath, ignorePatterns);
     }
-    // 2. Content Selection (Root only) - Additive mode
+    // 2. Content Selection (Root only)
     const rootEntries = fs.readdirSync(resolvedPath, { withFileTypes: true })
         .filter(e => !shouldExclude(resolvedPath, path.join(resolvedPath, e.name), ignorePatterns))
         .filter(e => !shouldIgnore(e.name, e.name, ignorePatterns));
@@ -363,141 +203,41 @@ export async function update(sourcePath, templateName, options = {}) {
     let selectedStructure = [];
     if (!isFullMode) {
         // Additive mode for files and folders
-        // Start with existing copy_files entries as the base (preserves all settings including substitute_variables)
         const existingCopyFiles = config.templates[templateName].copy_files || [];
-        // selectedFiles here is only used to track new file names to append
-        let newSelectedFiles = [];
-        let newSelectedFolderDirs = [];
-        const fileDiff = getNewFiles(config.templates[templateName], resolvedPath);
-        if (fileDiff.newFiles.length > 0) {
-            console.log(chalk.cyan(`\n📊 New Files:`));
-            console.log(chalk.green(`  + ${fileDiff.newFiles.length} new file(s): ${fileDiff.newFiles.join(', ')}`));
-            // Show interactive checkbox for new files
-            if (!options.yes && !options.json) {
-                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: fileDiff.newFiles.map(f => ({
-                        name: f,
-                        checked: true // Auto-select by default
-                    }))
-                });
-                newSelectedFiles = fileDiff.newFiles.filter(f => selectedFileChoices.includes(f));
-            }
-            else {
-                // In --yes or --json mode, auto-add all
-                newSelectedFiles = [...fileDiff.newFiles];
-            }
-        }
-        else {
-            console.log(chalk.cyan("No new files detected"));
-        }
-        // For folders, use additive mode logic
-        // Preserve existing folder structure
+        // New files
+        const newFiles = rootFiles.filter(f => !existingCopyFiles.some(cf => cf.src === f));
+        printNewFiles(newFiles.length, newFiles);
+        const addedFiles = await promptNewFiles(newFiles, options);
+        selectedFiles = [...existingCopyFiles.filter(cf => !rootDirs.includes(cf.src)).map(cf => cf.src), ...addedFiles];
+        // Structure
         selectedStructure = config.templates[templateName].folders?.map(f => f.name) || [];
-        // Seed selectedFolders from existing copy_files directory entries (not a hardcoded list)
+        // Seed selectedFolders from existing copy_files directory entries
         selectedFolders = existingCopyFiles
             .filter(f => rootDirs.includes(f.src))
             .map(f => f.src);
         if (rootDirs.length > 0) {
-            const structureDiff = getNewFolders(config.templates[templateName].folders, resolvedPath, ignorePatterns);
-            if (structureDiff.added.length > 0) {
-                // Auto-select added folders for structure
-                selectedStructure = [...new Set([...selectedStructure, ...structureDiff.added.map(f => f.name)])];
-                // For new dirs, auto-select for recursive copy if they match the standard list
-                newSelectedFolderDirs = structureDiff.added
-                    .filter(f => ['APP', 'scripts', 'bin'].some(p => f.name === p))
-                    .map(f => f.name);
-            }
+            const detectedFolders = fileTemplateConfig.folders && Array.isArray(fileTemplateConfig.folders)
+                ? fileTemplateConfig.folders
+                : extractStructure(resolvedPath, resolvedPath, ignorePatterns);
+            const newFolders = detectedFolders.filter(f => !config.templates[templateName].folders?.some(ef => ef.name === f.name));
+            const addedDirs = newFolders
+                .filter(f => ['APP', 'scripts', 'bin'].some(p => f.name === p))
+                .map(f => f.name);
+            selectedStructure = [...new Set([...selectedStructure, ...addedDirs])];
+            selectedFolders = [...new Set([...selectedFolders, ...addedDirs])];
         }
-        // Merge: existing folder copy_files + newly selected dirs
-        selectedFolders = [...new Set([...selectedFolders, ...newSelectedFolderDirs])];
-        // Also carry forward file names for use in copy_files construction below
-        selectedFiles = [...existingCopyFiles.filter(f => !rootDirs.includes(f.src)).map(f => f.src), ...newSelectedFiles];
     }
     else {
         // Full mode: original behavior
         if (options.yes || options.json) {
-            // If --yes, auto-select the defaults
             selectedFiles = rootFiles.filter(f => ['.makerc', 'readme.md', 'README.md', '.gitattributes', '.gitignore', 'Makefile', 'makefile', 'package.json'].some(p => f.toLowerCase() === p.toLowerCase()));
-            selectedStructure = rootDirs; // Include all folders in structure
-            selectedFolders = rootDirs.filter(d => ['APP', 'scripts', 'bin'].some(p => d === p)); // Only copy specific ones recursively
+            selectedStructure = rootDirs;
+            selectedFolders = rootDirs.filter(d => ['APP', 'scripts', 'bin'].some(p => d === p));
         }
         else {
-            if (rootFiles.length > 0) {
-                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())
-                    }))
-                });
-                selectedFiles = filesResponse.selectedFiles;
-            }
-            else {
-                selectedFiles = [];
-            }
-            if (rootDirs.length > 0) {
-                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
-                    }))
-                });
-                selectedStructure = foldersResponse.selectedStructure;
-            }
-            else {
-                selectedStructure = [];
-            }
-            if (selectedStructure.length > 0) {
-                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)
-                    }))
-                });
-                selectedFolders = copyFoldersResponse.selectedFolders;
-            }
-            else {
-                selectedFolders = [];
-            }
+            selectedFiles = await promptRootFiles(rootFiles, undefined, options);
+            selectedStructure = await promptStructureFolders(rootDirs, options);
+            selectedFolders = await promptCopyFolders(selectedStructure, undefined, options);
         }
     }
     const copy_files = [];
@@ -505,27 +245,21 @@ export async function update(sourcePath, templateName, options = {}) {
         copy_files.push(...fileTemplateConfig.copy_files);
     }
     else if (!isFullMode) {
-        // Additive mode: start directly from the existing copy_files to preserve all settings,
-        // then append only brand-new entries (never rebuild from scratch).
         const existingCopyFiles = config.templates[templateName].copy_files || [];
         const existingSrcs = new Set(existingCopyFiles.map(e => e.src));
-        // Begin with all existing entries untouched
         copy_files.push(...existingCopyFiles);
-        // Append new files that were selected by the user
         for (const f of selectedFiles) {
             if (existingSrcs.has(f))
-                continue; // already present, skip
+                continue;
             copy_files.push({ src: f, dest: f, substitute_variables: true });
         }
-        // Append new directory entries that were selected
         for (const d of selectedFolders) {
             if (existingSrcs.has(d))
-                continue; // already present, skip
+                continue;
             copy_files.push({ src: d, dest: d, substitute_variables: true });
         }
     }
     else {
-        // Full mode: build from scratch using the selected files/folders
         for (const f of selectedFiles) {
             copy_files.push({ src: f, dest: f, substitute_variables: true });
         }
@@ -541,40 +275,11 @@ export async function update(sourcePath, templateName, options = {}) {
         variables: variables.length > 0 ? variables : undefined
     };
     // Check for post_config scripts
-    let postConfigTasks = [];
-    if (fileTemplateConfig.post_config && Array.isArray(fileTemplateConfig.post_config)) {
-        postConfigTasks = [...fileTemplateConfig.post_config];
-    }
-    else {
-        const shPath = path.join(resolvedPath, 'post_config.sh');
-        const batPath = path.join(resolvedPath, 'post_config.bat');
-        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 ')) {
-                    postConfigTasks.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 ')) {
-                    postConfigTasks.push({ command: line.trim(), description: currentDesc || line.trim() });
-                    currentDesc = '';
-                }
-            }
-        }
-    }
+    const shPath = path.join(resolvedPath, 'post_config.sh');
+    const batPath = path.join(resolvedPath, 'post_config.bat');
+    const detectedTasks = parsePostConfigScript(shPath, batPath);
+    let postConfigTasks = config.templates[templateName].post_config || [];
+    postConfigTasks = mergePostConfigTasks(postConfigTasks, fileTemplateConfig.post_config, detectedTasks);
     if (postConfigTasks.length > 0) {
         templateConfig.post_config = postConfigTasks;
         if (!options.json && !fileTemplateConfig.post_config)
@@ -584,36 +289,7 @@ export async function update(sourcePath, templateName, options = {}) {
     const defaultPostConfig = getDefaultPostConfig(config);
     const defaultApplicableTasks = defaultPostConfig.filter(t => !t.type || t.type === templateName);
     if (defaultApplicableTasks.length > 0) {
-        let selectedTaskNames = [];
-        if (options.yes || options.json) {
-            selectedTaskNames = defaultApplicableTasks.map(t => t.command || t.script || '');
-        }
-        else {
-            const choices = [];
-            for (const t of defaultApplicableTasks) {
-                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
-            });
-            selectedTaskNames = response.selected || [];
-        }
+        const selectedTaskNames = await promptPostConfigTasks(defaultApplicableTasks, options);
         if (selectedTaskNames.length > 0) {
             if (!templateConfig.post_config)
                 templateConfig.post_config = [];
@@ -629,46 +305,11 @@ export async function update(sourcePath, templateName, options = {}) {
         }
     }
     // 3. Detect executables at root
-    const detectedExecutables = [];
-    for (const file of rootFiles) {
-        const fullPath = path.join(resolvedPath, file);
-        if (isExecutable(fullPath, file)) {
-            detectedExecutables.push(file);
-        }
-    }
+    const detectedExecutables = rootFiles
+        .filter(file => isExecutable(path.join(resolvedPath, file), file))
+        .filter(file => !shouldExcludeFile(file));
     const existingPostCopy = config.templates[templateName].post_copy || [];
-    let post_copy = [...existingPostCopy];
-    if (fileTemplateConfig.post_copy && Array.isArray(fileTemplateConfig.post_copy)) {
-        for (const pc of fileTemplateConfig.post_copy) {
-            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) {
-        if (!options.json) {
-            console.log(chalk.cyan("\nAuto-detected " + newExecutables.length + " new executable file(s) at root:"));
-            for (const file of newExecutables) {
-                console.log(chalk.gray("  - " + file));
-            }
-        }
-        let addPostCopy = true;
-        if (!options.yes && !options.json) {
-            const response = await inquirer.prompt({
-                type: 'confirm',
-                name: 'addPostCopy',
-                message: 'Add these to post_copy (auto-chmod)?',
-                default: true
-            });
-            addPostCopy = response.addPostCopy;
-        }
-        if (addPostCopy) {
-            for (const file of newExecutables) {
-                post_copy.push({ src: file, dest: file });
-            }
-        }
-    }
+    const post_copy = mergePostCopyFiles(existingPostCopy, fileTemplateConfig.post_copy, detectedExecutables);
     if (post_copy.length > 0) {
         templateConfig.post_copy = post_copy;
         const postCopySrcs = post_copy.map(f => f.src);
@@ -679,8 +320,6 @@ export async function update(sourcePath, templateName, options = {}) {
             name: templateName,
             ...templateConfig
         };
-        // Force the application to wait until every single byte of this JSON string 
-        // safely clears the operating system's pipe buffer before letting the process die.
         process.stdout.write(JSON.stringify(output, null, 2) + '\n', () => {
             process.exit(0);
         });
@@ -690,96 +329,3 @@ export async function update(sourcePath, templateName, options = {}) {
     saveConfig(config);
     console.log(chalk.green(`\n✓ Template saved as "${templateName}"`));
 }
-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;
-    }
-}
-function extractStructure(dirPath, rootPath, ignorePatterns) {
-    let 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: info, children: children });
-        }
-    }
-    catch (e) { }
-    return nodes;
-}
-/**
- * Scan text files in top-level and 1st-level subdirectories for {{ variable_name }} placeholders.
- */
-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);
-}