multi-workspace 3.2.2__tar.gz → 3.2.4__tar.gz

{multi_workspace-3.2.2 → multi_workspace-3.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-workspace
-Version: 3.2.2
+Version: 3.2.4
 Summary: Multi
 Project-URL: Repository, https://github.com/gabemontague/multi
 Project-URL: Issues, https://github.com/gabemontague/multi/issues
@@ -108,12 +108,15 @@ To grant or remove GitHub collaborator access across every GitHub repo in a work
 ```bash
 multi collaborator add octocat --permission maintain --yes
 multi collaborator add --yes
+multi collaborator accept --yes
 multi collaborator remove octocat --yes
 multi collaborator recent-users
 ```
 
 When the workspace root repository has a GitHub `origin`, `multi collaborator` applies the change there too.
 
+The invited collaborator can run `multi collaborator accept --yes` with their own `gh` authentication to accept pending invitations for the workspace repos.
+
 Recent collaborator usernames are saved under `~/.multi`, and `multi collaborator add` can prompt from that list when no username is supplied.
 
 If one repo fails, `multi collaborator` continues through the rest of the workspace and reports the failures at the end.

{multi_workspace-3.2.2 → multi_workspace-3.2.4}/README.md

@@ -81,12 +81,15 @@ To grant or remove GitHub collaborator access across every GitHub repo in a work
 ```bash
 multi collaborator add octocat --permission maintain --yes
 multi collaborator add --yes
+multi collaborator accept --yes
 multi collaborator remove octocat --yes
 multi collaborator recent-users
 ```
 
 When the workspace root repository has a GitHub `origin`, `multi collaborator` applies the change there too.
 
+The invited collaborator can run `multi collaborator accept --yes` with their own `gh` authentication to accept pending invitations for the workspace repos.
+
 Recent collaborator usernames are saved under `~/.multi`, and `multi collaborator add` can prompt from that list when no username is supplied.
 
 If one repo fails, `multi collaborator` continues through the rest of the workspace and reports the failures at the end.

{multi_workspace-3.2.2 → multi_workspace-3.2.4}/multi/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.2.2'
-__version_tuple__ = version_tuple = (3, 2, 2)
+__version__ = version = '3.2.4'
+__version_tuple__ = version_tuple = (3, 2, 4)
 
 __commit_id__ = commit_id = None

{multi_workspace-3.2.2 → multi_workspace-3.2.4}/multi/app_api.py

@@ -2,6 +2,9 @@ from __future__ import annotations
 
 import dataclasses
 import subprocess
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor, TimeoutError, as_completed
 from pathlib import Path
 from typing import Any, Literal, TypedDict
 
@@ -10,11 +13,29 @@ from multi.errors import NoRepositoriesError
 from multi.paths import Paths
 from multi.repos import Repository, load_repos
 
-RepoStatus = Literal["clean", "dirty", "out-of-sync", "not-a-repo", "missing"]
+RepoStatus = Literal[
+    "clean",
+    "dirty",
+    "out-of-sync",
+    "no_git",
+    "missing",
+    "unknown",
+]
 
 HISTORY_GROUP_WINDOW_MS = 60_000
 HISTORY_MAX_COMMITS_PER_REPO = 250
 GIT_HISTORY_FORMAT = "%H%x1f%h%x1f%an%x1f%ae%x1f%at%x1f%s%x1f%b%x1e"
+PROJECT_SUMMARY_METADATA_CACHE_TTL_SECONDS = 10.0
+PROJECT_SUMMARY_WORKERS = 8
+PROJECT_SUMMARY_TIMEOUT_SECONDS = 12.0
+
+_project_summary_cache_lock = threading.Lock()
+_project_summary_executor = ThreadPoolExecutor(
+    max_workers=PROJECT_SUMMARY_WORKERS,
+    thread_name_prefix="multi-project-summary",
+)
+_cached_project_summary_metadata: dict[str, tuple[float, dict[str, Any]]] = {}
+_refreshing_project_summary_paths: set[str] = set()
 
 
 class RepoSyncState(TypedDict):
@@ -104,7 +125,7 @@ def _get_git_status_internal(repo_path: Path, ignore_untracked: bool) -> RepoSta
         return "missing"
 
     if not (repo_path / ".git").exists():
-        return "not-a-repo"
+        return "no_git"
 
     status_args = ["status", "--porcelain"]
     if ignore_untracked:
@@ -184,7 +205,9 @@ def _get_latest_commit_ms_for_repo(repo_path: Path) -> int | None:
         return None
 
     try:
-        stdout = _run_git(["log", "-1", "--format=%at"], cwd=repo_path, timeout=10).stdout
+        stdout = _run_git(
+            ["log", "-1", "--format=%at"], cwd=repo_path, timeout=10
+        ).stdout
         authored_at_seconds = int(stdout.strip())
         return authored_at_seconds * 1000
     except (OSError, ValueError, subprocess.SubprocessError):
@@ -194,10 +217,11 @@ def _get_latest_commit_ms_for_repo(repo_path: Path) -> int | None:
 def _worst_status(a: RepoStatus, b: RepoStatus) -> RepoStatus:
     severity = {
         "clean": 0,
-        "not-a-repo": 1,
-        "out-of-sync": 2,
-        "dirty": 3,
-        "missing": 4,
+        "unknown": 1,
+        "no_git": 2,
+        "out-of-sync": 3,
+        "dirty": 4,
+        "missing": 5,
     }
     return a if severity[a] >= severity[b] else b
 
@@ -214,10 +238,10 @@ def get_project_status(repo_path: str | Path) -> RepoStatus:
             ],
         ]
         worst = statuses[0]
-        if worst in {"missing", "not-a-repo"}:
+        if worst in {"missing", "no_git"}:
             worst = "clean"
         for status in statuses[1:]:
-            if status in {"missing", "not-a-repo"}:
+            if status in {"missing", "no_git"}:
                 continue
             worst = _worst_status(worst, status)
         return worst
@@ -311,10 +335,13 @@ def _history_commit_from_record(
         "authorName": author_name or "",
         "authorEmail": author_email or "",
         "authoredAtMs": authored_at_ms,
-        "authoredAtIso": __import__("datetime").datetime.fromtimestamp(
+        "authoredAtIso": __import__("datetime")
+        .datetime.fromtimestamp(
             authored_at_ms / 1000,
             tz=__import__("datetime").timezone.utc,
-        ).isoformat().replace("+00:00", "Z"),
+        )
+        .isoformat()
+        .replace("+00:00", "Z"),
         "repoPath": str(repo_path),
         "repoName": repo_name,
     }
@@ -365,7 +392,9 @@ def group_history_commits(commits: list[dict[str, Any]]) -> list[dict[str, Any]]
     for commit in sorted_commits:
         current_group = groups[-1] if groups else None
         previous_commit = (
-            current_group["commits"][-1] if current_group and current_group["commits"] else None
+            current_group["commits"][-1]
+            if current_group and current_group["commits"]
+            else None
         )
         should_merge = (
             previous_commit is not None
@@ -483,7 +512,7 @@ def _doctor_result(repo_path: Path) -> dict[str, Any] | None:
     }
 
 
-def get_project_summary(repo_path: str | Path) -> dict[str, Any]:
+def _project_summary_static_payload(repo_path: str | Path) -> dict[str, Any]:
     project_path = Path(repo_path)
     name = project_path.name or str(project_path)
     try:
@@ -495,15 +524,131 @@ def get_project_summary(repo_path: str | Path) -> dict[str, Any]:
         "path": str(project_path),
         "name": name,
         "lastModifiedMs": _normalize_optional_ms(last_modified_ms),
-        "lastCommitMs": _normalize_optional_ms(get_project_last_commit_ms(project_path)),
+    }
+
+
+def _project_summary_metadata(repo_path: str | Path) -> dict[str, Any]:
+    project_path = Path(repo_path)
+    return {
+        "lastCommitMs": _normalize_optional_ms(
+            get_project_last_commit_ms(project_path)
+        ),
         "status": get_project_status(project_path),
         "doctorResult": _doctor_result(project_path),
         "subRepos": _subrepo_payloads(project_path),
     }
 
 
+def _project_summary_fallback_metadata() -> dict[str, Any]:
+    return {
+        "lastCommitMs": None,
+        "status": "unknown",
+        "doctorResult": None,
+        "subRepos": None,
+    }
+
+
+def _cached_project_metadata(repo_path: str) -> tuple[dict[str, Any] | None, bool]:
+    now = time.monotonic()
+    with _project_summary_cache_lock:
+        cached = _cached_project_summary_metadata.get(repo_path)
+        if cached is None:
+            return None, False
+        cached_at, metadata = cached
+        return dict(
+            metadata
+        ), now - cached_at < PROJECT_SUMMARY_METADATA_CACHE_TTL_SECONDS
+
+
+def _refresh_project_summary_metadata_task(repo_path: str) -> None:
+    try:
+        metadata = _project_summary_metadata(repo_path)
+        with _project_summary_cache_lock:
+            _cached_project_summary_metadata[repo_path] = (time.monotonic(), metadata)
+    finally:
+        with _project_summary_cache_lock:
+            _refreshing_project_summary_paths.discard(repo_path)
+
+
+def _schedule_project_summary_metadata_refresh(repo_paths: list[str]) -> None:
+    now = time.monotonic()
+    scheduled: list[str] = []
+    with _project_summary_cache_lock:
+        for repo_path in dict.fromkeys(path for path in repo_paths if path):
+            cached = _cached_project_summary_metadata.get(repo_path)
+            if (
+                cached is not None
+                and now - cached[0] < PROJECT_SUMMARY_METADATA_CACHE_TTL_SECONDS
+            ):
+                continue
+            if repo_path in _refreshing_project_summary_paths:
+                continue
+            _refreshing_project_summary_paths.add(repo_path)
+            scheduled.append(repo_path)
+
+    for repo_path in scheduled:
+        _project_summary_executor.submit(
+            _refresh_project_summary_metadata_task, repo_path
+        )
+
+
+def _project_summary_payload(repo_path: str | Path) -> dict[str, Any]:
+    path_key = str(repo_path)
+    metadata, is_fresh = _cached_project_metadata(path_key)
+    if not is_fresh:
+        _schedule_project_summary_metadata_refresh([path_key])
+    return {
+        **_project_summary_static_payload(repo_path),
+        **(metadata or _project_summary_fallback_metadata()),
+    }
+
+
+def get_project_summary(repo_path: str | Path) -> dict[str, Any]:
+    return {
+        **_project_summary_static_payload(repo_path),
+        **_project_summary_metadata(repo_path),
+    }
+
+
 def get_projects_summary(repo_paths: list[str]) -> list[dict[str, Any]]:
-    return [get_project_summary(repo_path) for repo_path in repo_paths]
+    return [_project_summary_payload(repo_path) for repo_path in repo_paths]
+
+
+def refresh_projects_summary(repo_paths: list[str]) -> list[dict[str, Any]]:
+    unique_paths = list(dict.fromkeys(path for path in repo_paths if path))
+    futures = {
+        _project_summary_executor.submit(
+            _project_summary_metadata, repo_path
+        ): repo_path
+        for repo_path in unique_paths
+    }
+    refreshed: dict[str, dict[str, Any]] = {}
+    deadline = time.monotonic() + PROJECT_SUMMARY_TIMEOUT_SECONDS
+
+    try:
+        for future in as_completed(futures, timeout=PROJECT_SUMMARY_TIMEOUT_SECONDS):
+            repo_path = futures[future]
+            remaining = max(0.0, deadline - time.monotonic())
+            try:
+                metadata = future.result(timeout=remaining)
+            except Exception:
+                metadata = _project_summary_fallback_metadata()
+            refreshed[repo_path] = metadata
+            with _project_summary_cache_lock:
+                _cached_project_summary_metadata[repo_path] = (
+                    time.monotonic(),
+                    metadata,
+                )
+    except TimeoutError:
+        pass
+
+    return [
+        {
+            **_project_summary_static_payload(repo_path),
+            **refreshed.get(repo_path, _project_summary_fallback_metadata()),
+        }
+        for repo_path in unique_paths
+    ]
 
 
 def get_project_detail(repo_path: str | Path) -> dict[str, Any]:

{multi_workspace-3.2.2 → multi_workspace-3.2.4}/multi/collaborator.py

@@ -135,11 +135,17 @@ def _run_gh_api(
     method: str,
     endpoint: str,
     fields: dict[str, str] | None = None,
+    paginate: bool = False,
+    slurp: bool = False,
 ) -> subprocess.CompletedProcess[str]:
     cmd = [gh_path, "api", "--method", method, endpoint]
     if fields:
         for key, value in fields.items():
             cmd.extend(["-f", f"{key}={value}"])
+    if paginate:
+        cmd.append("--paginate")
+    if slurp:
+        cmd.append("--slurp")
 
     try:
         return subprocess.run(
@@ -155,6 +161,57 @@ def _run_gh_api(
         raise click.ClickException(message) from exc
 
 
+def _load_pending_repository_invitations(gh_path: str) -> list[dict[str, object]]:
+    result = _run_gh_api(
+        gh_path,
+        method="GET",
+        endpoint="user/repository_invitations?per_page=100",
+        paginate=True,
+        slurp=True,
+    )
+
+    try:
+        invitations = json.loads(result.stdout or "[]")
+    except json.JSONDecodeError as exc:
+        raise click.ClickException(
+            "GitHub returned invalid repository invitation data."
+        ) from exc
+
+    if not isinstance(invitations, list):
+        raise click.ClickException(
+            "GitHub returned invalid repository invitation data."
+        )
+
+    if all(isinstance(page, list) for page in invitations):
+        return [
+            invitation
+            for page in invitations
+            for invitation in page
+            if isinstance(invitation, dict)
+        ]
+
+    return [invitation for invitation in invitations if isinstance(invitation, dict)]
+
+
+def _get_invitation_id(invitation: dict[str, object]) -> int | None:
+    invitation_id = invitation.get("id")
+    if isinstance(invitation_id, int):
+        return invitation_id
+    return None
+
+
+def _get_invitation_repo_slug(invitation: dict[str, object]) -> str | None:
+    repository = invitation.get("repository")
+    if not isinstance(repository, dict):
+        return None
+
+    full_name = repository.get("full_name")
+    if isinstance(full_name, str) and full_name:
+        return full_name
+
+    return None
+
+
 def _load_workspace_github_repo_slug(paths: Paths) -> str | None:
     try:
         repo = git.Repo(paths.root_dir)
@@ -246,6 +303,70 @@ def _confirm_across_repos(
         raise click.ClickException("Operation cancelled.")
 
 
+def _confirm_accept_invitations(
+    *,
+    invitations: list[tuple[str, int]],
+    yes: bool,
+) -> None:
+    if yes:
+        return
+
+    repo_list = "\n".join(f"- {slug}" for slug, _ in invitations)
+    confirmed = click.confirm(
+        f"Accept repository invitations for these repos?\n{repo_list}",
+        default=False,
+    )
+    if not confirmed:
+        raise click.ClickException("Operation cancelled.")
+
+
+def _accept_collaborator_invitations(*, yes: bool) -> None:
+    paths = Paths(Path.cwd())
+    gh_path = _ensure_gh_available()
+    repo_targets = _load_github_repo_targets(paths)
+    target_slugs = {slug.lower() for _, slug in repo_targets}
+    invitations: list[tuple[str, int]] = []
+    failures: list[tuple[str, str]] = []
+
+    for invitation in _load_pending_repository_invitations(gh_path):
+        slug = _get_invitation_repo_slug(invitation)
+        invitation_id = _get_invitation_id(invitation)
+        if slug is None or invitation_id is None:
+            continue
+        if slug.lower() not in target_slugs:
+            continue
+        invitations.append((slug, invitation_id))
+
+    if not invitations:
+        click.echo("No pending repository invitations found for this workspace.")
+        return
+
+    _confirm_accept_invitations(invitations=invitations, yes=yes)
+
+    for slug, invitation_id in invitations:
+        try:
+            logger.info(f"Accepting repository invitation for {slug}")
+            _run_gh_api(
+                gh_path,
+                method="PATCH",
+                endpoint=f"user/repository_invitations/{invitation_id}",
+            )
+        except click.ClickException as exc:
+            message = exc.message or str(exc)
+            logger.error(
+                f"Failed accepting repository invitation for {slug}: {message}"
+            )
+            failures.append((slug, message))
+
+    if failures:
+        failure_lines = "\n".join(f"- {slug}: {message}" for slug, message in failures)
+        raise click.ClickException(
+            f"Finished accepting repository invitations with failures:\n{failure_lines}"
+        )
+
+    logger.info("✅ Accepted repository invitations for all workspace repos")
+
+
 def _manage_collaborator(
     *,
     action: str,
@@ -335,6 +456,17 @@ def collaborator_add_cmd(username: str | None, permission: str, yes: bool) -> No
     )
 
 
+@click.command(name="accept")
+@click.option(
+    "--yes",
+    is_flag=True,
+    help="Skip the confirmation prompt.",
+)
+def collaborator_accept_cmd(yes: bool) -> None:
+    """Accept pending collaborator invitations for this workspace."""
+    _accept_collaborator_invitations(yes=yes)
+
+
 @click.command(name="remove")
 @click.argument("username")
 @click.option(
@@ -365,5 +497,6 @@ def collaborator_recent_users_cmd() -> None:
 
 
 collaborator_cmd.add_command(common_command_wrapper(collaborator_add_cmd))
+collaborator_cmd.add_command(common_command_wrapper(collaborator_accept_cmd))
 collaborator_cmd.add_command(common_command_wrapper(collaborator_remove_cmd))
 collaborator_cmd.add_command(common_command_wrapper(collaborator_recent_users_cmd))

{multi_workspace-3.2.2 → multi_workspace-3.2.4}/multi/ignore_files.py

@@ -74,7 +74,7 @@ def _search_entries(paths: Paths) -> List[str]:
 
 
 def _subrepo_generated_entries(repo_path: Path, paths: Paths) -> List[str]:
-    entries = ["# These files are generated by multi."]
+    entries = []
     if would_generate_agents_for_repo(repo_path, paths):
         entries.extend(["CLAUDE.md", "AGENTS.md"])
     repo_vscode_dir = repo_path / ".vscode"
@@ -82,7 +82,13 @@ def _subrepo_generated_entries(repo_path: Path, paths: Paths) -> List[str]:
         repo_vscode_dir / "settings.local.json"
     ).exists():
         entries.append(".vscode/settings.json")
-    return entries
+    return _with_generated_files_header(entries)
+
+
+def _with_generated_files_header(entries: List[str]) -> List[str]:
+    if not entries:
+        return []
+    return ["# These files are generated by multi.", *entries]
 
 
 def clear_subrepo_generated_file_block(repo_path: Path) -> None:
@@ -135,7 +141,6 @@ def remove_ignore_entries_for_repos(paths: Paths, repo_names: List[str]) -> None
 
 def update_gitignore_with_generated_files(paths: Paths):
     root_generated_entries = [
-        "# These files are generated by multi.",
         ".vscode/settings.json",
         ".vscode/tasks.json",
         ".vscode/launch.json",
@@ -144,7 +149,7 @@ def update_gitignore_with_generated_files(paths: Paths):
     if would_generate_agents_for_repo(paths.root_dir, paths, is_root=True):
         root_generated_entries.extend(["CLAUDE.md", "AGENTS.md"])
     IgnoreFile(paths.gitignore_path, GENERATED_FILES_BLOCK).set_managed_lines(
-        root_generated_entries
+        _with_generated_files_header(root_generated_entries)
     )
 
     if paths.settings.is_monorepo() or not paths.settings.get("repos"):

{multi_workspace-3.2.2 → multi_workspace-3.2.4}/multi/service.py

@@ -12,6 +12,7 @@ from multi.app_api import (
     get_history_group_diff,
     get_project_detail,
     get_projects_summary,
+    refresh_projects_summary,
 )
 
 logger = logging.getLogger(__name__)
@@ -66,6 +67,18 @@ class MultiServiceHandler(BaseHTTPRequestHandler):
                 )
                 return
 
+            if self.path == "/v1/projects/status":
+                repo_paths = body.get("repoPaths", [])
+                if not isinstance(repo_paths, list) or not all(
+                    isinstance(item, str) for item in repo_paths
+                ):
+                    raise ValueError("repoPaths must be a list of strings.")
+                self._write_json(
+                    HTTPStatus.OK,
+                    {"projects": refresh_projects_summary(repo_paths)},
+                )
+                return
+
             if self.path == "/v1/project/detail":
                 repo_path = body.get("repoPath")
                 if not isinstance(repo_path, str) or not repo_path:

{multi_workspace-3.2.2 → multi_workspace-3.2.4}/multi/worktree.py

@@ -39,7 +39,12 @@ def _run_git(repo_path: Path, args: list[str]) -> None:
         ) from e
 
 
-def _create_root_worktree(root_dir: Path, destination: Path, branch_name: str) -> None:
+def _create_root_worktree(
+    root_dir: Path,
+    destination: Path,
+    branch_name: str,
+    base_ref: str,
+) -> None:
     exists_locally, exists_remotely = check_branch_existence(root_dir, branch_name)
 
     if exists_locally:
@@ -54,7 +59,7 @@ def _create_root_worktree(root_dir: Path, destination: Path, branch_name: str) -
             f"origin/{branch_name}",
         ]
     else:
-        args = ["worktree", "add", "-b", branch_name, str(destination), "HEAD"]
+        args = ["worktree", "add", "-b", branch_name, str(destination), base_ref]
 
     _run_git(root_dir, args)
     logger.info(f"Created worktree at {destination}")
@@ -164,12 +169,42 @@ def _transfer_configured_paths(source_paths: Paths, destination_paths: Paths) ->
 
 
 def _checkout_subrepos(
-    repos: Iterable[Repository],
+    source_repos: Iterable[Repository],
+    destination_repos: Iterable[Repository],
     branch_name: str,
     allow_create: bool,
+    base_ref: str,
 ) -> None:
-    for repo in repos:
+    source_by_name = {repo.name: repo for repo in source_repos}
+    for repo in destination_repos:
         repo_branch_name = repo.fixed_branch or branch_name
+        if repo.fixed_branch:
+            create_and_switch_branch(
+                repo.path,
+                repo_branch_name,
+                allow_create=allow_create,
+            )
+            continue
+        source_repo = source_by_name.get(repo.name)
+        if (
+            source_repo is not None
+            and base_ref != "HEAD"
+            and not check_branch_existence(repo.path, repo_branch_name)[0]
+        ):
+            try:
+                _run_git(repo.path, ["fetch", str(source_repo.path), base_ref])
+                _run_git(repo.path, ["checkout", "-b", repo_branch_name, "FETCH_HEAD"])
+                logger.info(f"✅ Switched to branch '{repo_branch_name}' in {repo.path}")
+                continue
+            except GitError as exc:
+                logger.warning(
+                    "⚠️  Base ref %s was not available for %s; creating %s from "
+                    "the current checkout instead. %s",
+                    base_ref,
+                    repo.name,
+                    repo_branch_name,
+                    exc,
+                )
         create_and_switch_branch(
             repo.path,
             repo_branch_name,
@@ -177,8 +212,14 @@ def _checkout_subrepos(
         )
 
 
-def add_worktree(root_dir: Path, name: str, branch_name: str | None = None) -> Path:
-    paths = Paths(root_dir)
+def add_worktree(
+    root_dir: Path,
+    name: str,
+    branch_name: str | None = None,
+    install_set: str | None = None,
+    base_ref: str = "HEAD",
+) -> Path:
+    paths = Paths(root_dir, install_set=install_set)
     if paths.settings.is_monorepo():
         raise click.UsageError(
             "The 'multi worktree add' command is not available in monorepo mode. "
@@ -198,14 +239,16 @@ def add_worktree(root_dir: Path, name: str, branch_name: str | None = None) -> P
             "already exist for all repos, this command will fix the situation."
         )
 
-    _create_root_worktree(paths.root_dir, destination, branch_name)
-    sync(root_dir=destination)
+    _create_root_worktree(paths.root_dir, destination, branch_name, base_ref)
+    sync(root_dir=destination, install_set=install_set)
 
-    destination_paths = Paths(destination)
+    destination_paths = Paths(destination, install_set=install_set)
     _checkout_subrepos(
+        load_repos(paths),
         load_repos(destination_paths),
         branch_name,
         allow_create=all_on_same_branch,
+        base_ref=base_ref,
     )
     _transfer_configured_paths(paths, destination_paths)
     return destination
@@ -223,13 +266,37 @@ def worktree_cmd() -> None:
     "branch_name",
     help="Branch name for the worktree. Defaults to NAME.",
 )
-def worktree_add_cmd(name: str, branch_name: str | None = None) -> None:
+@click.option(
+    "--install-set",
+    "--set",
+    "install_set",
+    metavar="NAME",
+    help="Only sync repositories included in the named install set.",
+)
+@click.option(
+    "--base-ref",
+    default="HEAD",
+    show_default=True,
+    help="Base ref for newly created root and sub-repo branches.",
+)
+def worktree_add_cmd(
+    name: str,
+    branch_name: str | None = None,
+    install_set: str | None = None,
+    base_ref: str = "HEAD",
+) -> None:
     """Create a sibling worktree.
 
     NAME: Directory name for the sibling worktree. Used as the branch name when
     --branch is omitted.
     """
-    add_worktree(Path.cwd(), name=name, branch_name=branch_name)
+    add_worktree(
+        Path.cwd(),
+        name=name,
+        branch_name=branch_name,
+        install_set=install_set,
+        base_ref=base_ref,
+    )
 
 
 worktree_cmd.add_command(common_command_wrapper(worktree_add_cmd))