@garyr/pt-cli 1.1.1 → 1.3.1

package/dist/index.js

@@ -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.1",
+  "version": "1.3.1",
   "description": "Project Template CLI - Learn structures and initialize projects",
   "main": "dist/index.js",
   "bin": {

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

@@ -66,11 +66,30 @@ _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
+        # Try template name completion first
         local templates
         templates=$(pt completion --templates 2>/dev/null)
-        COMPREPLY=( $(compgen -W "$templates" -- "$cur") )
+        local template_matches
+        template_matches=$(compgen -W "$templates" -- "$cur")
+        
+        # If we're at a position where destination could be (cword >= 2 for first arg after init,
+        # or cword >= 3 with templates already specified),
+        # also try directory completion. This handles cases like "pt init Base SPA PARK<TAB>"
+        local dir_matches
+        if [[ $cword -ge 2 ]]; then
+          dir_matches=$(compgen -d -- "$cur")
+        fi
+        
+        # Combine matches - template matches first, then directory matches
+        COMPREPLY=()
+        if [[ -n "$template_matches" ]]; then
+          COMPREPLY=( $template_matches )
+        fi
+        if [[ -n "$dir_matches" ]]; then
+          COMPREPLY+=( $dir_matches )
+        fi
       fi
       ;;
     config)
@@ -194,15 +213,16 @@ _pt() {
             '2:sourcePath:_files -/'
           ;;
         init)
-          _arguments \\
-            '(-f --file)'{-f,--file}'[Initialize directly from a JSON template file]:file:_files' \\
-            '--skip-post-config[Skip running post-config tasks]' \\
-            '--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:' \\
-            '(-h --help)'{-h,--help}'[display help for command]' \\
-            '1:template:_pt_templates' \\
-            '2:destPath:_files -/'
+          _arguments \
+            '(-f --file)'{-f,--file}'[Initialize directly from a JSON template file]:file:_files' \
+            '--skip-post-config[Skip running post-config tasks]' \
+            '--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]' \
+            '*: :(_pt_templates _directories)'
           ;;
         config)
           _arguments \\
@@ -324,11 +344,28 @@ complete -c pt -n '__fish_pt_using_command update' -l no-diff -d 'Disable additi
 
 # init
 complete -c pt -n '__fish_pt_using_command init' -a '(__fish_pt_templates)' -d 'Template name'
+complete -c pt -n '__fish_pt_using_command init' -F -d 'Target directory' --wraps=pt --condition=__fish_pt_init_dir
 complete -c pt -n '__fish_pt_using_command init' -s f -l file -d 'Initialize directly from a JSON template file without adding it to local config'
 complete -c pt -n '__fish_pt_using_command init' -l skip-post-config -d 'Skip running post-config tasks'
 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'
+
+# Helper function for init directory completion (only when last positional arg looks like a path)
+function __fish_pt_init_dir
+    set -l cmd (commandline -opc)
+    # Count non-flag positional arguments after 'init'
+    set -l args (string match -r '(^[^ ]+ )?init( .+)?' <<< "$cmd")
+    # Simple approach: if the current token contains / or starts with ~ or ., complete as directory
+    set -l cur (commandline -ct)
+    if string match -q '*/' "$cur"; or string match -q '~*' "$cur"; or string match -q '.*' "$cur"
+        return 0
+    else
+        return 1
+    end
+end
 
 # config
 complete -c pt -n '__fish_pt_using_command config' -a '(__fish_pt_templates)' -d 'Template name'