git-workspace-tui 0.1.0__py3-none-any.whl

git_workspace/__init__.py

@@ -0,0 +1,6 @@
+"""Git-aware multi-repo terminal workspace."""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+

git_workspace/__main__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

git_workspace/cli.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+from .executor import process_env, resolve_command
+from .models import ExecMode
+from .output import plan_items_for_action, print_plan, print_status
+from .planner import build_plan
+from .tui import GitWorkspace
+from .workspace import load_workspace
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="gws",
+        description="Git-aware multi-repo terminal workspace",
+    )
+    parser.add_argument("--cwd", type=Path, default=None, help="workspace start directory")
+
+    sub = parser.add_subparsers(dest="command")
+
+    status = sub.add_parser("status", aliases=["st", "s"], help="show workspace status")
+    status.add_argument("profile", nargs="?")
+
+    plan = sub.add_parser("plan", help="show workspace action plan")
+    plan.add_argument("profile", nargs="?")
+
+    switch = sub.add_parser("switch", help="checkout target branches from a profile")
+    switch.add_argument("profile", nargs="?")
+
+    pull = sub.add_parser("pull", help="pull repositories that are safe to update")
+    pull.add_argument("profile", nargs="?")
+
+    sync = sub.add_parser("sync", help="switch then pull repositories that are safe to update")
+    sync.add_argument("profile", nargs="?")
+
+    exec_cmd = sub.add_parser("exec", help="execute a command in every selected repository")
+    exec_cmd.add_argument("tokens", nargs=argparse.REMAINDER, metavar="...")
+
+    sub.add_parser("tui", help="open the TUI")
+    return parser
+
+
+def run_git(repo_path: Path, *args: str) -> int:
+    proc = subprocess.run(
+        ["git", "-C", str(repo_path), "--no-pager", *args],
+        text=True,
+        env=process_env(),
+    )
+    return proc.returncode
+
+
+def do_switch(profile: str | None, start: Path | None) -> int:
+    workspace = load_workspace(start)
+    exit_code = 0
+    for item in build_plan(workspace, profile):
+        if item.action == "blocked":
+            print(f"skip {item.repo.name}: {item.note}")
+            exit_code = 1
+            continue
+        if item.current != item.target:
+            print(f"== {item.repo.name}: checkout {item.target} ==")
+            exit_code = run_git(item.repo.path, "checkout", item.target) or exit_code
+    return exit_code
+
+
+def do_pull(profile: str | None, start: Path | None) -> int:
+    workspace = load_workspace(start)
+    exit_code = 0
+    for item in build_plan(workspace, profile):
+        if item.action == "blocked":
+            print(f"skip {item.repo.name}: {item.note}")
+            exit_code = 1
+            continue
+        if item.action == "skip pull":
+            print(f"skip {item.repo.name}: {item.note}")
+            continue
+        if item.action == "checkout + pull":
+            hint = "run switch first or use sync"
+            print(f"skip {item.repo.name}: target branch differs; {hint}")
+            exit_code = 1
+            continue
+        print(f"== {item.repo.name}: pull ==")
+        exit_code = run_git(item.repo.path, "pull", "--ff-only") or exit_code
+    return exit_code
+
+
+def do_sync(profile: str | None, start: Path | None) -> int:
+    switch_code = do_switch(profile, start)
+    pull_code = do_pull(profile, start)
+    return switch_code or pull_code
+
+
+def parse_exec_tokens(tokens: list[str], profiles: set[str]) -> tuple[str | None, list[str]]:
+    if not tokens:
+        return None, []
+    if tokens[0] == "--":
+        return None, tokens[1:]
+    if "--" in tokens:
+        separator = tokens.index("--")
+        before = tokens[:separator]
+        if len(before) > 1:
+            raise ValueError("exec accepts at most one profile before --")
+        return (before[0] if before else None), tokens[separator + 1 :]
+    if tokens[0] in profiles:
+        return tokens[0], tokens[1:]
+    return None, tokens
+
+
+def do_exec(tokens: list[str], start: Path | None) -> int:
+    workspace = load_workspace(start)
+    try:
+        profile, command_tokens = parse_exec_tokens(tokens, set(workspace.config.profiles))
+    except ValueError as exc:
+        print(str(exc), file=sys.stderr)
+        return 2
+
+    command = " ".join(command_tokens).strip()
+    if not command:
+        print("gws exec requires a command", file=sys.stderr)
+        return 2
+
+    selected = plan_items_for_action(
+        workspace,
+        profile,
+        {"pull", "checkout + pull", "skip pull", "blocked"},
+    )
+    repos = [item.repo for item in selected] or list(workspace.repos)
+    exit_code = 0
+    for repo in repos:
+        print(f"== {repo.name} ==", flush=True)
+        resolved = resolve_command(command, repo, workspace.config, ExecMode.SHELL)
+        if resolved is None:
+            continue
+        proc = subprocess.run(resolved.args, cwd=str(resolved.cwd), text=True, env=process_env())
+        exit_code = proc.returncode or exit_code
+    return exit_code
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    command = args.command
+
+    if command is None or command == "tui":
+        GitWorkspace(args.cwd).run(mouse=False)
+        return 0
+
+    workspace = load_workspace(args.cwd)
+    if command in {"status", "st", "s"}:
+        print_status(workspace, args.profile)
+        return 0
+    if command == "plan":
+        print_plan(workspace, args.profile)
+        return 0
+    if command == "switch":
+        return do_switch(args.profile, args.cwd)
+    if command == "pull":
+        return do_pull(args.profile, args.cwd)
+    if command == "sync":
+        return do_sync(args.profile, args.cwd)
+    if command == "exec":
+        return do_exec(args.tokens, args.cwd)
+    parser.print_help()
+    return 2

git_workspace/config.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from .models import ExecMode, ExecSettings, WorkspaceConfig
+
+CONFIG_NAMES = ("workspace.yml", "workspace.yaml")
+LOCAL_CONFIG_NAMES = ("workspace.local.yml", "workspace.local.yaml")
+
+
+def find_config(start: Path) -> Path | None:
+    current = start.resolve()
+    if current.is_file():
+        current = current.parent
+    for directory in (current, *current.parents):
+        for name in CONFIG_NAMES:
+            candidate = directory / name
+            if candidate.exists():
+                return candidate
+    return None
+
+
+def _read_yaml(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+    loaded = yaml.safe_load(path.read_text(encoding="utf-8"))
+    if loaded is None:
+        return {}
+    if not isinstance(loaded, dict):
+        raise ValueError(f"{path} must contain a mapping")
+    return loaded
+
+
+def _deep_merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    result = dict(base)
+    for key, value in override.items():
+        if isinstance(result.get(key), dict) and isinstance(value, dict):
+            result[key] = _deep_merge(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def _as_mapping(value: Any, name: str) -> dict[str, Any]:
+    if value is None:
+        return {}
+    if not isinstance(value, dict):
+        raise ValueError(f"{name} must be a mapping")
+    return value
+
+
+def _as_string_mapping(value: Any, name: str) -> dict[str, str]:
+    mapping = _as_mapping(value, name)
+    return {str(key): str(val) for key, val in mapping.items()}
+
+
+def _normalize_repo_config(value: Any) -> dict[str, dict[str, str]]:
+    repos = _as_mapping(value, "repos")
+    normalized: dict[str, dict[str, str]] = {}
+    for name, raw in repos.items():
+        if raw is None:
+            normalized[str(name)] = {}
+        elif isinstance(raw, str):
+            normalized[str(name)] = {"path": raw}
+        elif isinstance(raw, dict):
+            normalized[str(name)] = {str(key): str(val) for key, val in raw.items()}
+        else:
+            raise ValueError(f"repos.{name} must be a mapping or string")
+    return normalized
+
+
+def _normalize_profiles(value: Any) -> dict[str, dict[str, str]]:
+    profiles = _as_mapping(value, "profiles")
+    normalized: dict[str, dict[str, str]] = {}
+    for name, raw in profiles.items():
+        normalized[str(name)] = _as_string_mapping(raw, f"profiles.{name}")
+    return normalized
+
+
+def _normalize_ignore(value: Any) -> tuple[str, ...]:
+    if value is None:
+        return ()
+    if not isinstance(value, list | tuple):
+        raise ValueError("workspace.ignore must be a list")
+    return tuple(str(item) for item in value)
+
+
+def _normalize_exec(value: Any) -> ExecSettings:
+    raw = _as_mapping(value, "exec")
+    mode = str(raw.get("defaultMode", raw.get("default_mode", "shell"))).lower()
+    default_mode = ExecMode.GIT if mode == "git" else ExecMode.SHELL
+    shell = _as_mapping(raw.get("shell"), "exec.shell")
+    return ExecSettings(
+        default_mode=default_mode,
+        git_shortcuts=bool(raw.get("gitShortcuts", raw.get("git_shortcuts", True))),
+        interactive_shell=bool(shell.get("interactive", True)),
+    )
+
+
+def load_config(start: Path | None = None) -> WorkspaceConfig:
+    cwd = (start or Path.cwd()).resolve()
+    config_file = find_config(cwd)
+    if config_file is None:
+        return WorkspaceConfig(root=cwd)
+
+    data = _read_yaml(config_file)
+    for local_name in LOCAL_CONFIG_NAMES:
+        local_file = config_file.parent / local_name
+        if local_file.exists():
+            data = _deep_merge(data, _read_yaml(local_file))
+
+    workspace = _as_mapping(data.get("workspace"), "workspace")
+    root_value = workspace.get("root", ".")
+    root = (config_file.parent / str(root_value)).resolve()
+
+    return WorkspaceConfig(
+        root=root,
+        config_file=config_file,
+        ignore=_normalize_ignore(workspace.get("ignore")),
+        repos=_normalize_repo_config(data.get("repos")),
+        profiles=_normalize_profiles(data.get("profiles")),
+        aliases=_as_string_mapping(data.get("aliases"), "aliases"),
+        exec_settings=_normalize_exec(data.get("exec")),
+    )
+

git_workspace/executor.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import os
+import shlex
+import signal
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+from .git import git_aliases
+from .models import ExecMode, Repo, WorkspaceConfig
+
+BUILTIN_GIT_ALIASES: dict[str, str] = {
+    "g": "status -sb",
+    "gs": "status -sb",
+    "gst": "status -sb",
+    "gss": "status -s",
+    "ga": "add",
+    "gaa": "add --all",
+    "gb": "branch",
+    "gba": "branch -a",
+    "gbr": "branch --remote",
+    "gco": "checkout",
+    "gcb": "checkout -b",
+    "gsw": "switch",
+    "gswc": "switch -c",
+    "gd": "diff",
+    "gds": "diff --stat",
+    "gf": "fetch --all --prune",
+    "gl": "pull",
+    "gp": "push",
+    "gpl": "pull",
+    "gps": "push",
+    "glog": "log --oneline --decorate -20",
+    "grv": "remote -v",
+}
+
+
+@dataclass(frozen=True)
+class ResolvedCommand:
+    display: str
+    args: list[str]
+    cwd: Path
+    shell_mode: bool
+    expanded: str | None = None
+
+
+def normalize_git_command(command: str) -> str:
+    command = command.strip()
+    if command.startswith("git "):
+        return command[4:].strip()
+    return command
+
+
+def shell_program() -> str:
+    return os.environ.get("SHELL") or "/bin/sh"
+
+
+def _source_if_readable(path: str) -> str:
+    return f'[ -r "{path}" ] && . "{path}" >/dev/null 2>&1 || true'
+
+
+def _posix_shell_script(command: str, shell_name: str) -> str:
+    rc_files: tuple[str, ...]
+    prelude: list[str] = ["set +e"]
+    if shell_name == "zsh":
+        prelude.append("setopt aliases >/dev/null 2>&1 || true")
+        rc_files = ("$HOME/.zshenv", "$HOME/.zprofile", "$HOME/.zshrc")
+    elif shell_name == "bash":
+        prelude.append("shopt -s expand_aliases >/dev/null 2>&1 || true")
+        rc_files = ("$HOME/.bash_profile", "$HOME/.bash_login", "$HOME/.profile", "$HOME/.bashrc")
+    elif shell_name == "ksh":
+        rc_files = ("$HOME/.profile", "$HOME/.kshrc")
+    else:
+        rc_files = ()
+
+    lines = [f"GWS_COMMAND={shlex.quote(command)}", *prelude]
+    lines.extend(_source_if_readable(path) for path in rc_files)
+    lines.append("set +e")
+    lines.append('eval "$GWS_COMMAND"')
+    return "\n".join(lines)
+
+
+def shell_invocation(command: str, interactive: bool = True) -> list[str]:
+    shell = shell_program()
+    name = Path(shell).name
+    if interactive and name in {"bash", "zsh", "ksh"}:
+        flag = "-fc" if name == "zsh" else "-c"
+        return [shell, flag, _posix_shell_script(command, name)]
+    if interactive and name == "fish":
+        return [shell, "-ic", command]
+    return [shell, "-lc", command]
+
+
+def command_exists_in_shell(command: str, cwd: Path, interactive: bool = True) -> bool:
+    try:
+        parts = shlex.split(command)
+    except ValueError:
+        return True
+    if not parts:
+        return False
+    head = parts[0]
+    if head.startswith(":") or head in {"cd", "export", "alias", "unalias", "source", "."}:
+        return True
+    probe = f"type {shlex.quote(head)} >/dev/null 2>&1"
+    try:
+        proc = subprocess.run(
+            shell_invocation(probe, interactive=interactive),
+            cwd=str(cwd),
+            text=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            timeout=3,
+        )
+    except Exception:
+        return True
+    return proc.returncode == 0
+
+
+def aliases_for_repo(config: WorkspaceConfig, repo: Repo) -> dict[str, str]:
+    aliases: dict[str, str] = {}
+    aliases.update(BUILTIN_GIT_ALIASES)
+    aliases.update(git_aliases(repo))
+    aliases.update(config.aliases)
+    return aliases
+
+
+def expand_git_alias(command: str, aliases: dict[str, str]) -> tuple[str, bool]:
+    command = normalize_git_command(command)
+    try:
+        parts = shlex.split(command)
+    except ValueError:
+        return command, False
+    if not parts:
+        return "", False
+    head = parts[0]
+    expansion = aliases.get(head)
+    if expansion is None:
+        return command, False
+    rest = " ".join(shlex.quote(part) for part in parts[1:])
+    expanded = f"{expansion} {rest}".strip()
+    return normalize_git_command(expanded), expanded != command
+
+
+def resolve_command(
+    value: str,
+    repo: Repo,
+    config: WorkspaceConfig,
+    mode: ExecMode,
+) -> ResolvedCommand | None:
+    value = value.strip()
+    if not value:
+        return None
+
+    interactive = config.exec_settings.interactive_shell
+
+    if value.startswith("!"):
+        command = value[1:].strip()
+        if not command:
+            return None
+        return ResolvedCommand(value, shell_invocation(command, interactive), repo.path, True)
+
+    if mode == ExecMode.SHELL:
+        if command_exists_in_shell(value, repo.path, interactive):
+            return ResolvedCommand(value, shell_invocation(value, interactive), repo.path, True)
+        if not config.exec_settings.git_shortcuts:
+            return ResolvedCommand(value, shell_invocation(value, interactive), repo.path, True)
+
+    aliases = aliases_for_repo(config, repo)
+    command, expanded = expand_git_alias(value, aliases)
+    if not command:
+        return None
+    try:
+        git_args = shlex.split(command)
+    except ValueError as exc:
+        raise ValueError(f"解析失败：{exc}") from exc
+    return ResolvedCommand(
+        value,
+        ["git", "-C", str(repo.path), "--no-pager", *git_args],
+        config.root,
+        False,
+        command if expanded or value.startswith("git ") else None,
+    )
+
+
+def process_env() -> dict[str, str]:
+    env = os.environ.copy()
+    term = os.environ.get("TERM") or "xterm-256color"
+    if term == "dumb":
+        term = "xterm-256color"
+    env.update(
+        {
+            "GIT_PAGER": "cat",
+            "PAGER": "cat",
+            "LESS": "FRX",
+            "GIT_TERMINAL_PROMPT": "0",
+            "GIT_WORKSPACE": "1",
+            "TERM": term,
+        }
+    )
+    return env
+
+
+def terminate_process(proc: subprocess.Popen[str]) -> None:
+    try:
+        os.killpg(proc.pid, signal.SIGTERM)
+    except Exception:
+        proc.terminate()

git_workspace/git.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from .models import Repo, RepoState
+
+
+def git(repo: Path, *args: str, timeout: float | None = 12) -> subprocess.CompletedProcess[str]:
+    try:
+        return subprocess.run(
+            ["git", "-C", str(repo), *args],
+            text=True,
+            capture_output=True,
+            timeout=timeout,
+        )
+    except subprocess.TimeoutExpired as exc:
+        return subprocess.CompletedProcess(
+            exc.cmd,
+            124,
+            exc.stdout if isinstance(exc.stdout, str) else "",
+            exc.stderr if isinstance(exc.stderr, str) else "timeout",
+        )
+
+
+def is_git_worktree(path: Path) -> bool:
+    result = git(path, "rev-parse", "--is-inside-work-tree")
+    return result.returncode == 0 and result.stdout.strip() == "true"
+
+
+def git_toplevel(path: Path) -> Path | None:
+    result = git(path, "rev-parse", "--show-toplevel")
+    if result.returncode != 0:
+        return None
+    value = result.stdout.strip()
+    return Path(value).resolve() if value else None
+
+
+def current_branch(repo: Path) -> str:
+    result = git(repo, "branch", "--show-current")
+    value = result.stdout.strip()
+    if value:
+        return value
+    result = git(repo, "rev-parse", "--short", "HEAD")
+    return f"detached:{result.stdout.strip() or '?'}"
+
+
+def dirty_count(repo: Path) -> int:
+    result = git(repo, "status", "--porcelain=v1")
+    return len([line for line in result.stdout.splitlines() if line.strip()])
+
+
+def upstream(repo: Path) -> str | None:
+    result = git(repo, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}")
+    if result.returncode != 0:
+        return None
+    value = result.stdout.strip()
+    return value if value and value != "@{u}" else None
+
+
+def ahead_behind(repo: Path, upstream_ref: str) -> tuple[int, int] | tuple[None, None]:
+    result = git(repo, "rev-list", "--left-right", "--count", f"{upstream_ref}...HEAD")
+    if result.returncode != 0:
+        return None, None
+    parts = result.stdout.strip().split()
+    if len(parts) != 2:
+        return None, None
+    behind, ahead = parts
+    return int(ahead), int(behind)
+
+
+def repo_state(repo: Repo) -> RepoState:
+    up = upstream(repo.path)
+    ahead: int | None = None
+    behind: int | None = None
+    if up:
+        ahead, behind = ahead_behind(repo.path, up)
+    return RepoState(
+        branch=current_branch(repo.path),
+        dirty=dirty_count(repo.path),
+        upstream=up,
+        ahead=ahead,
+        behind=behind,
+    )
+
+
+def git_aliases(repo: Repo | None = None) -> dict[str, str]:
+    args = ["git"]
+    if repo is not None:
+        args.extend(["-C", str(repo.path)])
+    args.extend(["config", "--get-regexp", r"^alias\."])
+    proc = subprocess.run(
+        args,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL,
+    )
+    aliases: dict[str, str] = {}
+    if proc.returncode not in {0, 1}:
+        return aliases
+    for raw in proc.stdout.splitlines():
+        key, _, value = raw.partition(" ")
+        if not key.startswith("alias.") or not value.strip():
+            continue
+        aliases[key.removeprefix("alias.")] = value.strip()
+    return aliases