@garyr/pt-cli 0.40.1 → 0.42.0

package/dist/commands/learnCommand.js

@@ -1,9 +1,10 @@
 import fs from 'fs';
 import path from 'path';
 import inquirer from 'inquirer';
-import { loadConfig, saveConfig, getTemplateNames, shouldExclude, shouldIgnore, shouldExcludeFile, getDefaultPostConfig } from '../config.js';
+import { loadConfig, saveConfig, getTemplateNames, shouldExcludeFile, getDefaultPostConfig } from '../config.js';
 import chalk from 'chalk';
 import { downloadAndExtract } from '../remote.js';
+import { extractStructure, findVariablesInFiles, isExecutable, parseInfoFile, loadJsonTemplateConfig, getRootEntries, parsePostConfigScript, mergePostConfigTasks, mergePostCopyFiles, buildCopyFiles, promptTemplateName, promptDescription, promptAdditionalVariables, promptNewVariables, promptGlobalVariables, printNoNewVariables, promptNewFolders, printNoNewFolders, printNewFiles, promptNewFiles, promptRootFiles, promptStructureFolders, promptCopyFolders, promptPostConfigTasks } from './template-utils.js';
 export async function learn(sourcePath, updateTemplate = null, options = {}) {
     let resolvedPath;
     // Phase 1: Remote Check
@@ -30,51 +31,34 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
     const isUpdate = !!updateTemplate;
     const config = loadConfig();
     const existingNames = getTemplateNames(config);
-    // 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) {
+        // Find which file was loaded
+        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'));
+    // --- NAME ---
     let targetName = updateTemplate || '';
     if (isUpdate) {
+        // When updating, use the provided template name directly
+        // No auto-detection from files needed for updates
         if (!targetName || !config.templates[targetName]) {
             console.error(chalk.red(`Template "${targetName}" not found.`));
             process.exit(1);
         }
     }
     else {
-        // Track whether name came from .info.md or JSON (not user-provided)
         const nameFromSource = !options.name && (fileTemplateConfig.name || infoName);
         if (options.name) {
             targetName = options.name;
@@ -89,50 +73,24 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
             if (!options.json)
                 console.log(chalk.cyan(`Auto-detected template name from .info.md: ${targetName}`));
         }
-        else {
-            if (options.yes || options.json) {
-                targetName = path.basename(resolvedPath);
-            }
-            else {
-                const { newName } = await inquirer.prompt({
-                    type: 'input',
-                    name: 'newName',
-                    message: 'Name this template:',
-                    default: path.basename(resolvedPath)
-                });
-                targetName = newName;
-            }
+        else if (options.yes || options.json) {
+            targetName = path.basename(resolvedPath);
         }
-        // If name came from .info.md or JSON, prompt to confirm/edit
-        // This prevents accidental overwrites when creating new templates based on existing ones
-        if (nameFromSource && !options.json) {
-            if (options.yes) {
-                // In --yes mode, keep the auto-detected name but warn
-                const existingNames = getTemplateNames(config);
-                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;
-                }
-            }
+        else {
+            const { newName } = await inquirer.prompt({
+                type: 'input',
+                name: 'newName',
+                message: 'Name this template:',
+                default: path.basename(resolvedPath)
+            });
+            targetName = newName;
         }
+        // Confirm name if auto-detected
+        targetName = await promptTemplateName(targetName, existingNames, nameFromSource ? targetName : null, options);
     }
+    // --- DESCRIPTION ---
     let description = '';
+    const descFromSource = !options.desc && (fileTemplateConfig.description || infoDesc);
     if (options.desc) {
         description = options.desc;
     }
@@ -152,19 +110,11 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
                 description = currentDesc;
             }
             else {
-                const { newDesc } = await inquirer.prompt({
-                    type: 'input',
-                    name: 'newDesc',
-                    message: 'Purpose/Description of this template:',
-                    default: currentDesc
-                });
-                description = newDesc;
+                description = await promptDescription(currentDesc, options);
             }
         }
     }
     else {
-        // Track whether description came from .info.md or JSON (not user-provided)
-        const descFromSource = !options.desc && (fileTemplateConfig.description || infoDesc);
         if (fileTemplateConfig.description) {
             description = fileTemplateConfig.description;
             if (!options.json)
@@ -175,29 +125,12 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
             if (!options.json)
                 console.log(chalk.cyan(`Auto-detected template description from .info.md: ${description}`));
         }
-        else if (options.yes || options.json) {
-            description = infoDesc || '';
-        }
         else {
-            const { newDesc } = await inquirer.prompt({
-                type: 'input',
-                name: 'newDesc',
-                message: 'Purpose/Description of this template:',
-                default: targetName
-            });
-            description = newDesc;
+            description = await promptDescription(infoDesc || targetName, options);
         }
-        // If description came from .info.md or JSON, prompt to confirm/edit
-        // This prevents accidental overwrites when creating new templates based on existing ones
+        // Confirm description if auto-detected
         if (descFromSource && !options.json) {
-            if (options.yes) {
-                // In --yes mode, keep the auto-detected description but warn
-                const existingNames = getTemplateNames(config);
-                if (existingNames.includes(targetName)) {
-                    console.warn(chalk.yellow(`⚠ Warning: "${targetName}" already exists. Using this name will overwrite the existing template.`));
-                }
-            }
-            else {
+            if (!options.yes) {
                 const { confirmDesc } = await inquirer.prompt({
                     type: 'confirm',
                     name: 'confirmDesc',
@@ -205,26 +138,20 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
                     default: true
                 });
                 if (!confirmDesc) {
-                    const { newDesc } = await inquirer.prompt({
-                        type: 'input',
-                        name: 'newDesc',
-                        message: 'Purpose/Description of this template:',
-                        default: description
-                    });
-                    description = newDesc;
+                    description = await promptDescription(description, options);
                 }
             }
         }
     }
+    // --- IGNORE PATTERNS ---
     const cliIgnore = options.ignore ? options.ignore.split(',').map((s) => s.trim()).filter(Boolean) : [];
     const ignorePatterns = [...(config.ignore || []), ...cliIgnore];
-    // Detect variables from files
+    // --- VARIABLES ---
     const detectedVars = findVariablesInFiles(resolvedPath, resolvedPath, ignorePatterns);
     if (detectedVars.length > 0 && !options.json) {
         console.log(chalk.cyan(`Auto-detected ${detectedVars.length} variable(s): ${detectedVars.join(', ')}`));
     }
     let variables = [];
-    // During updates, merge existing template variables with JSON file variables
     if (isUpdate) {
         // Start with existing template variables
         if (config.templates[updateTemplate].variables) {
@@ -235,11 +162,9 @@ export async function learn(sourcePath, updateTemplate = null, 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 });
                 }
             }
@@ -254,11 +179,7 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
     // Add detected variables if not already present
     for (const varName of detectedVars) {
         if (!variables.some(v => v.name === varName)) {
-            variables.push({
-                name: varName,
-                prompt: `Enter ${varName}:`,
-                required: true
-            });
+            variables.push({ name: varName, prompt: `Enter ${varName}:`, required: true });
         }
     }
     // Include global variables as suggestions
@@ -269,137 +190,83 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
             }
         }
     }
-    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;
+    // Variable prompting
+    if (!isUpdate || options.noDiff === undefined) {
+        // New template or full mode - prompt for additional variables
+        const additionalVars = await promptAdditionalVariables(variables, options);
+        variables.push(...additionalVars);
     }
-    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
-                    });
-                }
-            }
+    else {
+        // Additive mode - only prompt for new variables
+        const existingVarNames = new Set(config.templates[updateTemplate].variables?.map(v => v.name) || []);
+        const newVars = variables.filter(v => !existingVarNames.has(v.name));
+        if (newVars.length > 0) {
+            const selectedNewVars = await promptNewVariables(newVars, options);
+            variables.push(...selectedNewVars);
+        }
+        else {
+            printNoNewVariables();
+        }
+        // Also prompt for global variables not already included
+        const globalVarsToPrompt = (config.variables || []).filter(gv => !variables.some(v => v.name === gv.name));
+        if (globalVarsToPrompt.length > 0) {
+            const selectedGlobals = await promptGlobalVariables(globalVarsToPrompt, options);
+            variables.push(...selectedGlobals);
         }
     }
-    // 1. Structure (skeleton)
-    const folders = fileTemplateConfig.folders && Array.isArray(fileTemplateConfig.folders)
+    // --- STRUCTURE ---
+    const detectedFolders = fileTemplateConfig.folders && Array.isArray(fileTemplateConfig.folders)
         ? fileTemplateConfig.folders
         : extractStructure(resolvedPath, resolvedPath, ignorePatterns);
-    // 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));
-    const rootFiles = rootEntries.filter(e => e.isFile()).map(e => e.name);
-    const rootDirs = rootEntries.filter(e => e.isDirectory()).map(e => e.name);
+    // --- CONTENT SELECTION (Root only) ---
+    const { files: rootFiles, dirs: rootDirs } = getRootEntries(resolvedPath, ignorePatterns);
     let selectedFiles = [];
     let selectedFolders = [];
     let selectedStructure = [];
-    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
-    }
-    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;
+    let folders;
+    if (isUpdate) {
+        // Additive mode for updates
+        const existingTemplate = config.templates[updateTemplate];
+        // New folders
+        const newFolders = detectedFolders.filter((f) => !existingTemplate.folders?.some((ef) => ef.name === f.name));
+        if (newFolders.length > 0) {
+            const addedFolders = await promptNewFolders(newFolders, options);
+            // Create new folders array preserving existing
+            folders = [...existingTemplate.folders, ...addedFolders];
         }
         else {
-            selectedFiles = [];
-        }
+            printNoNewFolders();
+            folders = existingTemplate.folders;
+        }
+        // New files
+        const newFiles = rootFiles.filter((f) => !existingTemplate.copy_files?.some((cf) => cf.src === f));
+        printNewFiles(newFiles.length, newFiles);
+        const addedFiles = await promptNewFiles(newFiles, options);
+        selectedFiles = [...(existingTemplate.copy_files?.filter((cf) => !rootDirs.includes(cf.src)).map((cf) => cf.src) || []), ...addedFiles];
+        // Structure
+        selectedStructure = existingTemplate.folders?.map((f) => f.name) || [];
+        // Seed selectedFolders from existing copy_files directory entries
+        selectedFolders = (existingTemplate.copy_files || [])
+            .filter((f) => rootDirs.includes(f.src))
+            .map((f) => f.src);
         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 = [];
+            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])];
         }
-        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 = [];
-        }
-    }
-    const copy_files = [];
-    if (fileTemplateConfig.copy_files && Array.isArray(fileTemplateConfig.copy_files)) {
-        copy_files.push(...fileTemplateConfig.copy_files);
     }
     else {
-        for (const f of selectedFiles) {
-            copy_files.push({ src: f, dest: f, substitute_variables: true });
-        }
-        for (const d of selectedFolders) {
-            copy_files.push({ src: d, dest: d, substitute_variables: true });
-        }
-    }
+        // New template - original behavior
+        selectedFiles = await promptRootFiles(rootFiles, undefined, options);
+        selectedStructure = await promptStructureFolders(rootDirs, options);
+        selectedFolders = await promptCopyFolders(selectedStructure, undefined, options);
+        folders = detectedFolders;
+    }
+    // --- COPY FILES ---
+    const existingCopyFiles = isUpdate ? config.templates[updateTemplate].copy_files || [] : [];
+    const copy_files = buildCopyFiles(selectedFiles, selectedFolders, existingCopyFiles);
     const templateConfig = {
         description: description,
         templateRoot: resolvedPath,
@@ -407,41 +274,12 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
         copy_files: copy_files,
         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 = '';
-                }
-            }
-        }
-    }
+    // --- POST_CONFIG ---
+    const shPath = path.join(resolvedPath, 'post_config.sh');
+    const batPath = path.join(resolvedPath, 'post_config.bat');
+    const detectedTasks = parsePostConfigScript(shPath, batPath);
+    let postConfigTasks = isUpdate ? config.templates[updateTemplate].post_config || [] : [];
+    postConfigTasks = mergePostConfigTasks(postConfigTasks, fileTemplateConfig.post_config, detectedTasks);
     if (postConfigTasks.length > 0) {
         templateConfig.post_config = postConfigTasks;
         if (!options.json && !fileTemplateConfig.post_config)
@@ -451,36 +289,7 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
     const defaultPostConfig = getDefaultPostConfig(config);
     const defaultApplicableTasks = defaultPostConfig.filter(t => !t.type || t.type === targetName);
     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 = [];
@@ -495,48 +304,20 @@ export async function learn(sourcePath, updateTemplate = null, 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);
-        }
-    }
-    if (fileTemplateConfig.post_copy && Array.isArray(fileTemplateConfig.post_copy)) {
-        templateConfig.post_copy = fileTemplateConfig.post_copy;
-        const postCopySrcs = fileTemplateConfig.post_copy.map(f => f.src);
+    // --- POST_COPY (executables) ---
+    const detectedExecutables = rootFiles
+        .filter(file => isExecutable(path.join(resolvedPath, file), file))
+        .filter(file => !shouldExcludeFile(file));
+    const existingPostCopy = isUpdate ? config.templates[updateTemplate].post_copy || [] : [];
+    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);
         templateConfig.copy_files = templateConfig.copy_files?.filter(cf => !postCopySrcs.includes(cf.src));
     }
-    else if (detectedExecutables.length > 0) {
-        if (!options.json) {
-            console.log(chalk.cyan("\nAuto-detected " + detectedExecutables.length + " executable file(s) at root:"));
-            for (const file of detectedExecutables) {
-                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) {
-            templateConfig.post_copy = detectedExecutables.map(f => ({ src: f, dest: f }));
-            templateConfig.copy_files = templateConfig.copy_files?.filter(cf => !detectedExecutables.includes(cf.src));
-        }
-    }
+    // --- OUTPUT ---
     if (options.json) {
-        const output = {
-            name: targetName,
-            ...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.
+        const output = { name: targetName, ...templateConfig };
         process.stdout.write(JSON.stringify(output, null, 2) + '\n', () => {
             process.exit(0);
         });
@@ -546,96 +327,3 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
     saveConfig(config);
     console.log(chalk.green(`\n✓ Template saved as "${targetName}"`));
 }
-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);
-}