@garyr/pt-cli 1.0.1 → 1.1.1

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

@@ -12,12 +12,13 @@ import { addCommand } from './commands/addCommand.js';
 import { removeCommand } from './commands/removeCommand.js';
 import { defaultPostConfigCommand } from './commands/defaultPostConfigCommand.js';
 import { securityResponseCommand } from './commands/securityResponseCommand.js';
+import { completionCommand } from './commands/completionCommand.js';
 import pkg from '../package.json' with { type: 'json' };
 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')
@@ -114,4 +115,11 @@ program
     .action(async (response) => {
     await securityResponseCommand(response);
 });
+program
+    .command('completion [shell]')
+    .description('Generate shell completion script')
+    .option('--templates', 'Internal helper to list template names for completion')
+    .action(async (shellArg, options) => {
+    await completionCommand(shellArg, options);
+});
 program.parse(process.argv);

package/doc/usage.md

@@ -305,3 +305,41 @@ To see your entire configuration (including all templates) in JSON format:
 ```bash
 pt config --json
 ```
+
+## Shell Completions
+
+`pt` can generate tab-completion scripts for Bash, Zsh, and Fish shells.
+
+### Installation
+
+#### Bash
+
+```bash
+pt completion bash > /etc/bash_completion.d/pt
+# Or user-local:
+pt completion bash > ~/.local/share/bash-completion/completions/pt
+```
+
+#### Zsh
+
+```bash
+pt completion zsh > ~/.zsh/completions/_pt
+# Add to ~/.zshrc:
+# fpath=(~/.zsh/completions $fpath)
+# autoload -U compinit && compinit
+```
+
+#### Fish
+
+```bash
+pt completion fish > ~/.config/fish/completions/pt.fish
+```
+
+### Dynamic Completion
+
+Template names auto-complete dynamically from your local `~/.pt/config.yaml` for:
+- `pt init <TAB>`
+- `pt update <TAB>`
+- `pt config <TAB>`
+- `pt remove <TAB>` (and `pt rm <TAB>`)
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@garyr/pt-cli",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Project Template CLI - Learn structures and initialize projects",
   "main": "dist/index.js",
   "bin": {
@@ -13,6 +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/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

@@ -0,0 +1,404 @@
+import fs from 'fs';
+import YAML from 'yaml';
+import { getConfigPath } from '../config.js';
+
+export function getTemplatesForCompletion(): string[] {
+  try {
+    const configPath = getConfigPath();
+    if (!fs.existsSync(configPath)) {
+      return [];
+    }
+    const content = fs.readFileSync(configPath, 'utf-8');
+    if (!content.trim()) {
+      return [];
+    }
+    const parsed = YAML.parse(content);
+    if (!parsed || !parsed.templates || typeof parsed.templates !== 'object') {
+      return [];
+    }
+    return Object.keys(parsed.templates);
+  } catch {
+    return [];
+  }
+}
+
+export function generateBashCompletion(): string {
+  return `# Bash completion for pt
+_pt_completions() {
+  local cur prev words cword
+  if declare -F _init_completion >/dev/null 2>&1; then
+    _init_completion || return
+  else
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    words=("\${COMP_WORDS[@]}")
+    cword=$COMP_CWORD
+  fi
+
+  local commands="learn update init config ignore variables default-post-config add remove rm security-response completion"
+
+  # Complete top-level command or global flags
+  if [[ $cword -eq 1 ]]; then
+    if [[ "$cur" == -* ]]; then
+      COMPREPLY=( $(compgen -W "-v --version -h --help" -- "$cur") )
+    else
+      COMPREPLY=( $(compgen -W "$commands" -- "$cur") )
+    fi
+    return 0
+  fi
+
+  local cmd="\${words[1]}"
+
+  case "$cmd" in
+    learn)
+      if [[ "$cur" == -* ]]; then
+        COMPREPLY=( $(compgen -W "--ignore -y --yes --name --desc --json --allow-untrusted -h --help" -- "$cur") )
+      fi
+      ;;
+    update)
+      if [[ "$cur" == -* ]]; then
+        COMPREPLY=( $(compgen -W "--ignore -y --yes --desc --no-diff -h --help" -- "$cur") )
+      elif [[ $cword -eq 2 ]]; then
+        local templates
+        templates=$(pt completion --templates 2>/dev/null)
+        COMPREPLY=( $(compgen -W "$templates" -- "$cur") )
+      fi
+      ;;
+    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
+        local templates
+        templates=$(pt completion --templates 2>/dev/null)
+        COMPREPLY=( $(compgen -W "$templates" -- "$cur") )
+      fi
+      ;;
+    config)
+      if [[ "$cur" == -* ]]; then
+        COMPREPLY=( $(compgen -W "--json -h --help" -- "$cur") )
+      elif [[ $cword -eq 2 ]]; then
+        local templates
+        templates=$(pt completion --templates 2>/dev/null)
+        COMPREPLY=( $(compgen -W "$templates" -- "$cur") )
+      fi
+      ;;
+    ignore)
+      if [[ "$cur" == -* ]]; then
+        COMPREPLY=( $(compgen -W "--set -h --help" -- "$cur") )
+      fi
+      ;;
+    variables)
+      if [[ "$cur" == -* ]]; then
+        COMPREPLY=( $(compgen -W "--set --json --delete -h --help" -- "$cur") )
+      fi
+      ;;
+    default-post-config)
+      if [[ "$cur" == -* ]]; then
+        COMPREPLY=( $(compgen -W "--set --json -h --help" -- "$cur") )
+      fi
+      ;;
+    add)
+      if [[ "$cur" == -* ]]; then
+        COMPREPLY=( $(compgen -W "-f --file -h --help" -- "$cur") )
+      fi
+      ;;
+    remove|rm)
+      if [[ "$cur" == -* ]]; then
+        COMPREPLY=( $(compgen -W "-y --yes -h --help" -- "$cur") )
+      elif [[ $cword -eq 2 ]]; then
+        local templates
+        templates=$(pt completion --templates 2>/dev/null)
+        COMPREPLY=( $(compgen -W "$templates" -- "$cur") )
+      fi
+      ;;
+    completion)
+      if [[ "$cur" == -* ]]; then
+        COMPREPLY=( $(compgen -W "-h --help" -- "$cur") )
+      elif [[ $cword -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "bash zsh fish" -- "$cur") )
+      fi
+      ;;
+    security-response)
+      if [[ "$cur" == -* ]]; then
+        COMPREPLY=( $(compgen -W "-h --help" -- "$cur") )
+      fi
+      ;;
+  esac
+}
+
+complete -F _pt_completions pt
+`;
+}
+
+export function generateZshCompletion(): string {
+  return `#compdef pt
+
+_pt_templates() {
+  local -a templates
+  templates=(\${(f)"$(pt completion --templates 2>/dev/null)"})
+  if [[ \${#templates[@]} -gt 0 ]]; then
+    _describe -t templates 'template' templates
+  fi
+}
+
+_pt() {
+  local context state state_policy
+  typeset -A opt_args
+
+  _arguments -C \\
+    '(-v --version)'{-v,--version}'[output the version number]' \\
+    '(-h --help)'{-h,--help}'[display help for command]' \\
+    '1: :->command' \\
+    '*:: :->args'
+
+  case $state in
+    command)
+      local -a commands
+      commands=(
+        'learn:Learn a project structure from an existing directory'
+        'update:Update an existing template with new structure/files'
+        'init:Initialize a new project from a learned template'
+        'config:Show current config location and list templates, or export a specific template'
+        'ignore:View or set global ignore patterns (comma-separated)'
+        'variables:View or set global variables (comma-separated key=value)'
+        'default-post-config:View or set default post-config tasks'
+        'add:Import/add a template from a JSON string or file'
+        'remove:Remove a learned template from the config'
+        'rm:Remove a learned template from the config'
+        'security-response:Handle security response from GUI'
+        'completion:Generate shell completion script'
+      )
+      _describe -t commands 'pt command' commands
+      ;;
+    args)
+      case $words[1] in
+        learn)
+          _arguments \\
+            '--ignore=[Folder patterns to ignore]:patterns:' \\
+            '(-y --yes)'{-y,--yes}'[Automatically confirm prompts]' \\
+            '--name=[Template name]:name:' \\
+            '--desc=[Template description]:description:' \\
+            '--json[Output template structure as JSON for sharing instead of saving]' \\
+            '--allow-untrusted[Bypass the trusted-source check for remote URLs]' \\
+            '(-h --help)'{-h,--help}'[display help for command]' \\
+            '1:path:_files -/'
+          ;;
+        update)
+          _arguments \\
+            '--ignore=[Folder patterns to ignore]:patterns:' \\
+            '(-y --yes)'{-y,--yes}'[Automatically confirm prompts]' \\
+            '--desc=[Template description]:description:' \\
+            '--no-diff[Disable additive mode, show full list]' \\
+            '(-h --help)'{-h,--help}'[display help for command]' \\
+            '1:template:_pt_templates' \\
+            '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 -/'
+          ;;
+        config)
+          _arguments \\
+            '--json[Output config or specific template as JSON]' \\
+            '(-h --help)'{-h,--help}'[display help for command]' \\
+            '1:template:_pt_templates'
+          ;;
+        ignore)
+          _arguments \\
+            '--set[Set the ignore patterns to the provided value]' \\
+            '(-h --help)'{-h,--help}'[display help for command]' \\
+            '1:patterns:'
+          ;;
+        variables)
+          _arguments \\
+            '--set[Set the variables to the provided pairs]' \\
+            '--json=[Set variables via JSON string or file]:data:' \\
+            '--delete=[Delete a specific global variable]:key:' \\
+            '(-h --help)'{-h,--help}'[display help for command]' \\
+            '1:pairs:'
+          ;;
+        default-post-config)
+          _arguments \\
+            '--set[Set the default post-config tasks via JSON]' \\
+            '--json=[JSON string or file containing tasks array]:data:' \\
+            '(-h --help)'{-h,--help}'[display help for command]'
+          ;;
+        add)
+          _arguments \\
+            '(-f --file)'{-f,--file}'[Path to JSON file containing template data]:file:_files' \\
+            '(-h --help)'{-h,--help}'[display help for command]' \\
+            '1:name:' \\
+            '2:json:'
+          ;;
+        remove|rm)
+          _arguments \\
+            '(-y --yes)'{-y,--yes}'[Automatically confirm removal]' \\
+            '(-h --help)'{-h,--help}'[display help for command]' \\
+            '1:template:_pt_templates'
+          ;;
+        security-response)
+          _arguments \\
+            '(-h --help)'{-h,--help}'[display help for command]' \\
+            '1:response:'
+          ;;
+        completion)
+          _arguments \\
+            '(-h --help)'{-h,--help}'[display help for command]' \\
+            '1:shell:(bash zsh fish)'
+          ;;
+      esac
+      ;;
+  esac
+}
+
+if [[ "$(basename -- "$0")" != "_pt" ]]; then
+  compdef _pt pt 2>/dev/null || true
+fi
+`;
+}
+
+export function generateFishCompletion(): string {
+  return `# Fish completion for pt
+
+function __fish_pt_needs_command
+    set -l cmd (commandline -opc)
+    if [ (count $cmd) -eq 1 ]
+        return 0
+    end
+    return 1
+end
+
+function __fish_pt_using_command
+    set -l cmd (commandline -opc)
+    if [ (count $cmd) -gt 1 ]
+        if [ "$argv[1]" = "$cmd[2]" ]
+            return 0
+        end
+    end
+    return 1
+end
+
+function __fish_pt_templates
+    pt completion --templates 2>/dev/null
+end
+
+# Global options
+complete -c pt -n '__fish_pt_needs_command' -s v -l version -d 'output the version number'
+complete -c pt -n '__fish_pt_needs_command' -s h -l help -d 'display help for command'
+
+# Commands
+complete -c pt -n '__fish_pt_needs_command' -a learn -d 'Learn a project structure from an existing directory'
+complete -c pt -n '__fish_pt_needs_command' -a update -d 'Update an existing template with new structure/files'
+complete -c pt -n '__fish_pt_needs_command' -a init -d 'Initialize a new project from a learned template'
+complete -c pt -n '__fish_pt_needs_command' -a config -d 'Show current config location and list templates, or export a specific template'
+complete -c pt -n '__fish_pt_needs_command' -a ignore -d 'View or set global ignore patterns (comma-separated)'
+complete -c pt -n '__fish_pt_needs_command' -a variables -d 'View or set global variables (comma-separated key=value)'
+complete -c pt -n '__fish_pt_needs_command' -a default-post-config -d 'View or set default post-config tasks'
+complete -c pt -n '__fish_pt_needs_command' -a add -d 'Import/add a template from a JSON string or file'
+complete -c pt -n '__fish_pt_needs_command' -a remove -d 'Remove a learned template from the config'
+complete -c pt -n '__fish_pt_needs_command' -a rm -d 'Remove a learned template from the config'
+complete -c pt -n '__fish_pt_needs_command' -a security-response -d 'Handle security response from GUI'
+complete -c pt -n '__fish_pt_needs_command' -a completion -d 'Generate shell completion script'
+
+# learn
+complete -c pt -n '__fish_pt_using_command learn' -l ignore -d 'Folder patterns to ignore (comma-separated)'
+complete -c pt -n '__fish_pt_using_command learn' -s y -l yes -d 'Automatically confirm prompts'
+complete -c pt -n '__fish_pt_using_command learn' -l name -d 'Template name (skip prompt)'
+complete -c pt -n '__fish_pt_using_command learn' -l desc -d 'Template description (skip prompt)'
+complete -c pt -n '__fish_pt_using_command learn' -l json -d 'Output template structure as JSON for sharing instead of saving'
+complete -c pt -n '__fish_pt_using_command learn' -l allow-untrusted -d 'Bypass the trusted-source check for remote URLs'
+
+# update
+complete -c pt -n '__fish_pt_using_command update' -a '(__fish_pt_templates)' -d 'Template name'
+complete -c pt -n '__fish_pt_using_command update' -l ignore -d 'Folder patterns to ignore (comma-separated)'
+complete -c pt -n '__fish_pt_using_command update' -s y -l yes -d 'Automatically confirm prompts'
+complete -c pt -n '__fish_pt_using_command update' -l desc -d 'Template description (skip prompt)'
+complete -c pt -n '__fish_pt_using_command update' -l no-diff -d 'Disable additive mode, show full list'
+
+# 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' -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'
+
+# config
+complete -c pt -n '__fish_pt_using_command config' -a '(__fish_pt_templates)' -d 'Template name'
+complete -c pt -n '__fish_pt_using_command config' -l json -d 'Output config or specific template as JSON'
+
+# ignore
+complete -c pt -n '__fish_pt_using_command ignore' -l set -d 'Set the ignore patterns to the provided value'
+
+# variables
+complete -c pt -n '__fish_pt_using_command variables' -l set -d 'Set the variables to the provided pairs'
+complete -c pt -n '__fish_pt_using_command variables' -l json -d 'Set variables via JSON string or file'
+complete -c pt -n '__fish_pt_using_command variables' -l delete -d 'Delete a specific global variable'
+
+# default-post-config
+complete -c pt -n '__fish_pt_using_command default-post-config' -l set -d 'Set the default post-config tasks via JSON'
+complete -c pt -n '__fish_pt_using_command default-post-config' -l json -d 'JSON string or file containing tasks array'
+
+# add
+complete -c pt -n '__fish_pt_using_command add' -s f -l file -d 'Path to JSON file containing template data'
+
+# remove / rm
+complete -c pt -n '__fish_pt_using_command remove' -a '(__fish_pt_templates)' -d 'Template name'
+complete -c pt -n '__fish_pt_using_command remove' -s y -l yes -d 'Automatically confirm removal'
+complete -c pt -n '__fish_pt_using_command rm' -a '(__fish_pt_templates)' -d 'Template name'
+complete -c pt -n '__fish_pt_using_command rm' -s y -l yes -d 'Automatically confirm removal'
+
+# completion
+complete -c pt -n '__fish_pt_using_command completion' -a 'bash zsh fish' -d 'Shell'
+`;
+}
+
+export function generateShellScript(shell: string): string {
+  switch (shell.toLowerCase()) {
+    case 'bash':
+      return generateBashCompletion();
+    case 'zsh':
+      return generateZshCompletion();
+    case 'fish':
+      return generateFishCompletion();
+    default: {
+      const supported = ['bash', 'zsh', 'fish'];
+      throw new Error(`Unsupported shell: ${shell}. Supported: ${supported.join(', ')}`);
+    }
+  }
+}
+
+export function generateCompletion(shell: string): string {
+  return generateShellScript(shell);
+}
+
+export async function completionCommand(shellArg?: string, options?: { templates?: boolean }): Promise<void> {
+  if (options?.templates || shellArg === '--templates' || shellArg === '_templates') {
+    const templates = getTemplatesForCompletion();
+    if (templates.length > 0) {
+      console.log(templates.join('\n'));
+    }
+    return;
+  }
+
+  if (!shellArg) {
+    console.error('Error: Please specify a shell (bash, zsh, fish).');
+    process.exit(1);
+  }
+
+  try {
+    const script = generateCompletion(shellArg);
+    console.log(script);
+  } catch (err: any) {
+    console.error(err.message || String(err));
+    process.exit(1);
+  }
+}
+