easy-worktree 0.0.7__py3-none-any.whl → 0.1.1__py3-none-any.whl

easy_worktree/__init__.py

@@ -2,216 +2,226 @@
 """
 Git worktree を簡単に管理するための CLI ツール
 """
+
 import os
 import subprocess
+import shutil
 import sys
 from pathlib import Path
 import re
-from datetime import datetime
-import json
+from datetime import datetime, timezone
+import toml
 
 
 # 言語判定
 def is_japanese() -> bool:
     """LANG環境変数から日本語かどうかを判定"""
-    lang = os.environ.get('LANG', '')
-    return 'ja' in lang.lower()
+    lang = os.environ.get("LANG", "")
+    return "ja" in lang.lower()
 
 
 # メッセージ辞書
 MESSAGES = {
-    'error': {
-        'en': 'Error: {}',
-        'ja': 'エラー: {}'
-    },
-    'usage': {
-        'en': 'Usage: wt clone <repository_url>',
-        'ja': '使用方法: wt clone <repository_url>'
-    },
-    'usage_add': {
-        'en': 'Usage: wt add <work_name> [<base_branch>] [--alias <name>]',
-        'ja': '使用方法: wt add <作業名> [<base_branch>] [--alias <名前>]'
-    },
-    'usage_rm': {
-        'en': 'Usage: wt rm <work_name>',
-        'ja': '使用方法: wt rm <作業名>'
-    },
-    'base_not_found': {
-        'en': '_base/ directory not found',
-        'ja': '_base/ ディレクトリが見つかりません'
-    },
-    'run_in_wt_dir': {
-        'en': 'Please run inside WT_<repository_name>/ directory',
-        'ja': 'WT_<repository_name>/ ディレクトリ内で実行してください'
-    },
-    'already_exists': {
-        'en': '{} already exists',
-        'ja': '{} はすでに存在します'
-    },
-    'cloning': {
-        'en': 'Cloning: {} -> {}',
-        'ja': 'クローン中: {} -> {}'
+    "error": {"en": "Error: {}", "ja": "エラー: {}"},
+    "usage": {
+        "en": "Usage: wt clone <repository_url>",
+        "ja": "使用方法: wt clone <repository_url>",
     },
-    'completed_clone': {
-        'en': 'Completed: cloned to {}',
-        'ja': '完了: {} にクローンしました'
+    "usage_add": {
+        "en": "Usage: wt add (ad) <work_name> [<base_branch>]",
+        "ja": "使用方法: wt add (ad) <作業名> [<base_branch>]",
     },
-    'not_git_repo': {
-        'en': 'Current directory is not a git repository',
-        'ja': '現在のディレクトリは git リポジトリではありません'
+    "usage_rm": {"en": "Usage: wt rm <work_name>", "ja": "使用方法: wt rm <作業名>"},
+    "base_not_found": {
+        "en": "Main repository directory not found",
+        "ja": "メインリポジトリのディレクトリが見つかりません",
     },
-    'run_at_root': {
-        'en': 'Please run at repository root directory {}',
-        'ja': 'リポジトリのルートディレクトリ {} で実行してください'
+    "run_in_wt_dir": {
+        "en": "Please run inside WT_<repository_name>/ directory",
+        "ja": "WT_<repository_name>/ ディレクトリ内で実行してください",
     },
-    'creating_dir': {
-        'en': 'Creating {}...',
-        'ja': '{} を作成中...'
+    "already_exists": {"en": "{} already exists", "ja": "{} はすでに存在します"},
+    "cloning": {"en": "Cloning: {} -> {}", "ja": "クローン中: {} -> {}"},
+    "completed_clone": {
+        "en": "Completed: cloned to {}",
+        "ja": "完了: {} にクローンしました",
     },
-    'moving': {
-        'en': 'Moving {} -> {}...',
-        'ja': '{} -> {} に移動中...'
+    "not_git_repo": {
+        "en": "Current directory is not a git repository",
+        "ja": "現在のディレクトリは git リポジトリではありません",
     },
-    'completed_move': {
-        'en': 'Completed: moved to {}',
-        'ja': '完了: {} に移動しました'
+    "run_at_root": {
+        "en": "Please run at repository root directory {}",
+        "ja": "リポジトリのルートディレクトリ {} で実行してください",
     },
-    'use_wt_from': {
-        'en': 'Use wt command from {} from next time',
-        'ja': '次回から {} で wt コマンドを使用してください'
+    "creating_dir": {"en": "Creating {}...", "ja": "{} を作成中..."},
+    "moving": {"en": "Moving {} -> {}...", "ja": "{} -> {} に移動中..."},
+    "completed_move": {"en": "Completed: moved to {}", "ja": "完了: {} に移動しました"},
+    "use_wt_from": {
+        "en": "Use wt command from {} from next time",
+        "ja": "次回から {} で wt コマンドを使用してください",
     },
-    'fetching': {
-        'en': 'Fetching latest information from remote...',
-        'ja': 'リモートから最新情報を取得中...'
+    "fetching": {
+        "en": "Fetching latest information from remote...",
+        "ja": "リモートから最新情報を取得中...",
     },
-    'creating_worktree': {
-        'en': 'Creating worktree: {}',
-        'ja': 'worktree を作成中: {}'
+    "creating_worktree": {"en": "Creating worktree: {}", "ja": "worktree を作成中: {}"},
+    "completed_worktree": {
+        "en": "Completed: created worktree at {}",
+        "ja": "完了: {} に worktree を作成しました",
     },
-    'completed_worktree': {
-        'en': 'Completed: created worktree at {}',
-        'ja': '完了: {} に worktree を作成しました'
+    "removing_worktree": {"en": "Removing worktree: {}", "ja": "worktree を削除中: {}"},
+    "completed_remove": {
+        "en": "Completed: removed {}",
+        "ja": "完了: {} を削除しました",
     },
-    'removing_worktree': {
-        'en': 'Removing worktree: {}',
-        'ja': 'worktree を削除中: {}'
+    "creating_branch": {
+        "en": "Creating new branch '{}' from '{}'",
+        "ja": "ブランチ '{}' を '{}' から作成しています",
     },
-    'completed_remove': {
-        'en': 'Completed: removed {}',
-        'ja': '完了: {} を削除しました'
+    "default_branch_not_found": {
+        "en": "Could not find default branch (main/master)",
+        "ja": "デフォルトブランチ (main/master) が見つかりません",
     },
-    'creating_branch': {
-        'en': "Creating new branch '{}' from '{}'",
-        'ja': "'{}' から新しいブランチ '{}' を作成"
+    "running_hook": {
+        "en": "Running post-add hook: {}",
+        "ja": "post-add hook を実行中: {}",
     },
-    'default_branch_not_found': {
-        'en': 'Could not find default branch (main/master)',
-        'ja': 'デフォルトブランチ (main/master) が見つかりません'
+    "hook_not_executable": {
+        "en": "Warning: hook is not executable: {}",
+        "ja": "警告: hook が実行可能ではありません: {}",
     },
-    'running_hook': {
-        'en': 'Running post-add hook: {}',
-        'ja': 'post-add hook を実行中: {}'
+    "hook_failed": {
+        "en": "Warning: hook exited with code {}",
+        "ja": "警告: hook が終了コード {} で終了しました",
     },
-    'hook_not_executable': {
-        'en': 'Warning: hook is not executable: {}',
-        'ja': '警告: hook が実行可能ではありません: {}'
+    "usage_clean": {
+        "en": "Usage: wt clean (cl) [--days N] [--merged] [--closed] [--all]",
+        "ja": "使用方法: wt clean (cl) [--days N] [--merged] [--closed] [--all]",
     },
-    'hook_failed': {
-        'en': 'Warning: hook exited with code {}',
-        'ja': '警告: hook が終了コード {} で終了しました'
+    "alias_updated": {
+        "en": "Updated alias: {} -> {}",
+        "ja": "エイリアスを更新しました: {} -> {}",
     },
-    'usage_clean': {
-        'en': 'Usage: wt clean [--dry-run] [--days N] [--all]',
-        'ja': '使用方法: wt clean [--dry-run] [--days N] [--all]'
+    "no_clean_targets": {
+        "en": "No worktrees to clean",
+        "ja": "クリーンアップ対象の worktree がありません",
     },
-    'usage_alias': {
-        'en': 'Usage: wt alias <name> <worktree> | wt alias --list | wt alias --remove <name>',
-        'ja': '使用方法: wt alias <名前> <worktree> | wt alias --list | wt alias --remove <名前>'
+    "clean_target": {
+        "en": "Will remove: {} (created: {}, clean)",
+        "ja": "削除対象: {} (作成日時: {}, 変更なし)",
     },
-    'alias_updated': {
-        'en': 'Updated alias: {} -> {}',
-        'ja': 'エイリアスを更新しました: {} -> {}'
+    "clean_confirm": {
+        "en": "Remove {} worktree(s)? [y/N]: ",
+        "ja": "{} 個の worktree を削除しますか？ [y/N]: ",
     },
-    'no_clean_targets': {
-        'en': 'No worktrees to clean',
-        'ja': 'クリーンアップ対象の worktree がありません'
+    "alias_removed": {"en": "Removed alias: {}", "ja": "エイリアスを削除しました: {}"},
+    "alias_not_found": {
+        "en": "Alias not found: {}",
+        "ja": "エイリアスが見つかりません: {}",
     },
-    'clean_target': {
-        'en': 'Will remove: {} (created: {}, clean)',
-        'ja': '削除対象: {} (作成日時: {}, 変更なし)'
+    "worktree_name": {"en": "Worktree", "ja": "Worktree"},
+    "branch_name": {"en": "Branch", "ja": "ブランチ"},
+    "created_at": {"en": "Created", "ja": "作成日時"},
+    "last_commit": {"en": "Last Commit", "ja": "最終コミット"},
+    "status_label": {"en": "Status", "ja": "状態"},
+    "changes_label": {"en": "Changes", "ja": "変更"},
+    "syncing": {"en": "Syncing: {} -> {}", "ja": "同期中: {} -> {}"},
+    "completed_sync": {
+        "en": "Completed sync of {} files",
+        "ja": "{} 個のファイルを同期しました",
     },
-    'clean_confirm': {
-        'en': 'Remove {} worktree(s)? [y/N]: ',
-        'ja': '{} 個の worktree を削除しますか？ [y/N]: '
+    "usage_sync": {
+        "en": "Usage: wt sync (sy) [files...] [--from <name>] [--to <name>]",
+        "ja": "使用方法: wt sync (sy) [files...] [--from <name>] [--to <name>]",
     },
-    'alias_created': {
-        'en': 'Created alias: {} -> {}',
-        'ja': 'エイリアスを作成しました: {} -> {}'
+    "usage_pr": {
+        "en": "Usage: wt pr add <number>",
+        "ja": "使用方法: wt pr add <number>",
     },
-    'alias_removed': {
-        'en': 'Removed alias: {}',
-        'ja': 'エイリアスを削除しました: {}'
+    "usage_stash": {
+        "en": "Usage: wt stash (st) <work_name> [<base_branch>]",
+        "ja": "使用方法: wt stash (st) <work_name> [<base_branch>]",
     },
-    'alias_not_found': {
-        'en': 'Alias not found: {}',
-        'ja': 'エイリアスが見つかりません: {}'
+    "stashing_changes": {
+        "en": "Stashing local changes...",
+        "ja": "ローカルの変更をスタッシュ中...",
     },
-    'worktree_name': {
-        'en': 'Worktree',
-        'ja': 'Worktree'
+    "popping_stash": {
+        "en": "Moving changes to new worktree...",
+        "ja": "変更を新しい worktree に移動中...",
     },
-    'branch_name': {
-        'en': 'Branch',
-        'ja': 'ブランチ'
+    "nothing_to_stash": {
+        "en": "No local changes to stash.",
+        "ja": "スタッシュする変更がありません",
     },
-    'created_at': {
-        'en': 'Created',
-        'ja': '作成日時'
-    },
-    'last_commit': {
-        'en': 'Last Commit',
-        'ja': '最終コミット'
-    },
-    'status_label': {
-        'en': 'Status',
-        'ja': '状態'
-    }
 }
 
 
 def msg(key: str, *args) -> str:
     """言語に応じたメッセージを取得"""
-    lang = 'ja' if is_japanese() else 'en'
+    lang = "ja" if is_japanese() else "en"
     message = MESSAGES.get(key, {}).get(lang, key)
     if args:
         return message.format(*args)
     return message
 
 
-def run_command(cmd: list[str], cwd: Path = None, check: bool = True) -> subprocess.CompletedProcess:
+def run_command(
+    cmd: list[str], cwd: Path = None, check: bool = True
+) -> subprocess.CompletedProcess:
     """コマンドを実行"""
     try:
+        # print(f"DEBUG: Running command: {cmd} cwd={cwd}", file=sys.stderr)
         result = subprocess.run(
-            cmd,
-            cwd=cwd,
-            capture_output=True,
-            text=True,
-            check=check
+            cmd, cwd=cwd, capture_output=True, text=True, check=check
         )
         return result
     except subprocess.CalledProcessError as e:
-        print(msg('error', e.stderr), file=sys.stderr)
+        print(msg("error", e.stderr), file=sys.stderr)
         sys.exit(1)
 
 
 def get_repository_name(url: str) -> str:
     """リポジトリ URL から名前を抽出"""
     # URL から .git を削除して最後の部分を取得
-    match = re.search(r'/([^/]+?)(?:\.git)?$', url)
+    match = re.search(r"/([^/]+?)(?:\.git)?$", url)
     if match:
-        return match.group(1)
+        name = match.group(1)
+        # サービス名などが含まれる場合のクリーンアップ
+        return name.split(":")[-1]
     # ローカルパスの場合
-    return Path(url).name
+    return Path(url).stem
+
+
+def load_config(base_dir: Path) -> dict:
+    """設定ファイルを読み込む"""
+    config_file = base_dir / ".wt" / "config.toml"
+    default_config = {
+        "worktrees_dir": ".worktrees",
+        "sync_files": [".env"],
+        "auto_copy_on_add": True,
+    }
+
+    if config_file.exists():
+        try:
+            with open(config_file, "r", encoding="utf-8") as f:
+                user_config = toml.load(f)
+                default_config.update(user_config)
+        except Exception as e:
+            print(msg("error", f"Failed to load config: {e}"), file=sys.stderr)
+
+    return default_config
+
+
+def save_config(base_dir: Path, config: dict):
+    """設定ファイルを保存する"""
+    wt_dir = base_dir / ".wt"
+    wt_dir.mkdir(exist_ok=True)
+    config_file = wt_dir / "config.toml"
+
+    with open(config_file, "w", encoding="utf-8") as f:
+        toml.dump(config, f)
 
 
 def create_hook_template(base_dir: Path):
@@ -221,6 +231,39 @@ def create_hook_template(base_dir: Path):
     # .wt ディレクトリを作成
     wt_dir.mkdir(exist_ok=True)
 
+    # config.toml
+    config_file = wt_dir / "config.toml"
+    if not config_file.exists():
+        save_config(
+            base_dir,
+            {
+                "worktrees_dir": ".worktrees",
+                "sync_files": [".env"],
+                "auto_copy_on_add": True,
+            },
+        )
+
+    # .gitignore (repository root) に worktrees_dir を追加
+    config = load_config(base_dir)
+    worktrees_dir_name = config.get("worktrees_dir", ".worktrees")
+    root_gitignore = base_dir / ".gitignore"
+
+    entries = [f"{worktrees_dir_name}/"]
+
+    if root_gitignore.exists():
+        content = root_gitignore.read_text(encoding="utf-8")
+        updated = False
+        for entry in entries:
+            if entry not in content:
+                if content and not content.endswith("\n"):
+                    content += "\n"
+                content += f"{entry}\n"
+                updated = True
+        if updated:
+            root_gitignore.write_text(content, encoding="utf-8")
+    else:
+        root_gitignore.write_text("\n".join(entries) + "\n", encoding="utf-8")
+
     # post-add hook テンプレート
     hook_file = wt_dir / "post-add"
     if not hook_file.exists():
@@ -231,7 +274,7 @@ def create_hook_template(base_dir: Path):
 # Available environment variables:
 #   WT_WORKTREE_PATH  - Path to the created worktree
 #   WT_WORKTREE_NAME  - Name of the worktree
-#   WT_BASE_DIR       - Path to the _base/ directory
+#   WT_BASE_DIR       - Path to the main repository directory
 #   WT_BRANCH         - Branch name
 #   WT_ACTION         - Action name (add)
 #
@@ -339,7 +382,7 @@ wt add feature-b --alias current
 
 - `WT_WORKTREE_PATH`: 作成された worktree のパス
 - `WT_WORKTREE_NAME`: worktree の名前
-- `WT_BASE_DIR`: _base/ ディレクトリのパス
+- `WT_BASE_DIR`: メインリポジトリディレクトリのパス
 - `WT_BRANCH`: ブランチ名
 - `WT_ACTION`: アクション名（常に "add"）
 
@@ -422,7 +465,7 @@ The `post-add` hook is a script that runs automatically after creating a worktre
 
 - `WT_WORKTREE_PATH`: Path to the created worktree
 - `WT_WORKTREE_NAME`: Name of the worktree
-- `WT_BASE_DIR`: Path to the _base/ directory
+- `WT_BASE_DIR`: Path to the main repository directory
 - `WT_BRANCH`: Branch name
 - `WT_ACTION`: Action name (always "add")
 
@@ -436,110 +479,97 @@ The `post-add` hook is a script that runs automatically after creating a worktre
 
 
 def find_base_dir() -> Path | None:
-    """現在のディレクトリまたは親ディレクトリから _base/ を探す"""
-    current = Path.cwd()
-
-    # 現在のディレクトリに _base/ がある場合
-    base_dir = current / "_base"
-    if base_dir.exists() and base_dir.is_dir():
-        return base_dir
+    """現在のディレクトリまたは親ディレクトリから git root を探す"""
+    try:
+        result = run_command(["git", "rev-parse", "--show-toplevel"], check=False)
+        if result.returncode == 0:
+            return Path(result.stdout.strip())
+    except Exception:
+        pass
 
-    # 親ディレクトリに _base/ がある場合（worktree の中にいる場合）
-    base_dir = current.parent / "_base"
-    if base_dir.exists() and base_dir.is_dir():
-        return base_dir
+    # git コマンドが失敗した場合、.git ディレクトリを探す
+    current = Path.cwd()
+    for parent in [current] + list(current.parents):
+        if (parent / ".git").exists():
+            return parent
 
     return None
 
 
 def cmd_clone(args: list[str]):
-    """wt clone <repository_url> - Clone a repository"""
+    """wt clone <repository_url> [dest_dir] - Clone a repository"""
     if len(args) < 1:
-        print(msg('usage'), file=sys.stderr)
+        print(msg("usage"), file=sys.stderr)
         sys.exit(1)
 
     repo_url = args[0]
     repo_name = get_repository_name(repo_url)
 
-    # WT_<repository_name>/_base にクローン
-    parent_dir = Path(f"WT_{repo_name}")
-    base_dir = parent_dir / "_base"
+    dest_dir = Path(args[1]) if len(args) > 1 else Path(repo_name)
 
-    if base_dir.exists():
-        print(msg('error', msg('already_exists', base_dir)), file=sys.stderr)
+    if dest_dir.exists():
+        print(msg("error", msg("already_exists", dest_dir)), file=sys.stderr)
         sys.exit(1)
 
-    parent_dir.mkdir(exist_ok=True)
-
-    print(msg('cloning', repo_url, base_dir))
-    run_command(["git", "clone", repo_url, str(base_dir)])
-    print(msg('completed_clone', base_dir))
+    print(msg("cloning", repo_url, dest_dir), file=sys.stderr)
+    run_command(["git", "clone", repo_url, str(dest_dir)])
+    print(msg("completed_clone", dest_dir), file=sys.stderr)
 
-    # post-add hook テンプレートを作成
-    create_hook_template(base_dir)
+    # post-add hook と設定ファイルを作成
+    create_hook_template(dest_dir)
 
 
 def cmd_init(args: list[str]):
-    """wt init - Move existing git repository to WT_<repo>/_base/"""
+    """wt init - Initialize easy-worktree in current git repository"""
     current_dir = Path.cwd()
 
     # 現在のディレクトリが git リポジトリか確認
     result = run_command(
-        ["git", "rev-parse", "--show-toplevel"],
-        cwd=current_dir,
-        check=False
+        ["git", "rev-parse", "--show-toplevel"], cwd=current_dir, check=False
     )
 
     if result.returncode != 0:
-        print(msg('error', msg('not_git_repo')), file=sys.stderr)
+        print(msg("error", msg("not_git_repo")), file=sys.stderr)
         sys.exit(1)
 
     git_root = Path(result.stdout.strip())
 
-    # カレントディレクトリがリポジトリのルートでない場合はエラー
-    if git_root != current_dir:
-        print(msg('error', msg('run_at_root', git_root)), file=sys.stderr)
-        sys.exit(1)
+    # post-add hook と設定ファイルを作成
+    create_hook_template(git_root)
+
 
-    # リポジトリ名を取得（remote origin から、なければディレクトリ名）
+def get_default_branch(base_dir: Path) -> str:
+    """Detect default branch (main/master)"""
+    # 1. Try origin/HEAD
     result = run_command(
-        ["git", "remote", "get-url", "origin"],
-        cwd=current_dir,
-        check=False
+        ["git", "rev-parse", "--abbrev-ref", "origin/HEAD"], cwd=base_dir, check=False
     )
+    if result.returncode == 0:
+        return result.stdout.strip().replace("origin/", "")
+
+    # 2. Try common names
+    for b in ["main", "master"]:
+        if (
+            run_command(
+                ["git", "rev-parse", "--verify", b], cwd=base_dir, check=False
+            ).returncode
+            == 0
+        ):
+            return b
+
+    # 3. Fallback to current HEAD
+    result = run_command(
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=base_dir, check=False
+    )
+    if result.returncode == 0:
+        return result.stdout.strip()
 
-    if result.returncode == 0 and result.stdout.strip():
-        repo_name = get_repository_name(result.stdout.strip())
-    else:
-        # リモートがない場合は現在のディレクトリ名を使用
-        repo_name = current_dir.name
-
-    # 親ディレクトリと新しいパスを決定
-    parent_of_current = current_dir.parent
-    wt_parent_dir = parent_of_current / f"WT_{repo_name}"
-    new_base_dir = wt_parent_dir / "_base"
-
-    # すでに WT_<repo> が存在するかチェック
-    if wt_parent_dir.exists():
-        print(msg('error', msg('already_exists', wt_parent_dir)), file=sys.stderr)
-        sys.exit(1)
-
-    # WT_<repo>/ ディレクトリを作成
-    print(msg('creating_dir', wt_parent_dir))
-    wt_parent_dir.mkdir(exist_ok=True)
-
-    # 現在のディレクトリを WT_<repo>/_base/ に移動
-    print(msg('moving', current_dir, new_base_dir))
-    current_dir.rename(new_base_dir)
-
-    print(msg('completed_move', new_base_dir))
-    print(msg('use_wt_from', wt_parent_dir))
-
-    # post-add hook テンプレートを作成
-    create_hook_template(new_base_dir)
+    return None
 
 
-def run_post_add_hook(worktree_path: Path, work_name: str, base_dir: Path, branch: str = None):
+def run_post_add_hook(
+    worktree_path: Path, work_name: str, base_dir: Path, branch: str = None
+):
     """worktree 作成後の hook を実行"""
     # .wt/post-add を探す
     hook_path = base_dir / ".wt" / "post-add"
@@ -548,344 +578,744 @@ def run_post_add_hook(worktree_path: Path, work_name: str, base_dir: Path, branc
         return  # hook がなければ何もしない
 
     if not os.access(hook_path, os.X_OK):
-        print(msg('hook_not_executable', hook_path), file=sys.stderr)
+        print(msg("hook_not_executable", hook_path), file=sys.stderr)
         return
 
     # 環境変数を設定
     env = os.environ.copy()
-    env.update({
-        'WT_WORKTREE_PATH': str(worktree_path),
-        'WT_WORKTREE_NAME': work_name,
-        'WT_BASE_DIR': str(base_dir),
-        'WT_BRANCH': branch or work_name,
-        'WT_ACTION': 'add'
-    })
-
-    print(msg('running_hook', hook_path))
+    env.update(
+        {
+            "WT_WORKTREE_PATH": str(worktree_path),
+            "WT_WORKTREE_NAME": work_name,
+            "WT_BASE_DIR": str(base_dir),
+            "WT_BRANCH": branch or work_name,
+            "WT_ACTION": "add",
+        }
+    )
+
+    print(msg("running_hook", hook_path), file=sys.stderr)
     try:
         result = subprocess.run(
             [str(hook_path)],
             cwd=worktree_path,  # worktree 内で実行
             env=env,
-            check=False
+            stdout=sys.stderr,  # stdout を stderr にリダイレクト (cd 連携のため)
+            stderr=sys.stderr,
+            check=False,
         )
 
         if result.returncode != 0:
-            print(msg('hook_failed', result.returncode), file=sys.stderr)
+            print(msg("hook_failed", result.returncode), file=sys.stderr)
     except Exception as e:
-        print(msg('error', str(e)), file=sys.stderr)
-
+        print(msg("error", str(e)), file=sys.stderr)
 
-def cmd_add(args: list[str]):
-    """wt add <work_name> [<base_branch>] - Add a worktree"""
-    if len(args) < 1:
-        print(msg('usage_add'), file=sys.stderr)
-        sys.exit(1)
 
-    base_dir = find_base_dir()
+def add_worktree(
+    work_name: str,
+    branch_to_use: str = None,
+    new_branch_base: str = None,
+    base_dir: Path = None,
+) -> Path:
+    """Core logic to add a worktree, reused by cmd_add and cmd_stash"""
+    if not base_dir:
+        base_dir = find_base_dir()
     if not base_dir:
-        print(msg('error', msg('base_not_found')), file=sys.stderr)
-        print(msg('run_in_wt_dir'), file=sys.stderr)
+        print(msg("error", msg("base_not_found")), file=sys.stderr)
+        print(msg("run_in_wt_dir"), file=sys.stderr)
         sys.exit(1)
 
-    # --alias オプションをチェック
-    alias_name = None
-    if '--alias' in args:
-        alias_index = args.index('--alias')
-        if alias_index + 1 < len(args):
-            alias_name = args[alias_index + 1]
-            # --alias とその値を削除
-            args.pop(alias_index)
-            args.pop(alias_index)
-        else:
-            print(msg('error', 'Missing alias name after --alias'), file=sys.stderr)
-            sys.exit(1)
-
-    work_name = args[0]
+    # 設定を読み込む
+    config = load_config(base_dir)
+    worktrees_dir_name = config.get("worktrees_dir", ".worktrees")
+    worktrees_dir = base_dir / worktrees_dir_name
+    worktrees_dir.mkdir(exist_ok=True)
 
-    # worktree のパスを決定（_base の親ディレクトリに作成）
-    worktree_path = base_dir.parent / work_name
+    # worktree のパスを決定
+    worktree_path = worktrees_dir / work_name
 
     if worktree_path.exists():
-        print(msg('error', msg('already_exists', worktree_path)), file=sys.stderr)
+        print(msg("error", msg("already_exists", worktree_path)), file=sys.stderr)
         sys.exit(1)
 
     # ブランチを最新に更新
-    print(msg('fetching'))
+    print(msg("fetching"), file=sys.stderr)
     run_command(["git", "fetch", "--all"], cwd=base_dir)
 
-    # _base/ を base branch の最新に更新
-    # 現在のブランチを取得
+    # 本体 (main) を base branch の最新に更新
     result = run_command(
-        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
-        cwd=base_dir,
-        check=False
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=base_dir, check=False
     )
     if result.returncode == 0:
         current_branch = result.stdout.strip()
-        # リモートブランチが存在する場合は pull
         result = run_command(
             ["git", "rev-parse", "--verify", f"origin/{current_branch}"],
             cwd=base_dir,
-            check=False
+            check=False,
         )
         if result.returncode == 0:
-            run_command(["git", "pull", "origin", current_branch], cwd=base_dir, check=False)
-
-    # ブランチ名が指定されている場合は既存ブランチをチェックアウト
-    # 指定されていない場合は新しいブランチを作成
-    branch_name = None
-    if len(args) >= 2:
-        # 既存ブランチをチェックアウト
-        branch_name = args[1]
-        print(msg('creating_worktree', worktree_path))
+            run_command(
+                ["git", "pull", "origin", current_branch], cwd=base_dir, check=False
+            )
+
+    # ブランチ作成/チェックアウト
+    final_branch_name = None
+    if new_branch_base:
+        # 新しいブランチをベースから作成
+        final_branch_name = work_name
+        print(
+            msg("creating_branch", final_branch_name, new_branch_base), file=sys.stderr
+        )
         result = run_command(
-            ["git", "worktree", "add", str(worktree_path), branch_name],
+            [
+                "git",
+                "worktree",
+                "add",
+                "-b",
+                final_branch_name,
+                str(worktree_path),
+                new_branch_base,
+            ],
             cwd=base_dir,
-            check=False
+            check=False,
+        )
+    elif branch_to_use:
+        # 指定されたブランチをチェックアウト
+        final_branch_name = branch_to_use
+        print(msg("creating_worktree", worktree_path), file=sys.stderr)
+        result = run_command(
+            ["git", "worktree", "add", str(worktree_path), final_branch_name],
+            cwd=base_dir,
+            check=False,
         )
     else:
+        # 自動判定
         # ブランチ名として work_name を使用
-        branch_name = work_name
+        final_branch_name = work_name
 
-        # ローカルまたはリモートにブランチが既に存在するかチェック
         check_local = run_command(
-            ["git", "rev-parse", "--verify", branch_name],
+            ["git", "rev-parse", "--verify", final_branch_name],
             cwd=base_dir,
-            check=False
+            check=False,
         )
         check_remote = run_command(
-            ["git", "rev-parse", "--verify", f"origin/{branch_name}"],
+            ["git", "rev-parse", "--verify", f"origin/{final_branch_name}"],
             cwd=base_dir,
-            check=False
+            check=False,
         )
 
         if check_local.returncode == 0 or check_remote.returncode == 0:
-            # 既存ブランチを使用
             if check_remote.returncode == 0:
-                # リモートブランチが存在する場合
-                print(msg('creating_worktree', worktree_path))
+                print(msg("creating_worktree", worktree_path), file=sys.stderr)
                 result = run_command(
-                    ["git", "worktree", "add", str(worktree_path), f"origin/{branch_name}"],
+                    [
+                        "git",
+                        "worktree",
+                        "add",
+                        str(worktree_path),
+                        f"origin/{final_branch_name}",
+                    ],
                     cwd=base_dir,
-                    check=False
+                    check=False,
                 )
             else:
-                # ローカルブランチのみ存在する場合
-                print(msg('creating_worktree', worktree_path))
+                print(msg("creating_worktree", worktree_path), file=sys.stderr)
                 result = run_command(
-                    ["git", "worktree", "add", str(worktree_path), branch_name],
+                    ["git", "worktree", "add", str(worktree_path), final_branch_name],
                     cwd=base_dir,
-                    check=False
+                    check=False,
                 )
         else:
-            # 新しいブランチを作成
-            # デフォルトブランチを探す（origin/main または origin/master）
-            result = run_command(
+            # デフォルトブランチを探す
+            result_sym = run_command(
                 ["git", "symbolic-ref", "refs/remotes/origin/HEAD", "--short"],
                 cwd=base_dir,
-                check=False
+                check=False,
             )
 
-            if result.returncode == 0 and result.stdout.strip():
-                base_branch = result.stdout.strip()
+            detected_base = None
+            if result_sym.returncode == 0 and result_sym.stdout.strip():
+                detected_base = result_sym.stdout.strip()
             else:
-                # symbolic-ref が失敗した場合は手動でチェック
-                result_main = run_command(
-                    ["git", "rev-parse", "--verify", "origin/main"],
-                    cwd=base_dir,
-                    check=False
-                )
-                result_master = run_command(
-                    ["git", "rev-parse", "--verify", "origin/master"],
-                    cwd=base_dir,
-                    check=False
-                )
-
-                if result_main.returncode == 0:
-                    base_branch = "origin/main"
-                elif result_master.returncode == 0:
-                    base_branch = "origin/master"
-                else:
-                    print(msg('error', msg('default_branch_not_found')), file=sys.stderr)
+                # remote/local main/master の順に探す
+                for b in ["origin/main", "origin/master", "main", "master"]:
+                    if (
+                        run_command(
+                            ["git", "rev-parse", "--verify", b],
+                            cwd=base_dir,
+                            check=False,
+                        ).returncode
+                        == 0
+                    ):
+                        detected_base = b
+                        break
+
+                if not detected_base:
+                    # 最終手段として現在のブランチを使用
+                    res_curr = run_command(
+                        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                        cwd=base_dir,
+                        check=False,
+                    )
+                    if res_curr.returncode == 0:
+                        detected_base = res_curr.stdout.strip()
+
+                if not detected_base:
+                    print(
+                        msg("error", msg("default_branch_not_found")), file=sys.stderr
+                    )
                     sys.exit(1)
 
-            print(msg('creating_branch', base_branch, work_name))
+            print(
+                msg("creating_branch", final_branch_name, detected_base),
+                file=sys.stderr,
+            )
             result = run_command(
-                ["git", "worktree", "add", "-b", work_name, str(worktree_path), base_branch],
+                [
+                    "git",
+                    "worktree",
+                    "add",
+                    "-b",
+                    final_branch_name,
+                    str(worktree_path),
+                    detected_base,
+                ],
                 cwd=base_dir,
-                check=False
+                check=False,
             )
 
     if result.returncode == 0:
-        print(msg('completed_worktree', worktree_path))
-
-        # エイリアスを作成
-        if alias_name:
-            alias_path = base_dir.parent / alias_name
-
-            # 既存かどうかをチェック
-            is_updating = alias_path.is_symlink()
-
-            # 既存のシンボリックリンクを削除
-            if alias_path.is_symlink():
-                alias_path.unlink()
-            elif alias_path.exists():
-                # シンボリックリンクではないファイル/ディレクトリが存在
-                print(msg('error', f'{alias_name} exists but is not a symlink'), file=sys.stderr)
-                # post-add hook を実行
-                run_post_add_hook(worktree_path, work_name, base_dir, branch_name)
-                sys.exit(0)  # worktree は作成できたので正常終了
-
-            # シンボリックリンクを作成
-            alias_path.symlink_to(worktree_path, target_is_directory=True)
-
-            if is_updating:
-                print(msg('alias_updated', alias_name, work_name))
-            else:
-                print(msg('alias_created', alias_name, work_name))
-
-        # post-add hook を実行
-        run_post_add_hook(worktree_path, work_name, base_dir, branch_name)
+        # 自動同期
+        if config.get("auto_copy_on_add"):
+            sync_files = config.get("sync_files", [])
+            for file_name in sync_files:
+                src = base_dir / file_name
+                dst = worktree_path / file_name
+                if src.exists():
+                    print(msg("syncing", src, dst), file=sys.stderr)
+                    import shutil
+
+                    shutil.copy2(src, dst)
+
+        # post-add hook
+        run_post_add_hook(worktree_path, work_name, base_dir, final_branch_name)
+        return worktree_path
     else:
-        # エラーメッセージを表示
         if result.stderr:
             print(result.stderr, file=sys.stderr)
         sys.exit(1)
 
 
+def cmd_add(args: list[str]):
+    """wt add <work_name> [<base_branch>] - Add a worktree"""
+    if len(args) < 1:
+        print(msg("usage_add"), file=sys.stderr)
+        sys.exit(1)
+
+    work_name = args[0]
+    branch_to_use = args[1] if len(args) >= 2 else None
+
+    add_worktree(work_name, branch_to_use=branch_to_use)
+
+
+def cmd_stash(args: list[str]):
+    """wt stash <work_name> [<base_branch>] - Stash changes and move to new worktree"""
+    if len(args) < 1:
+        print(msg("usage_stash"), file=sys.stderr)
+        sys.exit(1)
+
+    base_dir = find_base_dir()
+    if not base_dir:
+        print(msg("error", msg("base_not_found")), file=sys.stderr)
+        sys.exit(1)
+
+    # 変更があるかチェック
+    result = run_command(["git", "status", "--porcelain"], cwd=base_dir, check=False)
+    has_changes = bool(result.stdout.strip())
+
+    if has_changes:
+        print(msg("stashing_changes"), file=sys.stderr)
+        # stash する
+        # -u (include untracked)
+        run_command(
+            ["git", "stash", "push", "-u", "-m", f"easy-worktree stash for {args[0]}"],
+            cwd=base_dir,
+        )
+    else:
+        print(msg("nothing_to_stash"), file=sys.stderr)
+
+    # 新しい worktree を作成
+    work_name = args[0]
+
+    # base_branch が指定されていない場合は現在のブランチをベースにする
+    # 指定されている場合はそれをベースにする
+    new_branch_base = args[1] if len(args) >= 2 else None
+    if not new_branch_base:
+        res = run_command(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=base_dir, check=False
+        )
+        if res.returncode == 0:
+            new_branch_base = res.stdout.strip()
+
+    # aliasはサポートしないでおく（とりあえずシンプルに）
+    # wt stash は常に新しいブランチを作成する振る舞いにする
+    wt_path = add_worktree(
+        work_name, new_branch_base=new_branch_base, base_dir=base_dir
+    )
+
+    if has_changes and wt_path:
+        print(msg("popping_stash"), file=sys.stderr)
+        # 新しい worktree で stash pop
+        run_command(["git", "stash", "pop"], cwd=wt_path)
+
+
+def cmd_pr(args: list[str]):
+    """wt pr <add|co> <number> - Pull Request management"""
+    if len(args) < 2:
+        print(msg("usage_pr"), file=sys.stderr)
+        sys.exit(1)
+
+    subcommand = args[0]
+    pr_number = args[1]
+
+    # Ensure pr_number is a digit
+    if not pr_number.isdigit():
+        print(msg("error", f"PR number must be a digit: {pr_number}"), file=sys.stderr)
+        sys.exit(1)
+
+    base_dir = find_base_dir()
+    if not base_dir:
+        print(msg("error", msg("base_not_found")), file=sys.stderr)
+        sys.exit(1)
+
+    if subcommand == "add":
+        # Check if gh command exists
+        if shutil.which("gh") is None:
+            print(
+                msg("error", "GitHub CLI (gh) is required for this command"),
+                file=sys.stderr,
+            )
+            sys.exit(1)
+
+        print(f"Verifying PR #{pr_number}...", file=sys.stderr)
+        # Verify PR exists using gh
+        verify_cmd = ["gh", "pr", "view", pr_number, "--json", "number"]
+        result = run_command(verify_cmd, cwd=base_dir, check=False)
+        if result.returncode != 0:
+            print(
+                msg("error", f"PR #{pr_number} not found (or access denied)"),
+                file=sys.stderr,
+            )
+            sys.exit(1)
+
+        branch_name = f"pr-{pr_number}"
+        worktree_name = f"pr@{pr_number}"
+
+        print(f"Fetching PR #{pr_number} contents...", file=sys.stderr)
+        # Fetch PR head to a local branch
+        # git fetch origin pull/ID/head:local-branch
+        fetch_cmd = ["git", "fetch", "origin", f"pull/{pr_number}/head:{branch_name}"]
+        # We might want to handle case where origin doesn't exist or pull ref is different,
+        # but origin pull/ID/head is standard for GitHub.
+        run_command(fetch_cmd, cwd=base_dir)
+
+        print(f"Creating worktree {worktree_name}...", file=sys.stderr)
+        add_worktree(worktree_name, branch_to_use=branch_name, base_dir=base_dir)
+
+    elif subcommand == "co":
+        # Just a shortcut for checkout pr@<number>
+        cmd_checkout([f"pr@{pr_number}"])
+    else:
+        print(msg("usage_pr"), file=sys.stderr)
+        sys.exit(1)
+
+
 def get_worktree_info(base_dir: Path) -> list[dict]:
     """worktree の詳細情報を取得"""
-    result = run_command(
-        ["git", "worktree", "list", "--porcelain"],
-        cwd=base_dir
-    )
+    result = run_command(["git", "worktree", "list", "--porcelain"], cwd=base_dir)
 
     worktrees = []
     current = {}
 
-    for line in result.stdout.strip().split('\n'):
+    for line in result.stdout.strip().split("\n"):
         if not line:
             if current:
                 worktrees.append(current)
                 current = {}
             continue
 
-        if line.startswith('worktree '):
-            current['path'] = line.split(' ', 1)[1]
-        elif line.startswith('HEAD '):
-            current['head'] = line.split(' ', 1)[1]
-        elif line.startswith('branch '):
-            current['branch'] = line.split(' ', 1)[1].replace('refs/heads/', '')
-        elif line.startswith('detached'):
-            current['branch'] = 'DETACHED'
+        if line.startswith("worktree "):
+            current["path"] = line.split(" ", 1)[1]
+        elif line.startswith("HEAD "):
+            current["head"] = line.split(" ", 1)[1]
+        elif line.startswith("branch "):
+            current["branch"] = line.split(" ", 1)[1].replace("refs/heads/", "")
+        elif line.startswith("detached"):
+            current["branch"] = "DETACHED"
 
     if current:
         worktrees.append(current)
 
     # 各 worktree の詳細情報を取得
     for wt in worktrees:
-        path = Path(wt['path'])
+        path = Path(wt["path"])
 
         # 作成日時（ディレクトリの作成時刻）
         if path.exists():
             stat_info = path.stat()
-            wt['created'] = datetime.fromtimestamp(stat_info.st_ctime)
+            wt["created"] = datetime.fromtimestamp(stat_info.st_ctime)
 
         # 最終コミット日時
         result = run_command(
-            ["git", "log", "-1", "--format=%ct", wt.get('head', 'HEAD')],
+            ["git", "log", "-1", "--format=%ct", wt.get("head", "HEAD")],
             cwd=base_dir,
-            check=False
+            check=False,
         )
         if result.returncode == 0 and result.stdout.strip():
-            wt['last_commit'] = datetime.fromtimestamp(int(result.stdout.strip()))
+            wt["last_commit"] = datetime.fromtimestamp(int(result.stdout.strip()))
 
         # git status（変更があるか）
-        result = run_command(
-            ["git", "status", "--porcelain"],
-            cwd=path,
-            check=False
+        result = run_command(["git", "status", "--porcelain"], cwd=path, check=False)
+        wt["is_clean"] = result.returncode == 0 and not result.stdout.strip()
+        wt["has_untracked"] = "??" in result.stdout
+
+        # Diff stats取得
+        result_diff = run_command(
+            ["git", "diff", "HEAD", "--shortstat"], cwd=path, check=False
         )
-        wt['is_clean'] = result.returncode == 0 and not result.stdout.strip()
+
+        insertions = 0
+        deletions = 0
+        if result_diff.returncode == 0 and result_diff.stdout.strip():
+            out = result_diff.stdout.strip()
+            m_plus = re.search(r"(\d+) insertion", out)
+            m_minus = re.search(r"(\d+) deletion", out)
+            if m_plus:
+                insertions = int(m_plus.group(1))
+            if m_minus:
+                deletions = int(m_minus.group(1))
+
+        wt["insertions"] = insertions
+        wt["deletions"] = deletions
 
     return worktrees
 
+    if result.returncode == 0:
+        return result.stdout.strip()
+    return ""
+
+
+def get_pr_info(branch: str, cwd: Path = None) -> str:
+    """Get rich GitHub PR information for the branch"""
+    if not branch or branch == "HEAD" or branch == "DETACHED":
+        return ""
+
+    # Check if gh command exists
+    if shutil.which("gh") is None:
+        return ""
+
+    import json
+
+    cmd = [
+        "gh",
+        "pr",
+        "list",
+        "--head",
+        branch,
+        "--state",
+        "all",
+        "--json",
+        "state,isDraft,url,createdAt,number",
+    ]
+    result = run_command(cmd, cwd=cwd, check=False)
+
+    if result.returncode != 0 or not result.stdout.strip():
+        return ""
+
+    try:
+        prs = json.loads(result.stdout)
+        if not prs:
+            return ""
+
+        pr = prs[0]
+        state = pr["state"]
+        is_draft = pr["isDraft"]
+        url = pr["url"]
+        created_at_str = pr["createdAt"]
+        number = pr["number"]
+
+        # Parse created_at
+        # ISO format: 2024-03-20T12:00:00Z
+        try:
+            # Localize to local timezone
+            dt_aware = datetime.fromisoformat(created_at_str.replace("Z", "+00:00"))
+            dt_local = dt_aware.astimezone().replace(tzinfo=None)
+            rel_time = get_relative_time(dt_local)
+        except Exception:
+            rel_time = "N/A"
+
+        # Symbols and Colors
+        GREEN = "\033[32m"
+        GRAY = "\033[90m"
+        MAGENTA = "\033[35m"
+        RED = "\033[31m"
+        RESET = "\033[0m"
+
+        if is_draft:
+            symbol = f"{GRAY}◌{RESET}"
+        elif state == "OPEN":
+            symbol = f"{GREEN}●{RESET}"
+        elif state == "MERGED":
+            symbol = f"{MAGENTA}✔{RESET}"
+        else:  # CLOSED
+            symbol = f"{RED}✘{RESET}"
+
+        # Hyperlink for #NUMBER
+        # ANSI sequence for hyperlink: ESC ] 8 ; ; URL ESC \ TEXT ESC ] 8 ; ; ESC \
+        link_start = f"\x1b]8;;{url}\x1b\\"
+        link_end = "\x1b]8;;\x1b\\"
+
+        return f"{symbol} {link_start}#{number}{link_end} ({rel_time})"
+
+    except Exception:
+        return ""
+
+
+def get_relative_time(dt: datetime) -> str:
+    """Get relative time string"""
+    if not dt:
+        return "N/A"
+
+    now = datetime.now()
+    diff = now - dt
+
+    seconds = diff.total_seconds()
+    days = diff.days
+
+    if days < 0:
+        return "just now"
+
+    if days == 0:
+        if seconds < 60:
+            return "just now"
+        if seconds < 3600:
+            minutes = int(seconds / 60)
+            return f"{minutes}m ago"
+        hours = int(seconds / 3600)
+        return f"{hours}h ago"
+
+    if days == 1:
+        return "yesterday"
+
+    if days < 30:
+        return f"{days}d ago"
+
+    if days < 365:
+        months = int(days / 30)
+        return f"{months}mo ago"
+
+    years = int(days / 365)
+    return f"{years}y ago"
+
 
 def cmd_list(args: list[str]):
     """wt list - List worktrees"""
     base_dir = find_base_dir()
     if not base_dir:
-        print(msg('error', msg('base_not_found')), file=sys.stderr)
+        print(msg("error", msg("base_not_found")), file=sys.stderr)
         sys.exit(1)
 
-    # --verbose または --sort オプションがある場合は詳細表示
-    verbose = '--verbose' in args or '-v' in args
-    sort_by = None
+    # --quiet / -q オプション（xargs 用）
+    quiet = "--quiet" in args or "-q" in args
+    show_pr = "--pr" in args
 
-    # ソートオプションを取得
-    for i, arg in enumerate(args):
-        if arg == '--sort' and i + 1 < len(args):
-            sort_by = args[i + 1]
+    worktrees = get_worktree_info(base_dir)
 
-    if not verbose and not sort_by:
-        # 通常の git worktree list を実行
-        result = run_command(["git", "worktree", "list"] + args, cwd=base_dir)
-        print(result.stdout, end='')
+    # ソート: 作成日時の降順（最新が上）
+    worktrees.sort(key=lambda x: x.get("created", datetime.min), reverse=True)
+
+    # PR infoの取得
+    if show_pr:
+        for wt in worktrees:
+            branch = wt.get("branch", "")
+            if branch:
+                wt["pr_info"] = get_pr_info(branch, cwd=base_dir)
+
+    # 相対時間の計算
+    for wt in worktrees:
+        wt["relative_time"] = get_relative_time(wt.get("created"))
+
+    if quiet:
+        for wt in worktrees:
+            print(
+                Path(wt["path"]).name
+                if Path(wt["path"]).name != base_dir.name
+                else "main"
+            )
         return
 
-    # 詳細情報を取得
-    worktrees = get_worktree_info(base_dir)
+    # "Changes" カラムの表示文字列作成
+    GREEN = "\033[32m"
+    RED = "\033[31m"
+    GRAY = "\033[90m"
+    RESET = "\033[0m"
 
-    # ソート
-    if sort_by == 'age' or sort_by == 'created':
-        worktrees.sort(key=lambda x: x.get('created', datetime.min))
-    elif sort_by == 'name':
-        worktrees.sort(key=lambda x: Path(x['path']).name)
+    for wt in worktrees:
+        plus = wt.get("insertions", 0)
+        minus = wt.get("deletions", 0)
+        untracked = wt.get("has_untracked", False)
+
+        parts = []
+        clean_parts = []
+        if plus > 0:
+            parts.append(f"{GREEN}+{plus}{RESET}")
+            clean_parts.append(f"+{plus}")
+        if minus > 0:
+            parts.append(f"{RED}-{minus}{RESET}")
+            clean_parts.append(f"-{minus}")
+        if untracked:
+            parts.append(f"{GRAY}??{RESET}")
+            clean_parts.append("??")
+
+        if not parts:
+            wt["changes_display"] = "-"
+            wt["changes_clean_len"] = 1
+        else:
+            wt["changes_display"] = " ".join(parts)
+            wt["changes_clean_len"] = len(" ".join(clean_parts))
+
+    # カラム幅の計算
+    name_w = (
+        max(
+            len(msg("worktree_name")),
+            max((len(Path(wt["path"]).name) for wt in worktrees), default=0),
+        )
+        + 2
+    )
+    branch_w = (
+        max(
+            len(msg("branch_name")),
+            max((len(wt.get("branch", "N/A")) for wt in worktrees), default=0),
+        )
+        + 2
+    )
+    time_w = (
+        max(
+            len("Created"),
+            max((len(wt.get("relative_time", "")) for wt in worktrees), default=0),
+        )
+        + 2
+    )
+    status_w = (
+        max(
+            len(msg("changes_label")),
+            max((wt["changes_clean_len"] for wt in worktrees), default=0),
+        )
+        + 2
+    )
+    pr_w = 0
+    if show_pr:
+        # PR info contains ANSI codes, so calculate real length
+        import re
+
+        # More robust ANSI escape regex including hyperlinks
+        ansi_escape = re.compile(
+            r"""
+            \x1B(?:
+                [@-Z\\-_]
+            |
+                \[[0-9]*[ -/]*[@-~]
+            |
+                \][0-9]*;.*?(\x1B\\|\x07)
+            )
+        """,
+            re.VERBOSE,
+        )
 
-    # 表示
-    if verbose:
-        # ヘッダー
-        print(f"{msg('worktree_name'):<30} {msg('branch_name'):<25} {msg('created_at'):<20} {msg('last_commit'):<20} {msg('status_label')}")
-        print("-" * 110)
+        def clean_len(s):
+            return len(ansi_escape.sub("", s))
 
-        for wt in worktrees:
-            name = Path(wt['path']).name
-            branch = wt.get('branch', 'N/A')
-            created = wt.get('created').strftime('%Y-%m-%d %H:%M') if wt.get('created') else 'N/A'
-            last_commit = wt.get('last_commit').strftime('%Y-%m-%d %H:%M') if wt.get('last_commit') else 'N/A'
-            status = 'clean' if wt.get('is_clean') else 'modified'
+        pr_w = (
+            max(
+                3,
+                max((clean_len(wt.get("pr_info", "")) for wt in worktrees), default=0),
+            )
+            + 2
+        )
+
+    # ヘッダー (色付き)
+    CYAN = "\033[36m"
+    RESET = "\033[0m"
+    BOLD = "\033[1m"
 
-            print(f"{name:<30} {branch:<25} {created:<20} {last_commit:<20} {status}")
+    base_header = f"{msg('worktree_name'):<{name_w}} {msg('branch_name'):<{branch_w}} {'Created':<{time_w}} {msg('changes_label'):<{status_w}}"
+    if show_pr:
+        header = f"{BOLD}{base_header}   PR{RESET}"
+        separator_len = len(base_header) + 5
     else:
-        # 通常表示（ソートのみ）
-        for wt in worktrees:
-            print(wt['path'])
+        header = f"{BOLD}{base_header.rstrip()}{RESET}"
+        separator_len = len(base_header.rstrip())
+
+    print(header)
+    print("-" * separator_len)
+
+    for wt in worktrees:
+        path = Path(wt["path"])
+        name_display = path.name if path != base_dir else f"{CYAN}(main){RESET}"
+        name_clean_len = len(path.name) if path != base_dir else 6
+        name_padding = " " * (name_w - name_clean_len)
+
+        branch = wt.get("branch", "N/A")
+        rel_time = wt.get("relative_time", "N/A")
+        changes_display = wt.get("changes_display", "no changes")
+        changes_clean_len = wt.get("changes_clean_len", 1)
+
+        # ANSI コード分を補正して表示
+        changes_padding = " " * (status_w - changes_clean_len)
+
+        print(
+            f"{name_display}{name_padding} {branch:<{branch_w}} {rel_time:<{time_w}} {changes_display}{changes_padding}",
+            end="",
+        )
+        if show_pr:
+            print(f"   {wt.get('pr_info', '')}", end="")
+        print()
 
 
 def cmd_remove(args: list[str]):
     """wt rm/remove <work_name> - Remove a worktree"""
     if len(args) < 1:
-        print(msg('usage_rm'), file=sys.stderr)
+        print(msg("usage_rm"), file=sys.stderr)
         sys.exit(1)
 
     base_dir = find_base_dir()
     if not base_dir:
-        print(msg('error', msg('base_not_found')), file=sys.stderr)
+        print(msg("error", msg("base_not_found")), file=sys.stderr)
         sys.exit(1)
 
-    work_name = args[0]
+    # Parse flags and find worktree name
+    flags = []
+    work_name = None
+    for arg in args:
+        if arg in ["-f", "--force"]:
+            flags.append(arg)
+        elif not work_name:
+            work_name = arg
+        else:
+            # Additional non-flag arguments are currently ignored or could be treated as error
+            pass
+
+    if not work_name:
+        print(msg("usage_rm"), file=sys.stderr)
+        sys.exit(1)
 
     # worktree を削除
-    print(msg('removing_worktree', work_name))
+    print(msg("removing_worktree", work_name), file=sys.stderr)
     result = run_command(
-        ["git", "worktree", "remove", work_name],
-        cwd=base_dir,
-        check=False
+        ["git", "worktree", "remove"] + flags + [work_name], cwd=base_dir, check=False
     )
 
     if result.returncode == 0:
-        print(msg('completed_remove', work_name))
+        pass
     else:
         if result.stderr:
             print(result.stderr, file=sys.stderr)
@@ -893,84 +1323,195 @@ def cmd_remove(args: list[str]):
 
 
 def cmd_clean(args: list[str]):
-    """wt clean - Remove old/unused worktrees"""
+    """wt clean - Remove old/unused/merged worktrees"""
     base_dir = find_base_dir()
     if not base_dir:
-        print(msg('error', msg('base_not_found')), file=sys.stderr)
+        print(msg("error", msg("base_not_found")), file=sys.stderr)
         sys.exit(1)
 
     # オプションを解析
-    dry_run = '--dry-run' in args
-    clean_all = '--all' in args
+    # オプションを解析
+    clean_all = "--all" in args
+    clean_merged = "--merged" in args
+    clean_closed = "--closed" in args
     days = None
 
     for i, arg in enumerate(args):
-        if arg == '--days' and i + 1 < len(args):
+        if arg == "--days" and i + 1 < len(args):
             try:
                 days = int(args[i + 1])
             except ValueError:
-                print(msg('error', 'Invalid days value'), file=sys.stderr)
+                print(msg("error", "Invalid days value"), file=sys.stderr)
                 sys.exit(1)
 
     # worktree 情報を取得
     worktrees = get_worktree_info(base_dir)
 
     # エイリアスで使われている worktree を取得
-    parent_dir = base_dir.parent
+    # 今回の構成では root 内のシンボリックリンクを探す
     aliased_worktrees = set()
-    for item in parent_dir.iterdir():
-        if item.is_symlink() and item.name != '_base':
-            target = item.resolve()
-            aliased_worktrees.add(target)
+    for item in base_dir.iterdir():
+        if item.is_symlink():
+            try:
+                target = item.resolve()
+                aliased_worktrees.add(target)
+            except Exception:
+                pass
+
+    # マージ済みブランチを取得
+    merged_branches = set()
+    merged_pr_branches = set()
+
+    # デフォルトブランチを取得して、それに対してマージされているかを確認
+    default_branch = get_default_branch(base_dir)
+    default_branch_sha = None
+    if default_branch:
+        res_sha = run_command(
+            ["git", "rev-parse", default_branch], cwd=base_dir, check=False
+        )
+        if res_sha.returncode == 0:
+            default_branch_sha = res_sha.stdout.strip()
 
-    # 削除対象を抽出（_baseは除外）
+    if clean_merged and default_branch:
+        # Local merged branches (merged into default_branch)
+        result = run_command(
+            ["git", "branch", "--merged", default_branch], cwd=base_dir, check=False
+        )
+        if result.returncode == 0:
+            for line in result.stdout.split("\n"):
+                # Extract branch name, removing '*', '+', and whitespace
+                line = line.strip()
+                if line.startswith("* ") or line.startswith("+ "):
+                    line = line[2:].strip()
+                if line:
+                    merged_branches.add(line)
+
+        # GitHub merged PRs
+        if shutil.which("gh"):
+            import json
+
+            # Get last 100 merged PRs
+            pr_cmd = [
+                "gh",
+                "pr",
+                "list",
+                "--state",
+                "merged",
+                "--limit",
+                "100",
+                "--json",
+                "headRefName",
+            ]
+            pr_res = run_command(pr_cmd, cwd=base_dir, check=False)
+            if pr_res.returncode == 0:
+                try:
+                    pr_data = json.loads(pr_res.stdout)
+                    for pr in pr_data:
+                        merged_pr_branches.add(pr["headRefName"])
+                except:
+                    pass
+
+    # Closed PRs
+    closed_pr_branches = set()
+    if clean_closed:
+        if shutil.which("gh"):
+            import json
+
+            # Get last 100 closed PRs
+            pr_cmd = [
+                "gh",
+                "pr",
+                "list",
+                "--state",
+                "closed",
+                "--limit",
+                "100",
+                "--json",
+                "headRefName",
+            ]
+            pr_res = run_command(pr_cmd, cwd=base_dir, check=False)
+            if pr_res.returncode == 0:
+                try:
+                    pr_data = json.loads(pr_res.stdout)
+                    for pr in pr_data:
+                        closed_pr_branches.add(pr["headRefName"])
+                except:
+                    pass
+
+    # 削除対象を抽出
     targets = []
     now = datetime.now()
 
     for wt in worktrees:
-        path = Path(wt['path'])
+        path = Path(wt["path"])
 
-        # _base は除外
-        if path.name == '_base':
+        # base (git root) は除外
+        if path == base_dir:
             continue
 
         # エイリアスで使われている worktree は除外
         if path in aliased_worktrees:
             continue
 
-        # clean状態のものだけが対象
-        if not wt.get('is_clean'):
-            continue
-
-        # 日数指定がある場合はチェック
-        if days is not None:
-            created = wt.get('created')
-            if created:
-                age_days = (now - created).days
-                if age_days < days:
+        reason = None
+        # マージ済みの場合は無条件で対象（ただし dirty でないこと）
+        is_merged = (
+            wt.get("branch") in merged_branches
+            or wt.get("branch") in merged_pr_branches
+        )
+        if clean_merged and is_merged:
+            # Check safeguard: if branch points to same SHA as default branch and NOT in merged_pr_branches
+            # it might be a new branch that hasn't diverged yet.
+            if default_branch_sha and wt.get("branch") not in merged_pr_branches:
+                wt_sha = run_command(
+                    ["git", "rev-parse", wt.get("branch")], cwd=base_dir, check=False
+                ).stdout.strip()
+                if wt_sha == default_branch_sha:
+                    # Skip deletion for fresh branches
                     continue
 
-        targets.append(wt)
+            if wt.get("is_clean"):
+                reason = "merged"
+
+        is_closed = wt.get("branch") in closed_pr_branches
+        if not reason and clean_closed and is_closed:
+            if wt.get("is_clean"):
+                reason = "closed"
+
+        # 通常のクリーンアップ対象
+        if not reason and wt.get("is_clean"):
+            if days is not None:
+                created = wt.get("created")
+                if created:
+                    age_days = (now - created).days
+                    if age_days >= days:
+                        reason = f"older than {days} days"
+            elif clean_all:
+                reason = "clean"
+
+        if reason:
+            wt["reason"] = reason
+            targets.append(wt)
 
     if not targets:
-        print(msg('no_clean_targets'))
+        print(msg("no_clean_targets"), file=sys.stderr)
         return
 
     # 削除対象を表示
     for wt in targets:
-        path = Path(wt['path'])
-        created = wt.get('created').strftime('%Y-%m-%d %H:%M') if wt.get('created') else 'N/A'
-        print(msg('clean_target', path.name, created))
-
-    if dry_run:
-        print(f"\n(--dry-run mode, no changes made)")
-        return
+        path = Path(wt["path"])
+        created = (
+            wt.get("created").strftime("%Y-%m-%d %H:%M") if wt.get("created") else "N/A"
+        )
+        print(
+            f"{path.name} (reason: {wt['reason']}, created: {created})", file=sys.stderr
+        )
 
     # 確認
     if not clean_all:
         try:
-            response = input(msg('clean_confirm', len(targets)))
-            if response.lower() not in ['y', 'yes']:
+            response = input(msg("clean_confirm", len(targets)))
+            if response.lower() not in ["y", "yes"]:
                 print("Cancelled.")
                 return
         except (EOFError, KeyboardInterrupt):
@@ -979,151 +1520,119 @@ def cmd_clean(args: list[str]):
 
     # 削除実行
     for wt in targets:
-        path = Path(wt['path'])
-        print(msg('removing_worktree', path.name))
+        path = Path(wt["path"])
+        print(msg("removing_worktree", path.name), file=sys.stderr)
         result = run_command(
-            ["git", "worktree", "remove", str(path)],
-            cwd=base_dir,
-            check=False
+            ["git", "worktree", "remove", str(path)], cwd=base_dir, check=False
         )
 
         if result.returncode == 0:
-            print(msg('completed_remove', path.name))
+            pass
         else:
             if result.stderr:
                 print(result.stderr, file=sys.stderr)
 
 
-def cmd_alias(args: list[str]):
-    """wt alias - Manage worktree aliases"""
+def cmd_sync(args: list[str]):
+    """wt sync [files...] [--from <name>] [--to <name>] - Sync files between worktrees"""
     base_dir = find_base_dir()
     if not base_dir:
-        print(msg('error', msg('base_not_found')), file=sys.stderr)
+        print(msg("error", msg("base_not_found")), file=sys.stderr)
         sys.exit(1)
 
-    parent_dir = base_dir.parent
-
-    # --list オプション
-    if '--list' in args or len(args) == 0:
-        # エイリアス一覧を表示（シンボリックリンクを探す）
-        aliases = []
-        for item in parent_dir.iterdir():
-            if item.is_symlink() and item.name != '_base':
-                target = item.resolve()
-                aliases.append((item.name, target.name))
-
-        if aliases:
-            for alias, target in sorted(aliases):
-                print(f"{alias} -> {target}")
+    config = load_config(base_dir)
+    files_to_sync = []
+    from_name = None
+    to_name = None
+
+    # 引数解析
+    i = 0
+    while i < len(args):
+        if args[i] == "--from" and i + 1 < len(args):
+            from_name = args[i + 1]
+            i += 2
+        elif args[i] == "--to" and i + 1 < len(args):
+            to_name = args[i + 1]
+            i += 2
         else:
-            print("No aliases found.")
-        return
+            files_to_sync.append(args[i])
+            i += 1
 
-    # --remove オプション
-    if '--remove' in args:
-        if len(args) < 2:
-            print(msg('usage_alias'), file=sys.stderr)
-            sys.exit(1)
-
-        alias_name = args[args.index('--remove') + 1]
-        alias_path = parent_dir / alias_name
-
-        if not alias_path.exists():
-            print(msg('error', msg('alias_not_found', alias_name)), file=sys.stderr)
-            sys.exit(1)
+    if not files_to_sync:
+        files_to_sync = config.get("sync_files", [])
 
-        if not alias_path.is_symlink():
-            print(msg('error', f'{alias_name} is not an alias'), file=sys.stderr)
-            sys.exit(1)
-
-        alias_path.unlink()
-        print(msg('alias_removed', alias_name))
+    if not files_to_sync:
         return
 
-    # エイリアス作成
-    if len(args) < 2:
-        print(msg('usage_alias'), file=sys.stderr)
-        sys.exit(1)
-
-    alias_name = args[0]
-    worktree_name = args[1]
-
-    alias_path = parent_dir / alias_name
-    worktree_path = parent_dir / worktree_name
+    worktrees = get_worktree_info(base_dir)
 
-    # worktree が存在するかチェック
-    if not worktree_path.exists():
-        print(msg('error', f'Worktree not found: {worktree_name}'), file=sys.stderr)
-        sys.exit(1)
+    # 送信元と送信先のパスを決定
+    from_path = base_dir
+    if from_name:
+        found = False
+        for wt in worktrees:
+            if Path(wt["path"]).name == from_name:
+                from_path = Path(wt["path"])
+                found = True
+                break
+        if not found:
+            print(msg("error", f"Worktree not found: {from_name}"), file=sys.stderr)
+            sys.exit(1)
 
-    # エイリアスがすでに存在する場合は上書き
-    if alias_path.exists():
-        if alias_path.is_symlink():
-            alias_path.unlink()
-            alias_path.symlink_to(worktree_path, target_is_directory=True)
-            print(msg('alias_updated', alias_name, worktree_name))
+    dest_paths = []
+    if to_name:
+        if to_name == "main":
+            dest_paths = [base_dir]
         else:
-            print(msg('error', f'{alias_name} exists but is not a symlink'), file=sys.stderr)
-            sys.exit(1)
+            found = False
+            for wt in worktrees:
+                if Path(wt["path"]).name == to_name:
+                    dest_paths = [Path(wt["path"])]
+                    found = True
+                    break
+            if not found:
+                print(msg("error", f"Worktree not found: {to_name}"), file=sys.stderr)
+                sys.exit(1)
     else:
-        # シンボリックリンクを作成
-        alias_path.symlink_to(worktree_path, target_is_directory=True)
-        print(msg('alias_created', alias_name, worktree_name))
-
-
-def cmd_status(args: list[str]):
-    """wt status - Show status of all worktrees"""
-    base_dir = find_base_dir()
-    if not base_dir:
-        print(msg('error', msg('base_not_found')), file=sys.stderr)
-        sys.exit(1)
-
-    # オプション
-    show_dirty_only = '--dirty' in args
-    short = '--short' in args
-
-    worktrees = get_worktree_info(base_dir)
+        # 指定がない場合は現在のディレクトリが worktree ならそこへ、そうでなければ全自動（通常は base -> current）
+        current_dir = Path.cwd()
+        if current_dir != base_dir and any(
+            current_dir.is_relative_to(Path(wt["path"])) for wt in worktrees
+        ):
+            dest_paths = [current_dir]
+        else:
+            # base から全 worktree へ（安全のため、ユーザーが現在の worktree にいる場合はそこだけにするのが一般的だが、ここでは全 worktree とした）
+            dest_paths = [
+                Path(wt["path"]) for wt in worktrees if Path(wt["path"]) != base_dir
+            ]
 
-    for wt in worktrees:
-        path = Path(wt['path'])
+    import shutil
 
-        # dirty only モードの場合、clean なものはスキップ
-        if show_dirty_only and wt.get('is_clean'):
+    count = 0
+    for dst_root in dest_paths:
+        if dst_root == from_path:
             continue
-
-        # git status を取得
-        result = run_command(
-            ["git", "status", "--short" if short else "--short"],
-            cwd=path,
-            check=False
-        )
-
-        status_output = result.stdout.strip()
-
-        # ヘッダー
-        print(f"\n{'='*60}")
-        print(f"Worktree: {path.name}")
-        print(f"Branch: {wt.get('branch', 'N/A')}")
-        print(f"Path: {path}")
-        print(f"{'='*60}")
-
-        if status_output:
-            print(status_output)
-        else:
-            print("(clean - no changes)")
+        for f in files_to_sync:
+            src = from_path / f
+            dst = dst_root / f
+            if src.exists():
+                print(msg("syncing", src, dst), file=sys.stderr)
+                dst.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(src, dst)
+                count += 1
 
 
 def cmd_passthrough(args: list[str]):
     """Passthrough other git worktree commands"""
     base_dir = find_base_dir()
     if not base_dir:
-        print(msg('error', msg('base_not_found')), file=sys.stderr)
+        print(msg("error", msg("base_not_found")), file=sys.stderr)
         sys.exit(1)
 
     result = run_command(["git", "worktree"] + args, cwd=base_dir, check=False)
-    print(result.stdout, end='')
+    print(result.stdout, end="")
     if result.stderr:
-        print(result.stderr, end='', file=sys.stderr)
+        print(result.stderr, end="", file=sys.stderr)
     sys.exit(result.returncode)
 
 
@@ -1136,22 +1645,29 @@ def show_help():
         print("  wt <command> [options]")
         print()
         print("コマンド:")
-        print("  clone <repository_url>                   - リポジトリをクローン")
-        print("  init                                      - 既存リポジトリを WT_<repo>/_base/ に移動")
-        print("  add <作業名> [<base_branch>] [--alias <名前>] - worktree を追加（デフォルト: 新規ブランチ作成）")
-        print("  list [--verbose] [--sort age|name] - worktree 一覧を表示")
-        print("  rm <作業名>                         - worktree を削除")
-        print("  remove <作業名>                     - worktree を削除")
-        print("  clean [--dry-run] [--days N]       - 未使用の worktree を削除")
-        print("  alias <名前> <worktree>            - worktree のエイリアスを作成/更新")
-        print("  alias --list                        - エイリアス一覧を表示")
-        print("  alias --remove <名前>              - エイリアスを削除")
-        print("  status [--dirty] [--short]         - 全 worktree の状態を表示")
-        print("  <git-worktree-command>             - その他の git worktree コマンド")
+        print(f"  {'clone <repository_url>':<55} - リポジトリをクローン")
+        print(f"  {'init':<55} - 既存リポジトリをメインリポジトリとして構成")
+        print(
+            f"  {'add (ad) <作業名> [<base_branch>]':<55} - worktree を追加（デフォルト: 新規ブランチ作成）"
+        )
+        print(f"  {'list (ls) [--pr]':<55} - worktree 一覧を表示")
+        print(
+            f"  {'stash (st) <作業名> [<base_branch>]':<55} - 現在の変更をスタッシュして新規 worktree に移動"
+        )
+        print(
+            f"  {'pr add <番号>':<55} - GitHub PR を取得して worktree を作成/パス表示"
+        )
+        print(f"  {'rm/remove <作業名> [-f|--force]':<55} - worktree を削除")
+        print(
+            f"  {'clean (cl) [--days N] [--merged] [--closed]':<55} - 不要な worktree を削除"
+        )
+        print(
+            f"  {'sync (sy) [files...] [--from <名>] [--to <名>]':<55} - ファイル（.env等）を同期"
+        )
         print()
         print("オプション:")
-        print("  -h, --help     - このヘルプメッセージを表示")
-        print("  -v, --version  - バージョン情報を表示")
+        print(f"  {'-h, --help':<55} - このヘルプメッセージを表示")
+        print(f"  {'-v, --version':<55} - バージョン情報を表示")
     else:
         print("easy-worktree - Simple CLI tool for managing Git worktrees")
         print()
@@ -1159,32 +1675,37 @@ def show_help():
         print("  wt <command> [options]")
         print()
         print("Commands:")
-        print("  clone <repository_url>                       - Clone a repository")
-        print("  init                                          - Move existing repo to WT_<repo>/_base/")
-        print("  add <work_name> [<base_branch>] [--alias <name>] - Add a worktree (default: create new branch)")
-        print("  list [--verbose] [--sort age|name]  - List worktrees")
-        print("  rm <work_name>                       - Remove a worktree")
-        print("  remove <work_name>                   - Remove a worktree")
-        print("  clean [--dry-run] [--days N]        - Remove unused worktrees")
-        print("  alias <name> <worktree>             - Create or update an alias for a worktree")
-        print("  alias --list                         - List aliases")
-        print("  alias --remove <name>               - Remove an alias")
-        print("  status [--dirty] [--short]          - Show status of all worktrees")
-        print("  <git-worktree-command>              - Other git worktree commands")
+        print(f"  {'clone <repository_url>':<55} - Clone a repository")
+        print(f"  {'init':<55} - Configure existing repository as main")
+        print(
+            f"  {'add (ad) <work_name> [<base_branch>]':<55} - Add a worktree (default: create new branch)"
+        )
+        print(f"  {'list (ls) [--pr]':<55} - List worktrees")
+        print(
+            f"  {'stash (st) <work_name> [<base_branch>]':<55} - Stash current changes and move to new worktree"
+        )
+        print(f"  {'pr add <number>':<55} - Manage GitHub PRs as worktrees")
+        print(f"  {'rm/remove <work_name> [-f|--force]':<55} - Remove a worktree")
+        print(
+            f"  {'clean (cl) [--days N] [--merged] [--closed]':<55} - Remove unused/merged worktrees"
+        )
+        print(
+            f"  {'sync (sy) [files...] [--from <name>] [--to <name>]':<55} - Sync files (.env, etc.)"
+        )
         print()
         print("Options:")
-        print("  -h, --help     - Show this help message")
-        print("  -v, --version  - Show version information")
+        print(f"  {'-h, --help':<55} - Show this help message")
+        print(f"  {'-v, --version':<55} - Show version information")
 
 
 def show_version():
     """Show version information"""
-    print("easy-worktree version 0.0.7")
+    print("easy-worktree version 0.1.1")
 
 
 def main():
     """メインエントリポイント"""
-    # ヘルプとバージョンのオプションは _base/ なしでも動作する
+    # ヘルプとバージョンのオプションは設定なしでも動作する
     if len(sys.argv) < 2:
         show_help()
         sys.exit(1)
@@ -1206,18 +1727,20 @@ def main():
         cmd_clone(args)
     elif command == "init":
         cmd_init(args)
-    elif command == "add":
+    elif command in ["add", "ad"]:
         cmd_add(args)
-    elif command == "list":
+    elif command in ["list", "ls"]:
         cmd_list(args)
     elif command in ["rm", "remove"]:
         cmd_remove(args)
-    elif command == "clean":
+    elif command in ["clean", "cl"]:
         cmd_clean(args)
-    elif command == "alias":
-        cmd_alias(args)
-    elif command == "status":
-        cmd_status(args)
+    elif command in ["sync", "sy"]:
+        cmd_sync(args)
+    elif command in ["stash", "st"]:
+        cmd_stash(args)
+    elif command == "pr":
+        cmd_pr(args)
     else:
         # その他のコマンドは git worktree にパススルー
         cmd_passthrough([command] + args)