@camaradesuk/git-worktree-tools 1.9.0 → 1.11.0

package/dist/cli/wt/completion.js

@@ -3,7 +3,7 @@
  *
  * Generates shell completion scripts for bash, zsh, and fish.
  */
-const BASH_COMPLETION = `###-begin-wt-completions-###
+export const BASH_COMPLETION = `###-begin-wt-completions-###
 #
 # wt bash completion script
 #
@@ -32,7 +32,7 @@ _wt_yargs_completions()
 }
 complete -o bashdefault -o default -F _wt_yargs_completions wt
 ###-end-wt-completions-###`;
-const ZSH_COMPLETION = `#compdef wt
+export const ZSH_COMPLETION = `#compdef wt
 ###-begin-wt-completions-###
 #
 # wt zsh completion script
@@ -58,6 +58,8 @@ _wt() {
     's:Query git worktree state'
     'config:Configuration management'
     'cfg:Configuration management'
+    'prs:Browse repository pull requests'
+    'init:Initialize configuration'
     'completion:Generate shell completion scripts'
   )
 
@@ -78,8 +80,16 @@ _wt() {
             '--draft[Create as draft PR]' \\
             '--json[Output result as JSON]' \\
             '--non-interactive[Run without prompts]' \\
-            '--action[Action to take]:action:(commit_all commit_staged stash)' \\
-            '--stash-untracked[Also stash untracked files]'
+            '--action[Action to take]:action:(empty_commit commit_staged commit_all stash_and_empty use_commits push_then_branch use_commits_and_commit_all use_commits_and_stash create_pr_for_branch pr_for_branch_commit_all pr_for_branch_stash branch_from_detached)' \\
+            '--no-wtlink[Skip wtlink config sync]' \\
+            '--no-hooks[Disable lifecycle hooks]' \\
+            '--confirm-hooks[Prompt before running hooks]' \\
+            '--plan[Generate AI plan document]' \\
+            '--no-plan[Skip plan generation]' \\
+            '--ready[Create PR as ready for review]' \\
+            '--install[Install dependencies after setup]' \\
+            '--code[Open editor to the new worktree]' \\
+            '--base[Base branch for PR]:branch:'
           ;;
         list|ls)
           _arguments \\
@@ -87,7 +97,8 @@ _wt() {
             '--json[Output as JSON]' \\
             '--no-status[Skip GitHub PR status lookup]' \\
             '--no-interactive[Disable interactive mode]' \\
-            '--filter[Filter worktrees by type]:filter:(pr main feature)'
+            '--filter[Filter worktrees by type]:filter:(pr main feature)' \\
+            '--refresh[Force refresh PR status from GitHub]'
           ;;
         clean|c)
           _arguments \\
@@ -95,6 +106,7 @@ _wt() {
             '--all[Clean all merged/closed worktrees]' \\
             '--dry-run[Show what would be cleaned]' \\
             '--force[Force cleanup even with uncommitted changes]' \\
+            '--delete-remote[Delete remote branches after cleaning]' \\
             '--json[Output result as JSON]'
           ;;
         link|l)
@@ -105,13 +117,35 @@ _wt() {
         state|s)
           _arguments \\
             '--json[Output as JSON]' \\
+            '--verbose[Show detailed state information]' \\
+            '--base-branch[Base branch to compare against]:branch:' \\
             '--quiet[Only output state name]'
           ;;
         config|cfg)
           _arguments \\
-            '1:command:(show init edit)' \\
+            '1:command:(interactive init show set get edit validate migrate schema)' \\
+            '--json[Output as JSON]' \\
             '--help[Show help]'
           ;;
+        prs)
+          _arguments \\
+            '--state[Filter by PR state]:state:(open closed merged all)' \\
+            '--author[Filter by author]:author:' \\
+            '--label[Filter by label]:label:' \\
+            '--draft[Show only draft PRs]' \\
+            '--no-draft[Exclude draft PRs]' \\
+            '--with-worktree[Show only PRs with local worktrees]' \\
+            '--limit[Maximum PRs to fetch]:number:' \\
+            '--json[Output as JSON]' \\
+            '--no-interactive[Disable interactive mode]' \\
+            '--refresh[Force refresh from GitHub]'
+          ;;
+        init)
+          _arguments \\
+            '--local[Create local config]' \\
+            '--global[Create global config]' \\
+            '--force[Overwrite existing config]'
+          ;;
         completion)
           _arguments \\
             '1:shell:(bash zsh fish)'
@@ -123,7 +157,7 @@ _wt() {
 
 _wt "$@"
 ###-end-wt-completions-###`;
-const FISH_COMPLETION = `# wt fish completion script
+export const FISH_COMPLETION = `# wt fish completion script
 #
 # Installation:
 #   wt completion fish > ~/.config/fish/completions/wt.fish
@@ -145,15 +179,27 @@ complete -c wt -n '__fish_use_subcommand' -a 'state' -d 'Query git worktree stat
 complete -c wt -n '__fish_use_subcommand' -a 's' -d 'Query state (alias)'
 complete -c wt -n '__fish_use_subcommand' -a 'config' -d 'Configuration management'
 complete -c wt -n '__fish_use_subcommand' -a 'cfg' -d 'Config (alias)'
+complete -c wt -n '__fish_use_subcommand' -a 'prs' -d 'Browse repository pull requests'
+complete -c wt -n '__fish_use_subcommand' -a 'init' -d 'Initialize configuration'
 complete -c wt -n '__fish_use_subcommand' -a 'completion' -d 'Generate shell completion scripts'
 
 # new/n options
 complete -c wt -n '__fish_seen_subcommand_from new n' -l pr -s p -d 'Existing PR number' -r
+complete -c wt -n '__fish_seen_subcommand_from new n' -l branch -s B -d 'Create PR for existing branch' -r
+complete -c wt -n '__fish_seen_subcommand_from new n' -l base -s b -d 'Base branch for PR' -r
 complete -c wt -n '__fish_seen_subcommand_from new n' -l draft -s d -d 'Create as draft PR'
+complete -c wt -n '__fish_seen_subcommand_from new n' -l ready -s r -d 'Create PR as ready for review'
+complete -c wt -n '__fish_seen_subcommand_from new n' -l install -s i -d 'Install dependencies after setup'
+complete -c wt -n '__fish_seen_subcommand_from new n' -l code -s c -d 'Open editor to the new worktree'
+complete -c wt -n '__fish_seen_subcommand_from new n' -l no-wtlink -d 'Skip wtlink config sync'
+complete -c wt -n '__fish_seen_subcommand_from new n' -l no-hooks -d 'Disable lifecycle hooks'
+complete -c wt -n '__fish_seen_subcommand_from new n' -l confirm-hooks -d 'Prompt before running hooks'
+complete -c wt -n '__fish_seen_subcommand_from new n' -l plan -d 'Generate AI plan document'
+complete -c wt -n '__fish_seen_subcommand_from new n' -l no-plan -d 'Skip plan generation'
 complete -c wt -n '__fish_seen_subcommand_from new n' -l json -d 'Output result as JSON'
 complete -c wt -n '__fish_seen_subcommand_from new n' -l non-interactive -s n -d 'Run without prompts'
-complete -c wt -n '__fish_seen_subcommand_from new n' -l action -s a -d 'Action to take' -ra 'commit_all commit_staged stash'
-complete -c wt -n '__fish_seen_subcommand_from new n' -l stash-untracked -d 'Also stash untracked files'
+complete -c wt -n '__fish_seen_subcommand_from new n' -l yes -s y -d 'Run without prompts'
+complete -c wt -n '__fish_seen_subcommand_from new n' -l action -s a -d 'Action to take' -ra 'empty_commit commit_staged commit_all stash_and_empty use_commits push_then_branch use_commits_and_commit_all use_commits_and_stash create_pr_for_branch pr_for_branch_commit_all pr_for_branch_stash branch_from_detached'
 
 # list/ls options
 complete -c wt -n '__fish_seen_subcommand_from list ls' -l verbose -s v -d 'Show full paths'
@@ -161,13 +207,32 @@ complete -c wt -n '__fish_seen_subcommand_from list ls' -l json -d 'Output as JS
 complete -c wt -n '__fish_seen_subcommand_from list ls' -l no-status -s s -d 'Skip GitHub PR status'
 complete -c wt -n '__fish_seen_subcommand_from list ls' -l no-interactive -s n -d 'Disable interactive mode'
 complete -c wt -n '__fish_seen_subcommand_from list ls' -l filter -s f -d 'Filter by type' -ra 'pr main feature'
+complete -c wt -n '__fish_seen_subcommand_from list ls' -l refresh -d 'Force refresh PR status from GitHub'
 
 # clean/c options
 complete -c wt -n '__fish_seen_subcommand_from clean c' -l all -s a -d 'Clean all merged/closed'
 complete -c wt -n '__fish_seen_subcommand_from clean c' -l dry-run -s d -d 'Preview only'
 complete -c wt -n '__fish_seen_subcommand_from clean c' -l force -s f -d 'Force cleanup'
+complete -c wt -n '__fish_seen_subcommand_from clean c' -l delete-remote -s r -d 'Delete remote branches'
 complete -c wt -n '__fish_seen_subcommand_from clean c' -l json -d 'Output as JSON'
 
+# prs options
+complete -c wt -n '__fish_seen_subcommand_from prs' -l state -s s -d 'Filter by PR state' -ra 'open closed merged all'
+complete -c wt -n '__fish_seen_subcommand_from prs' -l author -s a -d 'Filter by author' -r
+complete -c wt -n '__fish_seen_subcommand_from prs' -l label -s l -d 'Filter by label' -r
+complete -c wt -n '__fish_seen_subcommand_from prs' -l draft -d 'Show only draft PRs'
+complete -c wt -n '__fish_seen_subcommand_from prs' -l no-draft -d 'Exclude draft PRs'
+complete -c wt -n '__fish_seen_subcommand_from prs' -l with-worktree -d 'Only PRs with local worktrees'
+complete -c wt -n '__fish_seen_subcommand_from prs' -l limit -s n -d 'Maximum PRs to fetch' -r
+complete -c wt -n '__fish_seen_subcommand_from prs' -l json -s j -d 'Output as JSON'
+complete -c wt -n '__fish_seen_subcommand_from prs' -l no-interactive -d 'Disable interactive mode'
+complete -c wt -n '__fish_seen_subcommand_from prs' -l refresh -s r -d 'Force refresh from GitHub'
+
+# init options
+complete -c wt -n '__fish_seen_subcommand_from init' -l local -s l -d 'Create local config'
+complete -c wt -n '__fish_seen_subcommand_from init' -l global -s g -d 'Create global config'
+complete -c wt -n '__fish_seen_subcommand_from init' -l force -s f -d 'Overwrite existing config'
+
 # link/l subcommands
 complete -c wt -n '__fish_seen_subcommand_from link l' -a 'link' -d 'Create hard links'
 complete -c wt -n '__fish_seen_subcommand_from link l' -a 'manage' -d 'Manage manifest'
@@ -175,12 +240,18 @@ complete -c wt -n '__fish_seen_subcommand_from link l' -a 'validate' -d 'Validat
 
 # state/s options
 complete -c wt -n '__fish_seen_subcommand_from state s' -l json -d 'Output as JSON'
+complete -c wt -n '__fish_seen_subcommand_from state s' -l verbose -s v -d 'Show detailed state'
+complete -c wt -n '__fish_seen_subcommand_from state s' -l base-branch -s b -d 'Base branch to compare against' -r
 complete -c wt -n '__fish_seen_subcommand_from state s' -l quiet -s q -d 'Only output state name'
 
 # config/cfg subcommands
 complete -c wt -n '__fish_seen_subcommand_from config cfg' -a 'show' -d 'Show config'
 complete -c wt -n '__fish_seen_subcommand_from config cfg' -a 'init' -d 'Initialize config'
+complete -c wt -n '__fish_seen_subcommand_from config cfg' -a 'set' -d 'Set config value'
+complete -c wt -n '__fish_seen_subcommand_from config cfg' -a 'get' -d 'Get config value'
 complete -c wt -n '__fish_seen_subcommand_from config cfg' -a 'edit' -d 'Edit config'
+complete -c wt -n '__fish_seen_subcommand_from config cfg' -a 'validate' -d 'Validate config'
+complete -c wt -n '__fish_seen_subcommand_from config cfg' -a 'migrate' -d 'Migrate legacy config'
 
 # completion shells
 complete -c wt -n '__fish_seen_subcommand_from completion' -a 'bash' -d 'Bash completion'

package/dist/cli/wt/completion.js.map

@@ -1 +1 @@
-{"version":3,"file":"completion.js","sourceRoot":"","sources":["../../../src/cli/wt/completion.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA4BG,CAAC;AAE5B,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA0FI,CAAC;AAE5B,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+DvB,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAA0C;IACtE,OAAO,EAAE,oBAAoB;IAC7B,QAAQ,EAAE,mCAAmC;IAC7C,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;QACjB,OAAO,KAAK;aACT,UAAU,CAAC,OAAO,EAAE;YACnB,QAAQ,EAAE,YAAY;YACtB,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC;SACjC,CAAC;aACD,OAAO,CAAC,iCAAiC,EAAE,qCAAqC,CAAC;aACjF,OAAO,CAAC,4CAA4C,EAAE,4BAA4B,CAAC;aACnF,OAAO,CACN,yDAAyD,EACzD,6BAA6B,CAC9B,CAAC;IACN,CAAC;IACD,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE;QAChB,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YAChB,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwBjB,CAAC,CAAC;YACG,OAAO;QACT,CAAC;QAED,QAAQ,IAAI,CAAC,KAAK,EAAE,CAAC;YACnB,KAAK,MAAM;gBACT,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;gBAC7B,MAAM;YACR,KAAK,KAAK;gBACR,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;gBAC5B,MAAM;YACR,KAAK,MAAM;gBACT,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;gBAC7B,MAAM;QACV,CAAC;IACH,CAAC;CACF,CAAC"}
+{"version":3,"file":"completion.js","sourceRoot":"","sources":["../../../src/cli/wt/completion.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA4BJ,CAAC;AAE5B,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA4HH,CAAC;AAE5B,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoG9B,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAA0C;IACtE,OAAO,EAAE,oBAAoB;IAC7B,QAAQ,EAAE,mCAAmC;IAC7C,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;QACjB,OAAO,KAAK;aACT,UAAU,CAAC,OAAO,EAAE;YACnB,QAAQ,EAAE,YAAY;YACtB,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC;SACjC,CAAC;aACD,OAAO,CAAC,iCAAiC,EAAE,qCAAqC,CAAC;aACjF,OAAO,CAAC,4CAA4C,EAAE,4BAA4B,CAAC;aACnF,OAAO,CACN,yDAAyD,EACzD,6BAA6B,CAC9B,CAAC;IACN,CAAC;IACD,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE;QAChB,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YAChB,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwBjB,CAAC,CAAC;YACG,OAAO;QACT,CAAC;QAED,QAAQ,IAAI,CAAC,KAAK,EAAE,CAAC;YACnB,KAAK,MAAM;gBACT,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;gBAC7B,MAAM;YACR,KAAK,KAAK;gBACR,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;gBAC5B,MAAM;YACR,KAAK,MAAM;gBACT,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;gBAC7B,MAAM;QACV,CAAC;IACH,CAAC;CACF,CAAC"}

package/dist/cli/wt/config.d.ts

@@ -1,12 +1,14 @@
 /**
  * wt config - Configuration management
  *
- * Provides interactive config editing and wraps wtconfig CLI functionality.
+ * Direct library call handler - no subprocess spawning.
+ * Handles all config subcommands in-process via library imports.
  */
 import type { CommandModule } from 'yargs';
 interface ConfigArgs {
     subcommand?: string;
     args?: string[];
+    json?: boolean;
 }
 export declare const configCommand: CommandModule<object, ConfigArgs>;
 export {};

package/dist/cli/wt/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/cli/wt/config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAS3C,UAAU,UAAU;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAaD,eAAO,MAAM,aAAa,EAAE,aAAa,CAAC,MAAM,EAAE,UAAU,CA6D3D,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/cli/wt/config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAmC3C,UAAU,UAAU;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAaD,eAAO,MAAM,aAAa,EAAE,aAAa,CAAC,MAAM,EAAE,UAAU,CA0E3D,CAAC"}

package/dist/cli/wt/config.js

@@ -1,15 +1,21 @@
 /**
  * wt config - Configuration management
  *
- * Provides interactive config editing and wraps wtconfig CLI functionality.
+ * Direct library call handler - no subprocess spawning.
+ * Handles all config subcommands in-process via library imports.
  */
-import { runSubcommand } from './run-command.js';
+import * as fs from 'fs';
+import { spawnSync } from 'child_process';
 import * as git from '../../lib/git.js';
 import { runConfigEditor, quickEditConfig } from '../../lib/config-editor.js';
-import { loadConfigWithValidation, getConfigPath } from '../../lib/config.js';
+import { loadConfigWithValidation, getConfigPath, getDefaultConfig } from '../../lib/config.js';
 import { formatValidationErrors } from '../../lib/config-validation.js';
 import { getSchemaUrl } from '../../lib/global-config.js';
 import * as colors from '../../lib/colors.js';
+import { getConfigSource, loadMergedConfig, getConfigValue, setConfigValue, validateConfig, loadRepoConfig, saveRepoConfig, getGlobalConfigPath, findRepoConfigPath, } from '../../lib/wtconfig/index.js';
+import { detectMigrationIssues, runMigration, formatMigrationReport, } from '../../lib/config-migration/index.js';
+import { createSuccessResult, createErrorResult, formatJsonResult, ErrorCode, } from '../../lib/json-output.js';
+import { printError, printStatus } from '../../lib/ui/index.js';
 /**
  * Get repo root safely
  */
@@ -27,7 +33,7 @@ export const configCommand = {
     builder: (yargs) => {
         return yargs
             .positional('subcommand', {
-            describe: 'Subcommand: interactive, init, show, set, get, edit, validate, schema',
+            describe: 'Subcommand: interactive, init, show, set, get, edit, validate, migrate, schema',
             type: 'string',
             default: 'interactive',
         })
@@ -35,6 +41,11 @@ export const configCommand = {
             describe: 'Additional arguments (e.g., key value for set)',
             type: 'string',
             array: true,
+        })
+            .option('json', {
+            type: 'boolean',
+            description: 'Output as JSON (for show, get, validate, migrate)',
+            default: false,
         })
             .example('$0 config', 'Open interactive config editor')
             .example('$0 cfg i', 'Open interactive config editor')
@@ -44,38 +55,51 @@ export const configCommand = {
             .example('$0 config get ai.provider', 'Get a config value')
             .example('$0 cfg edit', 'Open config in text editor')
             .example('$0 config validate', 'Validate configuration')
+            .example('$0 config migrate', 'Migrate legacy config to latest version')
+            .example('$0 config migrate --json', 'Migrate with JSON output')
             .example('$0 config schema', 'Show JSON schema URL');
     },
     handler: async (argv) => {
         const subcommand = argv.subcommand || 'interactive';
         const args = argv.args || [];
-        // Handle interactive mode directly
-        if (subcommand === 'interactive' || subcommand === 'i') {
-            await handleInteractive();
-            return;
-        }
-        // Handle quick set with interactive edit
-        if (subcommand === 'set' && args.length === 1) {
-            // Only key provided, do interactive edit for that property
-            await handleQuickEdit(args[0]);
-            return;
-        }
-        // Handle validate with our validator
-        if (subcommand === 'validate') {
-            await handleValidate();
-            return;
-        }
-        // Handle schema info
-        if (subcommand === 'schema') {
-            handleSchema();
-            return;
-        }
-        // Delegate other commands to wtconfig
-        const wtconfigArgs = [subcommand];
-        if (args.length > 0) {
-            wtconfigArgs.push(...args);
+        switch (subcommand) {
+            case 'interactive':
+            case 'i':
+                await handleInteractive();
+                return;
+            case 'show':
+                handleShow(!!argv.json);
+                return;
+            case 'get':
+                handleGet(args, !!argv.json);
+                return;
+            case 'set':
+                if (args.length === 1) {
+                    await handleQuickEdit(args[0]);
+                }
+                else {
+                    handleSet(args);
+                }
+                return;
+            case 'edit':
+                handleEdit();
+                return;
+            case 'init':
+                handleInit();
+                return;
+            case 'validate':
+                handleValidate(!!argv.json);
+                return;
+            case 'migrate':
+                await handleMigrate(!!argv.json);
+                return;
+            case 'schema':
+                handleSchema();
+                return;
+            default:
+                printError({ title: `Unknown config subcommand: ${subcommand}` });
+                process.exit(1);
         }
-        runSubcommand('wtconfig', wtconfigArgs);
     },
 };
 /**
@@ -104,6 +128,138 @@ async function handleInteractive() {
         throw error;
     }
 }
+/**
+ * Handle show subcommand - display current configuration
+ */
+function handleShow(json) {
+    const repoRoot = getRepoRoot();
+    const source = getConfigSource(repoRoot ?? undefined);
+    const config = loadMergedConfig(repoRoot ?? undefined);
+    if (json) {
+        const result = createSuccessResult('wtconfig', {
+            subcommand: 'show',
+            source: source.type === 'none' ? null : source.path,
+            config,
+        });
+        console.log(formatJsonResult(result));
+        return;
+    }
+    const defaults = getDefaultConfig();
+    console.log(colors.info('Current Configuration'));
+    console.log();
+    if (source.type === 'none') {
+        console.log(colors.dim('No configuration file found. Using defaults.'));
+        console.log(colors.dim('Run "wt init" to create a configuration file.'));
+        console.log();
+    }
+    else {
+        console.log(colors.dim(`Source: ${source.path}`));
+        console.log();
+    }
+    const lines = ['{'];
+    const addLine = (key, value, defaultValue) => {
+        const isDefault = JSON.stringify(value) === JSON.stringify(defaultValue);
+        const valueStr = JSON.stringify(value);
+        if (isDefault) {
+            lines.push(`  ${key}: ${valueStr} ${colors.dim('(default)')}`);
+        }
+        else {
+            lines.push(`  ${colors.success(key + ':')} ${valueStr}`);
+        }
+    };
+    addLine('baseBranch', config.baseBranch ?? defaults.baseBranch, defaults.baseBranch);
+    addLine('draftPr', config.draftPr ?? defaults.draftPr, defaults.draftPr);
+    addLine('branchPrefix', config.branchPrefix ?? defaults.branchPrefix, defaults.branchPrefix);
+    addLine('worktreePattern', config.worktreePattern ?? defaults.worktreePattern, defaults.worktreePattern);
+    addLine('worktreeParent', config.worktreeParent ?? defaults.worktreeParent, defaults.worktreeParent);
+    addLine('preferredEditor', config.preferredEditor ?? defaults.preferredEditor, defaults.preferredEditor);
+    if (config.sharedRepos && config.sharedRepos.length > 0) {
+        addLine('sharedRepos', config.sharedRepos, defaults.sharedRepos);
+    }
+    if (config.ai) {
+        lines.push(`  ${colors.info('ai:')} ${JSON.stringify(config.ai)}`);
+    }
+    if (config.hooks && Object.keys(config.hooks).length > 0) {
+        lines.push(`  ${colors.info('hooks:')} ${JSON.stringify(config.hooks)}`);
+    }
+    lines.push('}');
+    console.log(lines.join('\n'));
+}
+/**
+ * Handle get subcommand - get a specific config value
+ */
+function handleGet(args, json) {
+    if (args.length === 0) {
+        printError({ title: 'Missing key argument', hint: 'Usage: wt config get <key>' });
+        process.exit(1);
+    }
+    const key = args[0];
+    const repoRoot = getRepoRoot();
+    const config = loadMergedConfig(repoRoot ?? undefined);
+    const defaults = getDefaultConfig();
+    let value = getConfigValue(config, key);
+    if (value === undefined) {
+        value = getConfigValue(defaults, key);
+    }
+    if (value === undefined) {
+        if (json) {
+            const errorResult = createErrorResult('wtconfig', ErrorCode.INVALID_ARGUMENT, `Unknown configuration key: ${key}`);
+            console.log(formatJsonResult(errorResult));
+        }
+        else {
+            printError({ title: `Key "${key}" not found in configuration` });
+        }
+        process.exit(1);
+    }
+    if (json) {
+        const result = createSuccessResult('wtconfig', { subcommand: 'get', key, value });
+        console.log(formatJsonResult(result));
+        return;
+    }
+    if (typeof value === 'object') {
+        console.log(JSON.stringify(value, null, 2));
+    }
+    else {
+        console.log(String(value));
+    }
+}
+/**
+ * Handle set subcommand with key and value
+ */
+function handleSet(args) {
+    if (args.length < 2) {
+        printError({ title: 'Usage: wt config set <key> <value>' });
+        process.exit(1);
+    }
+    const key = args[0];
+    const value = args[1];
+    const repoRoot = getRepoRoot();
+    if (!repoRoot) {
+        console.error(colors.error('Not in a git repository.'));
+        process.exit(1);
+    }
+    const currentConfig = loadRepoConfig(repoRoot) || {};
+    try {
+        const newConfig = setConfigValue(currentConfig, key, value);
+        const validation = validateConfig(newConfig);
+        if (!validation.valid) {
+            console.error(colors.error('Configuration validation failed:'));
+            for (const error of validation.errors) {
+                console.error(colors.error(`  ${error.path}: ${error.message}`));
+            }
+            process.exit(1);
+        }
+        for (const warning of validation.warnings) {
+            console.warn(colors.warning(`Warning: ${warning.path}: ${warning.message}`));
+        }
+        saveRepoConfig(repoRoot, newConfig);
+        console.log(colors.success(`Set ${key} = ${value}`));
+    }
+    catch (error) {
+        console.error(colors.error(`Failed to set value: ${error instanceof Error ? error.message : String(error)}`));
+        process.exit(1);
+    }
+}
 /**
  * Handle quick edit of a single property
  */
@@ -125,9 +281,80 @@ async function handleQuickEdit(key) {
     }
 }
 /**
- * Handle config validation
+ * Handle edit subcommand - open config in editor
  */
-async function handleValidate() {
+function handleEdit() {
+    const repoRoot = getRepoRoot();
+    const configPath = repoRoot ? findRepoConfigPath(repoRoot) : null;
+    if (!configPath) {
+        const globalPath = getGlobalConfigPath();
+        if (fs.existsSync(globalPath)) {
+            openInEditor(globalPath);
+            return;
+        }
+        printError({ title: 'No configuration file found.', hint: 'Run "wt init" to create one.' });
+        process.exit(1);
+    }
+    openInEditor(configPath);
+}
+/**
+ * Open a file in the system editor
+ */
+function openInEditor(filePath) {
+    const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
+    console.log(colors.dim(`Opening ${filePath} in ${editor}...`));
+    try {
+        spawnSync(editor, [filePath], { stdio: 'inherit' });
+    }
+    catch {
+        console.error(colors.error('Failed to open editor'));
+        process.exit(1);
+    }
+}
+/**
+ * Handle init subcommand - redirect to wt init
+ */
+function handleInit() {
+    console.log(colors.info('Use "wt init" to initialize git-worktree-tools configuration.'));
+    console.log();
+    console.log(colors.dim('Examples:'));
+    console.log(colors.dim('  wt init          Interactive initialization'));
+    console.log(colors.dim('  wt init --local   Create local config (gitignored)'));
+    console.log(colors.dim('  wt init --global  Create global config'));
+}
+/**
+ * Handle validate subcommand
+ */
+function handleValidate(json) {
+    if (json) {
+        const repoRoot = getRepoRoot();
+        const source = getConfigSource(repoRoot ?? undefined);
+        if (source.type === 'none') {
+            const result = createSuccessResult('wtconfig', {
+                subcommand: 'validate',
+                valid: true,
+                source: null,
+                errors: [],
+                warnings: [],
+            });
+            console.log(formatJsonResult(result));
+            return;
+        }
+        const config = loadMergedConfig(repoRoot ?? undefined);
+        const validationResult = validateConfig(config);
+        const result = createSuccessResult('wtconfig', {
+            subcommand: 'validate',
+            valid: validationResult.valid,
+            source: source.path,
+            errors: validationResult.errors,
+            warnings: validationResult.warnings,
+        });
+        console.log(formatJsonResult(result));
+        if (!validationResult.valid) {
+            process.exit(1);
+        }
+        return;
+    }
     const repoRoot = getRepoRoot();
     if (!repoRoot) {
         console.error(colors.error('Not in a git repository.'));
@@ -153,6 +380,70 @@ async function handleValidate() {
     console.log(formatValidationErrors(validation.errors));
     process.exit(1);
 }
+/**
+ * Handle migrate subcommand
+ */
+async function handleMigrate(json) {
+    const repoRoot = getRepoRoot();
+    if (!repoRoot) {
+        if (json) {
+            const errorResult = createErrorResult('wtconfig', ErrorCode.NOT_GIT_REPO, 'Not in a git repository');
+            console.log(formatJsonResult(errorResult));
+        }
+        else {
+            console.error(colors.error('Error: Not in a git repository'));
+            console.error(colors.dim('Run this command from within a git repository.'));
+        }
+        process.exit(1);
+    }
+    const detection = detectMigrationIssues(repoRoot);
+    if (detection.issues.length === 0) {
+        if (json) {
+            const result = createSuccessResult('wtconfig', {
+                migrated: false,
+                message: 'No migration needed',
+            });
+            console.log(formatJsonResult(result));
+        }
+        else {
+            printStatus('success', 'No migration needed.');
+        }
+        return;
+    }
+    if (json) {
+        const result = await runMigration(repoRoot, detection, { deleteLegacyFiles: false });
+        console.log(formatJsonResult(createSuccessResult('wtconfig', {
+            success: result.success,
+            backupPath: result.backupPath,
+            configPath: result.newConfigPath,
+            actionsApplied: result.actionsExecuted.length,
+            errors: result.errors,
+        })));
+        if (!result.success) {
+            process.exit(1);
+        }
+        return;
+    }
+    console.log(formatMigrationReport(detection, { verbose: true }));
+    console.log();
+    const result = await runMigration(repoRoot, detection, { deleteLegacyFiles: false });
+    if (result.success) {
+        console.log();
+        printStatus('success', 'Migration completed successfully!');
+        if (result.backupPath) {
+            console.log(colors.dim(`Backup created: ${result.backupPath}`));
+        }
+        console.log(colors.dim(`Config updated: ${result.newConfigPath}`));
+    }
+    else {
+        console.log();
+        console.error(colors.error('Migration failed:'));
+        for (const err of result.errors) {
+            console.error(colors.error(`  ${err}`));
+        }
+        process.exit(1);
+    }
+}
 /**
  * Handle schema info
  */