@garyr/pt-cli 1.1.0 → 1.3.0

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')
@@ -65,15 +65,33 @@ program
     }
 });
 program
-    .command('init [templateName] [destPath]')
-    .description('Initialize a new project from a learned template')
+    .command('init [args...]')
+    .description('Initialize a new project from one or more learned templates')
     .option('-f, --file <jsonPath>', 'Initialize directly from a JSON template file without adding it to local config')
     .option('--skip-post-config', 'Skip running post-config tasks')
     .option('--dry-run', 'Show what would be created without making changes')
     .option('-y, --yes', 'Automatically answer yes to prompts')
     .option('--vars <variables>', 'Comma-separated key=value variables (e.g. key1=val1,key2=val2)')
-    .action(async (typeName, destPath, options) => {
-    await init(typeName, destPath, options);
+    .option('--collision <mode>', 'File collision resolution strategy (overwrite, newest)', 'overwrite')
+    .option('--json', 'Output result as JSON')
+    .action(async (args, options) => {
+    try {
+        await init(args, options);
+    }
+    catch (err) {
+        if (options.json) {
+            process.stdout.write(JSON.stringify({
+                status: 'error',
+                message: err.message || String(err)
+            }) + '\n', () => {
+                process.exit(1);
+            });
+        }
+        else {
+            console.error(chalk.red(`Error: ${err.message || err}`));
+            process.exit(1);
+        }
+    }
 });
 program
     .command('config [templateName]')

package/dist/substitute.js

@@ -34,44 +34,62 @@ export function substituteVariables(content, variables, maxIterations = 10) {
 /**
  * Processes copy_files tasks from a template.
  */
-export async function processCopyFiles(templateRoot, resolvedDest, template, variables, dryRun = false) {
+export async function processCopyFiles(templateRoot, resolvedDest, template, variables, dryRun = false, collisionMode = 'overwrite', silent = false) {
     if (!template.copy_files)
         return;
     for (const copyFile of template.copy_files) {
         const srcPath = path.join(templateRoot, copyFile.src);
         const destPath = path.join(resolvedDest, sanitizePath(copyFile.dest));
         if (!fs.existsSync(srcPath)) {
-            console.warn(chalk.yellow(`Warning: ${copyFile.src} not found in template`));
+            if (!silent)
+                console.warn(chalk.yellow(`Warning: ${copyFile.src} not found in template`));
             continue;
         }
         const stat = fs.statSync(srcPath);
         if (stat.isDirectory()) {
             // Recursive directory copy
             if (dryRun) {
-                console.log(chalk.gray(`  [DRY RUN] Would recursively copy directory ${copyFile.src} → ${copyFile.dest}`));
+                if (!silent)
+                    console.log(chalk.gray(`  [DRY RUN] Would recursively copy directory ${copyFile.src} → ${copyFile.dest}`));
             }
             else {
                 const dirSubstitute = !!(copyFile.substitute_variables === true || (copyFile.substitute_variables === undefined &&
                     template.variables &&
                     template.variables.length > 0 &&
                     Object.keys(variables).length > 0));
-                copyDirRecursive(srcPath, destPath, variables, dirSubstitute, copyFile.chmod);
+                copyDirRecursive(srcPath, destPath, variables, dirSubstitute, copyFile.chmod, collisionMode, silent);
             }
-            console.log(chalk.green(`  ✓ ${copyFile.dest} (recursive)`));
+            if (!silent)
+                console.log(chalk.green(`  ✓ ${copyFile.dest} (recursive)`));
         }
         else {
+            // Check collision mode
+            if (collisionMode === 'newest' && fs.existsSync(destPath)) {
+                const destStat = fs.statSync(destPath);
+                if (destStat.mtimeMs > stat.mtimeMs) {
+                    if (dryRun && !silent) {
+                        console.log(chalk.yellow(`  [DRY RUN] [COLLISION] Destination is newer, keeping ${copyFile.dest}`));
+                    }
+                    else if (!silent) {
+                        console.log(chalk.yellow(`  [COLLISION] Destination is newer, keeping ${copyFile.dest}`));
+                    }
+                    continue;
+                }
+            }
             // Single file copy
             if (dryRun) {
-                console.log(chalk.gray(`  [DRY RUN] Would copy ${copyFile.src} → ${copyFile.dest}`));
-                const drySubstitute = !!(copyFile.substitute_variables === true || (copyFile.substitute_variables === undefined &&
-                    template.variables &&
-                    template.variables.length > 0 &&
-                    Object.keys(variables).length > 0));
-                if (drySubstitute) {
-                    console.log(chalk.gray(`  [DRY RUN] Would substitute variables in ${copyFile.dest}`));
-                }
-                if (copyFile.chmod) {
-                    console.log(chalk.gray(`  [DRY RUN] Would chmod ${copyFile.chmod} ${copyFile.dest}`));
+                if (!silent) {
+                    console.log(chalk.gray(`  [DRY RUN] Would copy ${copyFile.src} → ${copyFile.dest}`));
+                    const drySubstitute = !!(copyFile.substitute_variables === true || (copyFile.substitute_variables === undefined &&
+                        template.variables &&
+                        template.variables.length > 0 &&
+                        Object.keys(variables).length > 0));
+                    if (drySubstitute) {
+                        console.log(chalk.gray(`  [DRY RUN] Would substitute variables in ${copyFile.dest}`));
+                    }
+                    if (copyFile.chmod) {
+                        console.log(chalk.gray(`  [DRY RUN] Would chmod ${copyFile.chmod} ${copyFile.dest}`));
+                    }
                 }
                 continue;
             }
@@ -93,25 +111,33 @@ export async function processCopyFiles(templateRoot, resolvedDest, template, var
                     fs.chmodSync(destPath, parseInt(copyFile.chmod, 8));
                 }
                 catch (e) {
-                    if (process.platform !== 'win32') {
+                    if (process.platform !== 'win32' && !silent) {
                         console.error(chalk.red(`Failed to set chmod ${copyFile.chmod} on ${copyFile.dest}`));
                     }
                 }
             }
-            console.log(chalk.green(`  ✓ ${copyFile.dest}`));
+            if (!silent)
+                console.log(chalk.green(`  ✓ ${copyFile.dest}`));
         }
     }
 }
-function copyDirRecursive(src, dest, variables, substitute, chmod) {
+function copyDirRecursive(src, dest, variables, substitute, chmod, collisionMode = 'overwrite', silent = false) {
     fs.mkdirSync(dest, { recursive: true });
     const entries = fs.readdirSync(src, { withFileTypes: true });
     for (const entry of entries) {
         const srcPath = path.join(src, entry.name);
         const destPath = path.join(dest, entry.name);
         if (entry.isDirectory()) {
-            copyDirRecursive(srcPath, destPath, variables, substitute, chmod);
+            copyDirRecursive(srcPath, destPath, variables, substitute, chmod, collisionMode, silent);
         }
         else {
+            if (collisionMode === 'newest' && fs.existsSync(destPath)) {
+                const destStat = fs.statSync(destPath);
+                const srcStat = fs.statSync(srcPath);
+                if (destStat.mtimeMs > srcStat.mtimeMs) {
+                    continue;
+                }
+            }
             let content = fs.readFileSync(srcPath, 'utf-8');
             if (substitute) {
                 content = substituteVariables(content, variables);

package/doc/configuration.md

@@ -161,14 +161,16 @@ Each task supports:
 | `script`         | Path to script relative to template root                                         |
 | `cross_platform` | If `true`, use platform-safe runner                                              |
 
-**Interaction flow** during `pt init`:
+**Interaction flow** during `pt init` (single or multiple templates):
 
 1. Folder structure created
-2. If template has `post_config`:
+2. If template(s) have `post_config`:
    - Filter tasks by project type
-   - Show list: `[1/3] git init` ...
-   - Prompt: `Run post-config tasks? (y/N)`
-   - If yes: run each task, show ✓/✗ per task
+   - **Aggregate security check** — all templates' warnings shown in one prompt
+   - If warnings exist: prompt `Security warnings found in N template(s). Run post-config tasks anyway? (y/N)`
+   - Show unified task list with checkboxes (duplicates merged, template attribution shown)
+   - Prompt: `Select post-config tasks to run:`
+   - Run selected tasks, show ✓/✗ per task
 3. If no `post_config`, suggest baked-in defaults:
    - Prompt: `No post-config defined. Use suggested tasks?`
 4. If `--skip-post-config` flag: skip entirely

package/doc/usage.md

@@ -124,22 +124,39 @@ project=MyProject
 ## Initialize a project
 
 ```bash
-# Initialize from a template (auto-suggests post-config tasks)
-pt init <template_name> /path/to/new/PROJECT
+# Initialize from one or more templates (auto-suggests post-config tasks)
+pt init <template_name> [template_name2...] /path/to/new/PROJECT
 
 # Skip post-config tasks
-pt init <template_name> /path/to/new/PROJECT --skip-post-config
+pt init <template_name> [template_name2...] /path/to/new/PROJECT --skip-post-config
 
 # Dry run (preview actions without execution)
-pt init <template_name> /path/to/new/PROJECT --dry-run
+pt init <template_name> [template_name2...] /path/to/new/PROJECT --dry-run
 
 # Non-interactive mode with variables (useful for an API or AI agents)
-pt init <template_name> /path/to/new/PROJECT --yes --vars project_name=foo,author=bar
+pt init <template_name> [template_name2...] /path/to/new/PROJECT --yes --vars project_name=foo,author=bar
 
 # Initialize directly from a JSON template file (no config.yaml registration)
 pt init /path/to/new/PROJECT --file my-template.json --yes
 ```
 
+### Multi-Template Initialization
+
+When you provide multiple template names, `pt` combines them into a single project:
+
+- **Folder structures merged** — duplicate folder names are merged recursively
+- **Variables merged** — duplicate variable names use the last template's defaults
+- **Copy files merged** — files with same destination prompt for collision resolution
+- **Post-config tasks deduplicated** — identical tasks (same command + description) run once, with template attribution shown in selection
+
+```bash
+# Combine base template with addon
+pt init base-template caddy-addon /path/to/new/PROJECT
+
+# Interactive: you'll see one security prompt for all templates, then a unified task list
+# --yes: all deduplicated tasks run automatically
+```
+
 ### Direct JSON Scaffolding (`--file`)
 
 The `--file` option allows you to scaffold a project directly from a JSON template file **without** registering it in your local `~/.pt/config.yaml`. This is ideal for:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@garyr/pt-cli",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "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/skills/agency-pt-operator/SKILL.md

@@ -15,13 +15,14 @@ As an agent equipped with this skill, you have the ability to rapidly scaffold,
 
 2. **Scaffolding (`pt init`):**
    When a matching template exists, initialize it using the non-interactive flags. URL targets (GitHub, Gitea, etc.) are automatically translated to tarball downloads.
-   - **Command:** `pt init <template_name> <destination_path> --yes`
-   - If the template requires variables, pass them: `pt init <template_name> <destination_path> --yes --vars key1=value1,key2=value2`
+   - **Command:** `pt init <template_name> [template_name2...] <destination_path> --yes`
+   - Multiple templates can be combined: `pt init base-template caddy-addon /path/to/new/PROJECT --yes`
+   - If templates require variables, pass them: `pt init <template_name> [template_name2...] <destination_path> --yes --vars key1=value1,key2=value2`
    - **Direct JSON scaffolding:** To scaffold from a JSON template file without registering it in `config.yaml`:
      `pt init <destination_path> --file <json_path> --yes`
    - *Never* run `pt init` without `--yes`, as interactive prompts will block you.
-   - **Dry-run:** Preview what would be created without making changes: `pt init <template_name> <destination_path> --yes --dry-run`
-   - **Skip post-config:** Skip running post-config tasks: `pt init <template_name> <destination_path> --yes --skip-post-config`
+   - **Dry-run:** Preview what would be created without making changes: `pt init <template_name> [template_name2...] <destination_path> --yes --dry-run`
+   - **Skip post-config:** Skip running post-config tasks: `pt init <template_name> [template_name2...] <destination_path> --yes --skip-post-config`
    - Note any errors from auto-executed post-config tasks (like `npm install` failing) and correct them if necessary.
 
 3. **Capturing Knowledge (`pt learn`):**

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';
 
@@ -68,8 +66,8 @@ _pt_completions() {
       ;;
     init)
       if [[ "$cur" == -* ]]; then
-        COMPREPLY=( $(compgen -W "-f --file --skip-post-config --dry-run -y --yes --vars -h --help" -- "$cur") )
-      elif [[ $cword -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "-f --file --skip-post-config --dry-run -y --yes --vars --collision --json -h --help" -- "$cur") )
+      elif [[ $cword -ge 2 ]]; then
         local templates
         templates=$(pt completion --templates 2>/dev/null)
         COMPREPLY=( $(compgen -W "$templates" -- "$cur") )
@@ -202,9 +200,10 @@ _pt() {
             '--dry-run[Show what would be created without making changes]' \\
             '(-y --yes)'{-y,--yes}'[Automatically answer yes to prompts]' \\
             '--vars=[Comma-separated key=value variables]:variables:' \\
+            '--collision=[File collision resolution strategy]:mode:(overwrite newest)' \\
+            '--json[Output result as JSON]' \\
             '(-h --help)'{-h,--help}'[display help for command]' \\
-            '1:template:_pt_templates' \\
-            '2:destPath:_files -/'
+            '*:templates:_pt_templates'
           ;;
         config)
           _arguments \\
@@ -331,6 +330,8 @@ complete -c pt -n '__fish_pt_using_command init' -l skip-post-config -d 'Skip ru
 complete -c pt -n '__fish_pt_using_command init' -l dry-run -d 'Show what would be created without making changes'
 complete -c pt -n '__fish_pt_using_command init' -s y -l yes -d 'Automatically answer yes to prompts'
 complete -c pt -n '__fish_pt_using_command init' -l vars -d 'Comma-separated key=value variables'
+complete -c pt -n '__fish_pt_using_command init' -l collision -a 'overwrite newest' -d 'File collision resolution strategy'
+complete -c pt -n '__fish_pt_using_command init' -l json -d 'Output result as JSON'
 
 # config
 complete -c pt -n '__fish_pt_using_command config' -a '(__fish_pt_templates)' -d 'Template name'
@@ -404,12 +405,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);
-  }
-}