@garyr/pt-cli 1.1.0 → 1.1.1

package/README.md

@@ -32,21 +32,27 @@ graph LR
 <!-- TOC -->
 
 - [pt - Project Template CLI](#pt---project-template-cli)
-    - [Why pt-cli?](#why-pt-cli)
-    - [Core Benefits & Uses](#core-benefits--uses)
-        - [🚀 Low-Friction Templating](#-low-friction-templating)
-        - [🧠 Reduces Cognitive Load](#-reduces-cognitive-load)
-        - [📦 Sharing is Caring](#-sharing-is-caring)
-        - [🤖 Agentic and API Friendly](#-agentic-and-api-friendly)
-    - [Features at a Glance](#features-at-a-glance)
-    - [Quick Start](#quick-start)
-        - [Installation](#installation)
-        - [Basic Commands](#basic-commands)
-        - [Shell Completions](#shell-completions)
-    - [Agent Integration](#agent-integration)
-    - [Documentation](#documentation)
-    - [Development](#development)
-    - [Where are the Templates?](#where-are-the-templates)
+  - [Why pt-cli?](#why-pt-cli)
+  - [Core Benefits \& Uses](#core-benefits--uses)
+    - [🚀 Low-Friction Templating](#-low-friction-templating)
+    - [🧠 Reduces Cognitive Load](#-reduces-cognitive-load)
+    - [📦 Sharing is Caring](#-sharing-is-caring)
+    - [🤖 Agentic and API Friendly](#-agentic-and-api-friendly)
+  - [Features at a Glance](#features-at-a-glance)
+  - [Quick Start](#quick-start)
+    - [Installation](#installation)
+    - [Basic Commands](#basic-commands)
+    - [Shell Completions](#shell-completions)
+  - [Agent Integration](#agent-integration)
+  - [Documentation](#documentation)
+  - [Development](#development)
+  - [Where are the Templates?](#where-are-the-templates)
+  - [1.0 Release \& API Stability](#10-release--api-stability)
+    - [🔒 Stability Guarantee (1.x series)](#-stability-guarantee-1x-series)
+    - [📦 Versioning Policy](#-versioning-policy)
+    - [📋 What's Locked in 1.0](#-whats-locked-in-10)
+    - [📖 Migration from 0.x to 1.0](#-migration-from-0x-to-10)
+  - [Documentation](#documentation-1)
 
 <!-- /TOC -->
 

package/dist/commands/completionCommand.js

@@ -1,6 +1,4 @@
 import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
 import YAML from 'yaml';
 import { getConfigPath } from '../config.js';
 export function getTemplatesForCompletion() {
@@ -396,13 +394,3 @@ export async function completionCommand(shellArg, options) {
         process.exit(1);
     }
 }
-// Allow direct execution via tsx src/commands/completionCommand.ts <shell>
-if (process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1])) {
-    const shell = process.argv[2];
-    if (shell === '--templates' || shell === '_templates') {
-        completionCommand(shell, { templates: true });
-    }
-    else {
-        completionCommand(shell);
-    }
-}

package/dist/commands/learnCommand.js

@@ -238,13 +238,19 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
             printNoNewFolders();
             folders = existingTemplate.folders;
         }
+        // selectedStructure should include ALL folders (existing + added) in additive mode
+        // so that the final filter doesn't drop user-selected new folders
+        selectedStructure = [
+            ...new Set([
+                ...existingTemplate.folders?.map((f) => f.name) || [],
+                ...folders.filter(f => !existingTemplate.folders?.some(ef => ef.name === f.name)).map(f => f.name),
+            ]),
+        ];
         // 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))
@@ -266,7 +272,14 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
     }
     // --- COPY FILES ---
     const existingCopyFiles = isUpdate ? config.templates[updateTemplate].copy_files || [] : [];
-    const copy_files = buildCopyFiles(selectedFiles, selectedFolders, existingCopyFiles);
+    // If JSON template config has copy_files, use those directly (for new templates)
+    let copy_files;
+    if (!isUpdate && fileTemplateConfig.copy_files && Array.isArray(fileTemplateConfig.copy_files)) {
+        copy_files = [...fileTemplateConfig.copy_files];
+    }
+    else {
+        copy_files = buildCopyFiles(selectedFiles, selectedFolders, existingCopyFiles);
+    }
     const templateConfig = {
         description: description,
         templateRoot: resolvedPath,
@@ -308,8 +321,18 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
     const detectedExecutables = rootFiles
         .filter(file => isExecutable(path.join(resolvedPath, file), file))
         .filter(file => !shouldExcludeFile(file));
+    // In additive mode (isUpdate), only add executables that were explicitly selected by the user
+    let selectedExecutables = [];
+    if (isUpdate) {
+        // In additive mode, only include executables that are in selectedFiles (user explicitly chose them)
+        selectedExecutables = detectedExecutables.filter(exec => selectedFiles.includes(exec));
+    }
+    else {
+        // In new template mode, include all detected executables (original behavior)
+        selectedExecutables = detectedExecutables;
+    }
     const existingPostCopy = isUpdate ? config.templates[updateTemplate].post_copy || [] : [];
-    const post_copy = mergePostCopyFiles(existingPostCopy, fileTemplateConfig.post_copy, detectedExecutables);
+    const post_copy = mergePostCopyFiles(existingPostCopy, fileTemplateConfig.post_copy, selectedExecutables);
     if (post_copy.length > 0) {
         templateConfig.post_copy = post_copy;
         const postCopySrcs = post_copy.map(f => f.src);
@@ -318,9 +341,7 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
     // --- OUTPUT ---
     if (options.json) {
         const output = { name: targetName, ...templateConfig };
-        process.stdout.write(JSON.stringify(output, null, 2) + '\n', () => {
-            process.exit(0);
-        });
+        process.stdout.write(JSON.stringify(output, null, 2) + '\n');
         return;
     }
     config.templates[targetName] = templateConfig;

package/dist/commands/template-utils.js

@@ -153,7 +153,9 @@ 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 files = entries.filter(e => e.isFile())
+        .map(e => e.name)
+        .filter(fileName => !shouldExcludeFile(fileName));
     const dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
     return { files, dirs };
 }
@@ -204,12 +206,21 @@ export function mergePostConfigTasks(existingTasks, jsonTasks, detectedTasks) {
     if (jsonTasks && Array.isArray(jsonTasks)) {
         return [...jsonTasks];
     }
-    return detectedTasks.length > 0 ? detectedTasks : existingTasks;
+    // Merge detected tasks with existing, avoiding duplicates
+    const merged = [...existingTasks];
+    for (const dt of detectedTasks) {
+        const exists = merged.some(et => et.command === dt.command && et.script === dt.script);
+        if (!exists) {
+            merged.push(dt);
+        }
+    }
+    return merged;
 }
 /**
  * Merge post_copy files from existing, JSON file, and detected executables
+ * Only adds executables that were explicitly selected by the user
  */
-export function mergePostCopyFiles(existingPostCopy, jsonPostCopy, detectedExecutables) {
+export function mergePostCopyFiles(existingPostCopy, jsonPostCopy, selectedExecutables) {
     let post_copy = [...existingPostCopy];
     if (jsonPostCopy && Array.isArray(jsonPostCopy)) {
         for (const pc of jsonPostCopy) {
@@ -218,10 +229,9 @@ export function mergePostCopyFiles(existingPostCopy, jsonPostCopy, detectedExecu
             }
         }
     }
-    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) {
+    // Only add executables that were explicitly selected by the user
+    for (const file of selectedExecutables) {
+        if (!post_copy.some(existing => existing.src === file)) {
             post_copy.push({ src: file, dest: file });
         }
     }

package/dist/commands/updateCommand.js

@@ -4,7 +4,7 @@ import inquirer from 'inquirer';
 import { loadConfig, saveConfig, getTemplateNames, shouldExclude, shouldIgnore, shouldExcludeFile, getDefaultPostConfig } from '../config.js';
 import chalk from 'chalk';
 import { downloadAndExtract } from '../remote.js';
-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';
+import { extractStructure, findVariablesInFiles, isExecutable, parseInfoFile, loadJsonTemplateConfig, parsePostConfigScript, mergePostConfigTasks, mergePostCopyFiles, promptNewVariables, promptGlobalVariables, printNoNewVariables, promptNewFolders, printNoNewFolders, printNewFiles, promptNewFiles, promptRootFiles, promptStructureFolders, promptCopyFolders, promptPostConfigTasks } from './template-utils.js';
 export async function update(sourcePath, templateName, options = {}) {
     const isFullMode = options.noDiff;
     let resolvedPath;
@@ -125,11 +125,13 @@ export async function update(sourcePath, templateName, options = {}) {
     if (!isFullMode) {
         // Additive mode: only present new variables for selection
         const existingVarNames = new Set(config.templates[templateName].variables?.map(v => v.name) || []);
+        // newVars are NOT added to variables yet - only existing variables + JSON variables are in variables
         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);
+            // Only add the selected new variables (not all newVars)
             variables.push(...selectedNewVars);
         }
         else {
@@ -150,24 +152,34 @@ export async function update(sourcePath, templateName, options = {}) {
         }
     }
     else {
-        // Full mode: original behavior with optional default/global variables prompt
-        const globalVarsToPrompt = [];
-        if (config.variables && Array.isArray(config.variables)) {
-            for (const v of config.variables) {
-                if (!variables.some(existing => existing.name === v.name)) {
-                    globalVarsToPrompt.push({ ...v });
+        // Full mode: replace all variables with detected ones (no additive)
+        variables = [];
+        // Add detected variables
+        for (const varName of detectedVars) {
+            variables.push({
+                name: varName,
+                prompt: `Enter ${varName}:`,
+                required: true
+            });
+        }
+        // Also include JSON variables
+        if (fileTemplateConfig.variables && Array.isArray(fileTemplateConfig.variables)) {
+            for (const v of fileTemplateConfig.variables) {
+                const existingIndex = variables.findIndex(existing => existing.name === v.name);
+                if (existingIndex !== -1) {
+                    variables[existingIndex] = { ...variables[existingIndex], ...v };
+                }
+                else {
+                    variables.push({ ...v });
                 }
             }
         }
-        if (globalVarsToPrompt.length > 0) {
-            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 = [];
+    let selectedStructure = [];
+    let selectedFiles = [];
+    let selectedFolders = [];
     if (!isFullMode) {
         // Additive mode: only add new folders
         const detectedFolders = fileTemplateConfig.folders && Array.isArray(fileTemplateConfig.folders)
@@ -185,6 +197,14 @@ export async function update(sourcePath, templateName, options = {}) {
             printNoNewFolders();
             folders = existingFolders;
         }
+        // selectedStructure should include ALL folders (existing + added) in additive mode
+        // so that the final filter doesn't drop user-selected new folders
+        selectedStructure = [
+            ...new Set([
+                ...existingFolders.map(f => f.name),
+                ...folders.filter(f => !existingFolders.some(ef => ef.name === f.name)).map(f => f.name),
+            ]),
+        ];
     }
     else {
         // Full mode: original behavior
@@ -196,11 +216,10 @@ export async function update(sourcePath, templateName, options = {}) {
     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 rootFiles = rootEntries.filter(e => e.isFile())
+        .map(e => e.name)
+        .filter(fileName => !shouldExcludeFile(fileName));
     const rootDirs = rootEntries.filter(e => e.isDirectory()).map(e => e.name);
-    let selectedFiles = [];
-    let selectedFolders = [];
-    let selectedStructure = [];
     if (!isFullMode) {
         // Additive mode for files and folders
         const existingCopyFiles = config.templates[templateName].copy_files || [];
@@ -209,8 +228,6 @@ export async function update(sourcePath, templateName, options = {}) {
         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
         selectedFolders = existingCopyFiles
             .filter(f => rootDirs.includes(f.src))
@@ -228,9 +245,9 @@ export async function update(sourcePath, templateName, options = {}) {
         }
     }
     else {
-        // Full mode: original behavior
+        // Full mode: original behavior - pick up all files like a fresh learn
         if (options.yes || options.json) {
-            selectedFiles = rootFiles.filter(f => ['.makerc', 'readme.md', 'README.md', '.gitattributes', '.gitignore', 'Makefile', 'makefile', 'package.json'].some(p => f.toLowerCase() === p.toLowerCase()));
+            selectedFiles = rootFiles;
             selectedStructure = rootDirs;
             selectedFolders = rootDirs.filter(d => ['APP', 'scripts', 'bin'].some(p => d === p));
         }
@@ -308,8 +325,24 @@ export async function update(sourcePath, templateName, options = {}) {
     const detectedExecutables = rootFiles
         .filter(file => isExecutable(path.join(resolvedPath, file), file))
         .filter(file => !shouldExcludeFile(file));
+    // In additive mode, only add executables that were explicitly selected by the user
+    let selectedExecutables = [];
+    if (!isFullMode) {
+        // In additive mode, only include executables that are in selectedFiles (user explicitly chose them)
+        // BUT exclude files that already exist in copy_files with custom settings (chmod, substitute_variables: false)
+        const existingCopyFiles = config.templates[templateName].copy_files || [];
+        const existingCopySrcs = new Set(existingCopyFiles.map(cf => cf.src));
+        const existingCustomSettings = new Set(existingCopyFiles
+            .filter(cf => cf.chmod || cf.substitute_variables === false)
+            .map(cf => cf.src));
+        selectedExecutables = detectedExecutables.filter(exec => selectedFiles.includes(exec) && !existingCustomSettings.has(exec));
+    }
+    else {
+        // In full mode, include all detected executables (original behavior)
+        selectedExecutables = detectedExecutables;
+    }
     const existingPostCopy = config.templates[templateName].post_copy || [];
-    const post_copy = mergePostCopyFiles(existingPostCopy, fileTemplateConfig.post_copy, detectedExecutables);
+    const post_copy = mergePostCopyFiles(existingPostCopy, fileTemplateConfig.post_copy, selectedExecutables);
     if (post_copy.length > 0) {
         templateConfig.post_copy = post_copy;
         const postCopySrcs = post_copy.map(f => f.src);
@@ -320,9 +353,7 @@ export async function update(sourcePath, templateName, options = {}) {
             name: templateName,
             ...templateConfig
         };
-        process.stdout.write(JSON.stringify(output, null, 2) + '\n', () => {
-            process.exit(0);
-        });
+        process.stdout.write(JSON.stringify(output, null, 2) + '\n');
         return;
     }
     config.templates[templateName] = templateConfig;

package/dist/config.js

@@ -223,6 +223,7 @@ export const DEFAULT_EXCLUDES = [
     'dist',
     'build',
     'bin',
+    '.vscode',
     '.DS_Store',
     'Thumbs.db',
 ];
@@ -327,6 +328,8 @@ export function shouldExcludeFile(fileName) {
         'yarn.lock',
         'pnpm-lock.yaml',
         'composer.lock',
+        'post_config.sh',
+        'post_config.bat',
     ];
     for (const pattern of excludePatterns) {
         if (pattern.startsWith('*')) {

package/dist/index.js

@@ -18,7 +18,7 @@ const program = new Command();
 program
     .name('pt')
     .description('Project Template CLI - Learn project structures and initialize new ones')
-    .version(pkg.version, '-v', 'output the version number');
+    .version(pkg.version, '-v, --version', 'output the version number');
 program
     .command('learn [path]')
     .description('Learn a project structure from an existing directory')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@garyr/pt-cli",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Project Template CLI - Learn structures and initialize projects",
   "main": "dist/index.js",
   "bin": {
@@ -13,9 +13,9 @@
     "dev": "tsx src/index.ts",
     "test": "node --import tsx --test tests/**/*.test.ts",
     "test:sequential": "node --import tsx --test tests/config.test.ts && node --import tsx --test tests/init.test.ts && node --import tsx --test tests/learn.test.ts && node --import tsx --test tests/substitute.test.ts && node --import tsx --test tests/config-utils.test.ts",
-    "completion:bash": "tsx src/commands/completionCommand.ts bash",
-    "completion:zsh": "tsx src/commands/completionCommand.ts zsh",
-    "completion:fish": "tsx src/commands/completionCommand.ts fish",
+    "completion:bash": "tsx src/index.ts completion bash",
+    "completion:zsh": "tsx src/index.ts completion zsh",
+    "completion:fish": "tsx src/index.ts completion fish",
     "prepublishOnly": "npm run build",
     "build:linux": "bun build ./src/index.ts --compile --minify --target=bun-linux-x64   --outfile ../BUILD/pt-cli/pt-linux",
     "build:macos": "bun build ./src/index.ts --compile --minify --target=bun-darwin-x64  --outfile ../BUILD/pt-cli/pt-macos",

package/src/commands/completionCommand.ts

@@ -1,6 +1,4 @@
 import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
 import YAML from 'yaml';
 import { getConfigPath } from '../config.js';
 
@@ -404,12 +402,3 @@ export async function completionCommand(shellArg?: string, options?: { templates
   }
 }
 
-// Allow direct execution via tsx src/commands/completionCommand.ts <shell>
-if (process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1])) {
-  const shell = process.argv[2];
-  if (shell === '--templates' || shell === '_templates') {
-    completionCommand(shell, { templates: true });
-  } else {
-    completionCommand(shell);
-  }
-}

package/src/commands/learnCommand.ts

@@ -281,14 +281,21 @@ export async function learn(sourcePath: string, updateTemplate: string | null =
       folders = existingTemplate.folders;
     }
 
+    // selectedStructure should include ALL folders (existing + added) in additive mode
+    // so that the final filter doesn't drop user-selected new folders
+    selectedStructure = [
+      ...new Set([
+        ...existingTemplate.folders?.map((f: FolderNode) => f.name) || [],
+        ...folders.filter(f => !existingTemplate.folders?.some(ef => ef.name === f.name)).map(f => f.name),
+      ]),
+    ];
+
     // New files
     const newFiles = rootFiles.filter((f: string) => !existingTemplate.copy_files?.some((cf: CopyFileEntry) => cf.src === f));
     printNewFiles(newFiles.length, newFiles);
     const addedFiles = await promptNewFiles(newFiles, options);
     selectedFiles = [...(existingTemplate.copy_files?.filter((cf: CopyFileEntry) => !rootDirs.includes(cf.src)).map((cf: CopyFileEntry) => cf.src) || []), ...addedFiles];
 
-    // Structure
-    selectedStructure = existingTemplate.folders?.map((f: FolderNode) => f.name) || [];
     // Seed selectedFolders from existing copy_files directory entries
     selectedFolders = (existingTemplate.copy_files || [])
       .filter((f: CopyFileEntry) => rootDirs.includes(f.src))
@@ -311,7 +318,14 @@ export async function learn(sourcePath: string, updateTemplate: string | null =
 
   // --- COPY FILES ---
   const existingCopyFiles = isUpdate ? config.templates[updateTemplate].copy_files || [] : [];
-  const copy_files = buildCopyFiles(selectedFiles, selectedFolders, existingCopyFiles);
+  
+  // If JSON template config has copy_files, use those directly (for new templates)
+  let copy_files: CopyFileEntry[];
+  if (!isUpdate && fileTemplateConfig.copy_files && Array.isArray(fileTemplateConfig.copy_files)) {
+    copy_files = [...fileTemplateConfig.copy_files];
+  } else {
+    copy_files = buildCopyFiles(selectedFiles, selectedFolders, existingCopyFiles);
+  }
 
   const templateConfig: TemplateConfig = {
     description: description,
@@ -360,8 +374,18 @@ export async function learn(sourcePath: string, updateTemplate: string | null =
     .filter(file => isExecutable(path.join(resolvedPath, file), file))
     .filter(file => !shouldExcludeFile(file));
 
+  // In additive mode (isUpdate), only add executables that were explicitly selected by the user
+  let selectedExecutables: string[] = [];
+  if (isUpdate) {
+    // In additive mode, only include executables that are in selectedFiles (user explicitly chose them)
+    selectedExecutables = detectedExecutables.filter(exec => selectedFiles.includes(exec));
+  } else {
+    // In new template mode, include all detected executables (original behavior)
+    selectedExecutables = detectedExecutables;
+  }
+
   const existingPostCopy = isUpdate ? config.templates[updateTemplate].post_copy || [] : [];
-  const post_copy = mergePostCopyFiles(existingPostCopy, fileTemplateConfig.post_copy, detectedExecutables);
+  const post_copy = mergePostCopyFiles(existingPostCopy, fileTemplateConfig.post_copy, selectedExecutables);
 
   if (post_copy.length > 0) {
     templateConfig.post_copy = post_copy;
@@ -372,9 +396,7 @@ export async function learn(sourcePath: string, updateTemplate: string | null =
   // --- OUTPUT ---
   if (options.json) {
     const output = { name: targetName, ...templateConfig };
-    process.stdout.write(JSON.stringify(output, null, 2) + '\n', () => {
-      process.exit(0);
-    });
+    process.stdout.write(JSON.stringify(output, null, 2) + '\n');
     return;
   }
 

package/src/commands/template-utils.ts

@@ -151,7 +151,9 @@ export function getRootEntries(dirPath: string, ignorePatterns?: string[]): { fi
     .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 files = entries.filter(e => e.isFile())
+    .map(e => e.name)
+    .filter(fileName => !shouldExcludeFile(fileName));
   const dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
   return { files, dirs };
 }
@@ -207,16 +209,25 @@ export function mergePostConfigTasks(
   if (jsonTasks && Array.isArray(jsonTasks)) {
     return [...jsonTasks];
   }
-  return detectedTasks.length > 0 ? detectedTasks : existingTasks;
+  // Merge detected tasks with existing, avoiding duplicates
+  const merged = [...existingTasks];
+  for (const dt of detectedTasks) {
+    const exists = merged.some(et => et.command === dt.command && et.script === dt.script);
+    if (!exists) {
+      merged.push(dt);
+    }
+  }
+  return merged;
 }
 
 /**
  * Merge post_copy files from existing, JSON file, and detected executables
+ * Only adds executables that were explicitly selected by the user
  */
 export function mergePostCopyFiles(
   existingPostCopy: PostCopyFile[],
   jsonPostCopy: PostCopyFile[] | undefined,
-  detectedExecutables: string[]
+  selectedExecutables: string[]
 ): PostCopyFile[] {
   let post_copy = [...existingPostCopy];
 
@@ -228,11 +239,9 @@ export function mergePostCopyFiles(
     }
   }
 
-  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) {
+  // Only add executables that were explicitly selected by the user
+  for (const file of selectedExecutables) {
+    if (!post_copy.some(existing => existing.src === file)) {
       post_copy.push({ src: file, dest: file });
     }
   }

package/src/commands/updateCommand.ts

@@ -170,6 +170,7 @@ export async function update(sourcePath: string, templateName: string, options:
   if (!isFullMode) {
     // Additive mode: only present new variables for selection
     const existingVarNames = new Set(config.templates[templateName].variables?.map(v => v.name) || []);
+    // newVars are NOT added to variables yet - only existing variables + JSON variables are in variables
     const newVars = variables.filter(v => !existingVarNames.has(v.name));
     
     if (newVars.length > 0) {
@@ -177,6 +178,7 @@ export async function update(sourcePath: string, templateName: string, options:
       console.log(chalk.green(`  + ${newVars.length} new variable(s): ${newVars.map(v => v.name).join(', ')}`));
       
       const selectedNewVars = await promptNewVariables(newVars, options);
+      // Only add the selected new variables (not all newVars)
       variables.push(...selectedNewVars);
     } else {
       printNoNewVariables();
@@ -197,106 +199,119 @@ export async function update(sourcePath: string, templateName: string, options:
       variables.push(...selectedGlobals);
     }
   } else {
-    // Full mode: original behavior with optional default/global variables prompt
-    const globalVarsToPrompt: TemplateVariable[] = [];
-    if (config.variables && Array.isArray(config.variables)) {
-      for (const v of config.variables) {
-        if (!variables.some(existing => existing.name === v.name)) {
-          globalVarsToPrompt.push({ ...v });
+    // Full mode: replace all variables with detected ones (no additive)
+    variables = [];
+    // Add detected variables
+    for (const varName of detectedVars) {
+      variables.push({
+        name: varName,
+        prompt: `Enter ${varName}:`,
+        required: true
+      });
+    }
+    // Also include JSON variables
+    if (fileTemplateConfig.variables && Array.isArray(fileTemplateConfig.variables)) {
+      for (const v of fileTemplateConfig.variables) {
+        const existingIndex = variables.findIndex(existing => existing.name === v.name);
+        if (existingIndex !== -1) {
+          variables[existingIndex] = { ...variables[existingIndex], ...v };
+        } else {
+          variables.push({ ...v });
         }
       }
     }
-
-    if (globalVarsToPrompt.length > 0) {
-      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: FolderNode[] = [];
-  if (!isFullMode) {
-    // Additive mode: only add new folders
-    const detectedFolders = fileTemplateConfig.folders && Array.isArray(fileTemplateConfig.folders)
-      ? fileTemplateConfig.folders
-      : extractStructure(resolvedPath, resolvedPath, ignorePatterns);
+    let folders: FolderNode[] = [];
+    let selectedStructure: string[] = [];
+    let selectedFiles: string[] = [];
+    let selectedFolders: string[] = [];
+  
+    if (!isFullMode) {
+      // Additive mode: only add new folders
+      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(`  + ${newFolders.length} new folder(s): ${newFolders.map(f => f.name).join(', ')}`));
-      
-      const addedFolders = await promptNewFolders(newFolders, options);
-      folders = [...existingFolders, ...addedFolders];
-    } else {
-      printNoNewFolders();
-      folders = existingFolders;
-    }
-  } else {
-    // Full mode: original behavior
-    folders = 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));
 
-  // 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));
+      if (newFolders.length > 0) {
+        console.log(chalk.cyan(`\n📊 New Folders:`));
+        console.log(chalk.green(`  + ${newFolders.length} new folder(s): ${newFolders.map(f => f.name).join(', ')}`));
 
-  const rootFiles = rootEntries.filter(e => e.isFile()).map(e => e.name);
-  const rootDirs = rootEntries.filter(e => e.isDirectory()).map(e => e.name);
+        const addedFolders = await promptNewFolders(newFolders, options);
+        folders = [...existingFolders, ...addedFolders];
+      } else {
+        printNoNewFolders();
+        folders = existingFolders;
+      }
 
-  let selectedFiles: string[] = [];
-  let selectedFolders: string[] = [];
-  let selectedStructure: string[] = [];
+      // selectedStructure should include ALL folders (existing + added) in additive mode
+      // so that the final filter doesn't drop user-selected new folders
+      selectedStructure = [
+        ...new Set([
+          ...existingFolders.map(f => f.name),
+          ...folders.filter(f => !existingFolders.some(ef => ef.name === f.name)).map(f => f.name),
+        ]),
+      ];
+    } else {
+        // Full mode: original behavior
+        folders = fileTemplateConfig.folders && Array.isArray(fileTemplateConfig.folders)
+          ? fileTemplateConfig.folders
+          : extractStructure(resolvedPath, resolvedPath, ignorePatterns);
+      }
 
-  if (!isFullMode) {
-    // Additive mode for files and folders
-    const existingCopyFiles = config.templates[templateName].copy_files || [];
+      // 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)
+        .filter(fileName => !shouldExcludeFile(fileName));
+      const rootDirs = rootEntries.filter(e => e.isDirectory()).map(e => e.name);
+
+      if (!isFullMode) {
+        // Additive mode for files and folders
+        const existingCopyFiles = config.templates[templateName].copy_files || [];
     
-    // 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
-    selectedFolders = existingCopyFiles
-      .filter(f => rootDirs.includes(f.src))
-      .map(f => f.src);
-
-    if (rootDirs.length > 0) {
-      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));
+        // 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];
+
+        // 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 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])];
-    }
-  } else {
-    // Full mode: original behavior
-    if (options.yes || options.json) {
-      selectedFiles = rootFiles.filter(f => ['.makerc', 'readme.md', 'README.md', '.gitattributes', '.gitignore', 'Makefile', 'makefile', 'package.json'].some(p => f.toLowerCase() === p.toLowerCase()));
-      selectedStructure = rootDirs;
-      selectedFolders = rootDirs.filter(d => ['APP', 'scripts', 'bin'].some(p => d === p));
-    } else {
-      selectedFiles = await promptRootFiles(rootFiles, undefined, options);
-      selectedStructure = await promptStructureFolders(rootDirs, options);
-      selectedFolders = await promptCopyFolders(selectedStructure, undefined, options);
-    }
-  }
+          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])];
+        }
+      } else {
+          // Full mode: original behavior - pick up all files like a fresh learn
+          if (options.yes || options.json) {
+            selectedFiles = rootFiles;
+            selectedStructure = rootDirs;
+            selectedFolders = rootDirs.filter(d => ['APP', 'scripts', 'bin'].some(p => d === p));
+          } else {
+            selectedFiles = await promptRootFiles(rootFiles, undefined, options);
+            selectedStructure = await promptStructureFolders(rootDirs, options);
+            selectedFolders = await promptCopyFolders(selectedStructure, undefined, options);
+          }
+        }
 
   const copy_files: CopyFileEntry[] = [];
   if (fileTemplateConfig.copy_files && Array.isArray(fileTemplateConfig.copy_files)) {
@@ -371,8 +386,29 @@ export async function update(sourcePath: string, templateName: string, options:
     .filter(file => isExecutable(path.join(resolvedPath, file), file))
     .filter(file => !shouldExcludeFile(file));
 
+  // In additive mode, only add executables that were explicitly selected by the user
+  let selectedExecutables: string[] = [];
+  if (!isFullMode) {
+    // In additive mode, only include executables that are in selectedFiles (user explicitly chose them)
+    // BUT exclude files that already exist in copy_files with custom settings (chmod, substitute_variables: false)
+    const existingCopyFiles = config.templates[templateName].copy_files || [];
+    const existingCopySrcs = new Set(existingCopyFiles.map(cf => cf.src));
+    const existingCustomSettings = new Set(
+      existingCopyFiles
+        .filter(cf => cf.chmod || cf.substitute_variables === false)
+        .map(cf => cf.src)
+    );
+    
+    selectedExecutables = detectedExecutables.filter(exec => 
+      selectedFiles.includes(exec) && !existingCustomSettings.has(exec)
+    );
+  } else {
+    // In full mode, include all detected executables (original behavior)
+    selectedExecutables = detectedExecutables;
+  }
+
   const existingPostCopy = config.templates[templateName].post_copy || [];
-  const post_copy = mergePostCopyFiles(existingPostCopy, fileTemplateConfig.post_copy, detectedExecutables);
+  const post_copy = mergePostCopyFiles(existingPostCopy, fileTemplateConfig.post_copy, selectedExecutables);
 
   if (post_copy.length > 0) {
     templateConfig.post_copy = post_copy;
@@ -386,9 +422,7 @@ export async function update(sourcePath: string, templateName: string, options:
       ...templateConfig
     };
 
-    process.stdout.write(JSON.stringify(output, null, 2) + '\n', () => {
-      process.exit(0);
-    });
+    process.stdout.write(JSON.stringify(output, null, 2) + '\n');
     return;
   }
 

package/src/config.ts

@@ -285,6 +285,7 @@ export const DEFAULT_EXCLUDES = [
   'dist',
   'build',
   'bin',
+  '.vscode',
   '.DS_Store',
   'Thumbs.db',
 ];
@@ -397,6 +398,8 @@ export function shouldExcludeFile(fileName: string): boolean {
     'yarn.lock',
     'pnpm-lock.yaml',
     'composer.lock',
+    'post_config.sh',
+    'post_config.bat',
   ];
 
   for (const pattern of excludePatterns) {

package/src/index.ts

@@ -25,7 +25,7 @@ const program = new Command();
 program
   .name('pt')
   .description('Project Template CLI - Learn project structures and initialize new ones')
-  .version(pkg.version, '-v', 'output the version number');
+  .version(pkg.version, '-v, --version', 'output the version number');
 
 program
   .command('learn [path]')

package/tests/config-utils.test.ts

@@ -147,9 +147,9 @@ test('DEFAULT_EXCLUDES contains expected patterns', () => {
   assert.ok(DEFAULT_EXCLUDES.includes('node_modules'), 'Should include node_modules');
   assert.ok(DEFAULT_EXCLUDES.includes('dist'), 'Should include dist');
   assert.ok(DEFAULT_EXCLUDES.includes('build'), 'Should include build');
+  assert.ok(DEFAULT_EXCLUDES.includes('.vscode'), 'Should include .vscode');
   assert.ok(DEFAULT_EXCLUDES.includes('.DS_Store'), 'Should include .DS_Store');
   assert.ok(DEFAULT_EXCLUDES.includes('Thumbs.db'), 'Should include Thumbs.db');
-  assert.ok(!DEFAULT_EXCLUDES.includes('.vscode'), 'Should NOT include .vscode');
   assert.ok(!DEFAULT_EXCLUDES.includes('.gitea'), 'Should NOT include .gitea');
   assert.ok(!DEFAULT_EXCLUDES.includes('.stignore'), 'Should NOT include .stignore');
 });

package/tests/learn.test.ts

@@ -38,15 +38,16 @@ function cleanConfig() {
 
 /** Capture console.log output during an async callback. */
 async function captureStdout(fn: () => Promise<void>): Promise<string> {
-  const original = console.log;
+  const originalWrite = process.stdout.write;
   let captured = '';
-  console.log = (...args: unknown[]) => {
-    captured += args.map(a => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ') + '\n';
+  process.stdout.write = (chunk: any) => {
+    captured += chunk.toString();
+    return true;
   };
   try {
     await fn();
   } finally {
-    console.log = original;
+    process.stdout.write = originalWrite;
   }
   return captured;
 }

package/tests/update.test.ts

@@ -366,6 +366,51 @@ test('update: handles post_copy executables additively', async () => {
   }
 });
 
+test('update: does not add post_config.sh/.bat to post_copy when unchecked', async () => {
+  const srcDir = createSourceDir('.test-update-postconfig-exclude');
+  cleanup(testHome);
+  
+  try {
+    const initialConfig: PtConfig = {
+      version: '3.0',
+      templates: {
+        'update-test-pc-exclude': {
+          description: 'Test',
+          templateRoot: '/old/path',
+          folders: [],
+          copy_files: [],
+          variables: [],
+          post_copy: []
+        }
+      }
+    };
+    saveConfig(initialConfig);
+
+    // Create post_config scripts - these should be excluded by shouldExcludeFile
+    fs.writeFileSync(path.join(srcDir, 'post_config.sh'), '#!/bin/bash\necho "Running: Build"\nnpm run build\n');
+    fs.writeFileSync(path.join(srcDir, 'post_config.bat'), '@echo off\necho Running: Build\nnpm run build\n');
+    fs.chmodSync(path.join(srcDir, 'post_config.sh'), 0o755);
+    fs.chmodSync(path.join(srcDir, 'post_config.bat'), 0o755);
+
+    await update(srcDir, 'update-test-pc-exclude', { yes: true });
+
+    const config = loadConfig();
+    const tpl = config.templates['update-test-pc-exclude'];
+    
+    // post_config.sh and post_config.bat should NOT be in post_copy
+    const postCopySrcs = (tpl.post_copy || []).map(pc => pc.src);
+    assert.ok(!postCopySrcs.includes('post_config.sh'), 'post_config.sh should not be in post_copy');
+    assert.ok(!postCopySrcs.includes('post_config.bat'), 'post_config.bat should not be in post_copy');
+    
+    // They should also not be in copy_files
+    const copySrcs = (tpl.copy_files || []).map(cf => cf.src);
+    assert.ok(!copySrcs.includes('post_config.sh'), 'post_config.sh should not be in copy_files');
+    assert.ok(!copySrcs.includes('post_config.bat'), 'post_config.bat should not be in copy_files');
+  } finally {
+    cleanup(srcDir, testHome);
+  }
+});
+
 test('update: JSON mode outputs template config', async () => {
   const srcDir = createSourceDir('.test-update-json');
   cleanup(testHome);
@@ -390,21 +435,30 @@ test('update: JSON mode outputs template config', async () => {
     fs.writeFileSync(path.join(srcDir, 'template.txt'), '{{ var }}');
 
     // Capture stdout using a proper approach
-    const output: string[] = [];
-    const originalLog = console.log;
-    console.log = (...args: any[]) => {
-      output.push(args.join(' '));
+    const originalWrite = process.stdout.write;
+    let stdoutOutput = '';
+    process.stdout.write = (chunk: any) => {
+      stdoutOutput += chunk.toString();
+      return true;
     };
-    
+
     try {
       await update(srcDir, 'update-test-json', { yes: true, json: true });
     } finally {
-      console.log = originalLog;
+      process.stdout.write = originalWrite;
     }
     
-    // Find the JSON line (last line that starts with {)
-    const jsonLine = output.reverse().find(line => line.trim().startsWith('{'));
-    const parsed = JSON.parse(jsonLine!);
+    // Debug output
+    // console.error('stdoutOutput:', JSON.stringify(stdoutOutput));
+    
+    // Find the JSON (starts with { and goes to end)
+    const firstBrace = stdoutOutput.indexOf('{');
+    if (firstBrace === -1) {
+      console.error('No JSON found. Full output:', stdoutOutput);
+      assert.fail('No JSON output found');
+    }
+    const jsonString = stdoutOutput.substring(firstBrace);
+    const parsed = JSON.parse(jsonString);
     assert.strictEqual(parsed.name, 'update-test-json');
     assert.ok(parsed.folders);
     assert.ok(parsed.copy_files);