fadenstack 0.4.2__py3-none-any.whl

faden_cli/commands/dev/dev_pull.py

@@ -0,0 +1,297 @@
+"""``faden dev pull`` — pull the latest changes from a branch.
+
+Fetches and fast-forwards every repository checked out in the dev
+workspace to the latest commit of the target branch (default:
+``main``).  This is the counterpart of ``dev init --overwrite`` for an already
+bootstrapped workspace: no cloning and no dependency installation — it
+just brings the checkouts up to date.
+
+Repositories discovered in the workspace (same convention as
+``dev status``):
+
+* every Fadenstack service in the monorepo layout
+  ``<workspace>/fadenstack/<name>``, or
+* flat ``<workspace>/<name>`` checkouts, when that layout is in use;
+* the workspace root itself, if it is a git checkout (running the CLI
+  from inside a checkout).
+
+Subdirectories sharing a git repository collapse to the single repo
+root, and only repositories that live *inside* the workspace are ever
+touched — unrelated checkouts (e.g. an ``nvm`` install under a
+home-directory workspace) and ancestor checkouts the workspace merely
+sits in are both excluded.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+import click
+from rich.table import Table
+
+from faden_cli.core.console import console, error, info, success, warning
+from faden_cli.core.registry import REPO_DIR_MAP
+from faden_cli.core.settings import load_config
+from faden_cli.core.workspace import find_service_dir
+
+from .dev_group import dev_group
+
+
+def _git(repo_dir: Path, *args: str, timeout: int = 300) -> subprocess.CompletedProcess | None:
+    """Run a git command in *repo_dir*; returns None if git is missing or timed out."""
+    git = shutil.which("git")
+    if not git:
+        return None
+    try:
+        return subprocess.run(  # noqa: S603
+            [git, *args],
+            cwd=str(repo_dir),
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+    except (subprocess.TimeoutExpired, OSError):
+        return None
+
+
+def _git_toplevel(path: Path, within: Path | None = None) -> Path | None:
+    """Return the git repo root containing *path*, or None if it is not in one.
+
+    When *within* is given, the repo root must lie inside *within*
+    (inclusive) — ``rev-parse --show-toplevel`` walks up ancestor
+    directories, so a candidate inside a checkout merely *containing*
+    the workspace would otherwise resolve to that outer repo.
+    """
+    if not path.is_dir():
+        return None
+    proc = _git(path, "rev-parse", "--show-toplevel", timeout=15)
+    if proc is None or proc.returncode != 0:
+        return None
+    toplevel = Path(proc.stdout.strip())
+    if within is not None:
+        try:
+            toplevel.resolve().relative_to(within.resolve())
+        except ValueError:
+            return None
+    return toplevel
+
+
+def _find_repo_dirs(workspace: Path) -> list[tuple[str, Path]]:
+    """Return ``(display_name, repo_root)`` for each repo in the workspace.
+
+    Discovery follows the ``dev status`` convention — registry-driven via
+    :func:`find_service_dir` (monorepo layout ``<ws>/fadenstack/<name>``
+    or flat ``<ws>/<name>``) — plus the workspace root itself when it is a
+    checkout (running the CLI from inside a repo).  Candidates that live
+    inside the same git repository (e.g. monorepo subdirs) collapse to the
+    single repo root, so each checkout is pulled exactly once.  Unrelated
+    repos that happen to sit in the workspace (e.g. ``.nvm``) are never
+    touched.
+    """
+    found: list[tuple[str, Path]] = []
+    seen: set[str] = set()
+
+    def _add(candidate: Path) -> None:
+        toplevel = _git_toplevel(candidate, within=workspace)
+        if toplevel is None:
+            return
+        key = str(toplevel.resolve())
+        if key in seen:
+            return
+        seen.add(key)
+        found.append((toplevel.name or str(toplevel), toplevel))
+
+    if workspace.is_dir():
+        _add(workspace)
+    for local_name in REPO_DIR_MAP.values():
+        _add(find_service_dir(workspace, local_name))
+
+    return found
+
+
+def _pull_repo(
+    repo_dir: Path, branch: str, force: bool = False, hard: bool = False
+) -> tuple[str, str]:
+    """Pull *branch* into *repo_dir*.
+
+    Returns a ``(status, detail)`` tuple where status is one of
+    ``up-to-date``, ``updated``, ``forced``, ``failed``, ``skipped`` and
+    detail is a human-readable explanation (current branch, error
+    message, …).
+
+    With *hard*, the checkout is forcibly aligned to
+    ``origin/<branch>`` via three steps, in order:
+
+    1. ``git clean -fd`` — remove untracked files; build artifacts that
+       are git-ignored (``node_modules/``, ``.venv/``, ``.env``) are
+       preserved, everything else that is not tracked is deleted.
+    2. ``git checkout -f <branch>`` — switch to the target branch,
+       discarding any changes that would be overwritten by the switch.
+    3. ``git reset --hard origin/<branch>`` — discard the remaining
+       tracked modifications and move the working tree exactly to the
+       remote branch tip.
+
+    **No backup is taken** — local edits are irrecoverable.
+    """
+    proc = _git(repo_dir, "fetch", "origin", "--prune")
+    if proc is None:
+        return "failed", "git not found on PATH (or fetch timed out)"
+    if proc.returncode != 0:
+        return "failed", (proc.stderr or proc.stdout).strip() or f"git fetch exited with code {proc.returncode}"
+
+    # Does the branch even exist on the remote?
+    check = _git(repo_dir, "rev-parse", "--verify", "--quiet", f"origin/{branch}")
+    if check is not None and check.returncode != 0:
+        return "skipped", f"branch '{branch}' not found on remote"
+
+    if hard:
+        cl = _git(repo_dir, "clean", "-fd", timeout=600)
+        if cl is None or cl.returncode != 0:
+            detail = (cl.stderr if cl else "git timed out").strip() or "git clean -fd failed"
+            return "failed", detail
+        co = _git(repo_dir, "checkout", "-f", branch)
+        if co is None or co.returncode != 0:
+            detail = (co.stderr if co else "git timed out").strip() or "git checkout -f failed"
+            return "failed", detail
+        rs = _git(repo_dir, "reset", "--hard", f"origin/{branch}")
+        if rs is None or rs.returncode != 0:
+            detail = (rs.stderr if rs else "git reset timed out").strip() or "git reset --hard failed"
+            return "failed", detail
+        return "forced", f"reset to origin/{branch} (untracked files cleaned, local changes discarded)"
+
+    cur_proc = _git(repo_dir, "rev-parse", "--abbrev-ref", "HEAD")
+    current = cur_proc.stdout.strip() if cur_proc and cur_proc.returncode == 0 else "unknown"
+
+    if current != branch:
+        if force:
+            co = _git(repo_dir, "checkout", branch)
+            if co is None or co.returncode != 0:
+                detail = (co.stderr if co else "git timed out").strip() or "git checkout failed"
+                return "failed", detail
+        else:
+            return "skipped", f"checked out on '{current}' (use --force to switch to '{branch}')"
+
+    pull = _git(repo_dir, "pull", "--ff-only", "origin", branch)
+    if pull is None:
+        return "failed", "git pull timed out"
+    if pull.returncode != 0:
+        detail = (pull.stderr or pull.stdout).strip()
+        if "not possible" in detail or "diverged" in detail.lower() or "conflict" in detail.lower():
+            return "failed", "local changes conflict with origin — commit or stash them, then re-run"
+        return "failed", detail or f"git pull exited with code {pull.returncode}"
+
+    if "Already up to date" in pull.stdout:
+        return "up-to-date", f"on '{branch}'"
+    return "updated", f"on '{branch}'"
+
+
+@dev_group.command("pull")
+@click.option(
+    "--branch",
+    "-b",
+    default="main",
+    show_default=True,
+    help="Branch to pull from the remote.",
+)
+@click.option(
+    "--force",
+    "-f",
+    is_flag=True,
+    help="Switch repos to the target branch even if another branch is checked out.",
+)
+@click.option(
+    "--hard",
+    "-H",
+    is_flag=True,
+    help=(
+        "DESTRUCTIVE: clean untracked files, discard all local changes and "
+        "reset every checkout to the remote branch. Un-mergeable pull "
+        "errors (e.g. local changes or untracked files colliding with "
+        "incoming files) are resolved this way. No backup is taken."
+    ),
+)
+def dev_pull(*, branch: str, force: bool, hard: bool) -> None:
+    """Pull the latest changes from the default branch.
+
+    Fetches and fast-forwards every repository checked out in the dev
+    workspace to the latest commit of the target branch (default
+    ``main``).  Working trees that cannot be fast-forwarded are
+    reported and left untouched; ``--hard`` cleans untracked files,
+    discards all local changes and resets every checkout to the remote
+    branch (destructive).
+
+    \b
+    Examples:
+        faden dev pull
+        faden dev pull --branch feature-x
+        faden dev pull -b main --force
+        faden dev pull --hard   # destructive
+    """
+    cfg = load_config()
+    workspace = (
+        Path(cfg.dev.workspace_dir).expanduser()
+        if cfg.dev and cfg.dev.workspace_dir
+        else Path.cwd()
+    )
+
+    console.print(f"\n[bold cyan]Pulling [bold]{branch}[/bold] in {workspace}[/bold cyan]\n")
+    if not workspace.is_dir():
+        error(f"Dev workspace does not exist: {workspace}")
+        raise SystemExit(1)
+
+    repos = _find_repo_dirs(workspace)
+    if not repos:
+        error(
+            f"No git repositories found in {workspace}. "
+            "Run [bold]faden dev init[/bold] to bootstrap the workspace first."
+        )
+        raise SystemExit(1)
+
+    table = Table(title="Pull results", show_header=True, header_style="bold cyan")
+    table.add_column("Repository", style="bold")
+    table.add_column("Result")
+    table.add_column("Detail")
+
+    style_by_status = {
+        "up-to-date": "[green]up to date[/green]",
+        "updated": "[green]updated[/green]",
+        "forced": "[green]forced[/green]",
+        "failed": "[red]failed[/red]",
+        "skipped": "[yellow]skipped[/yellow]",
+    }
+    counts: dict[str, int] = {}
+
+    for name, repo_dir in repos:
+        status, detail = _pull_repo(repo_dir, branch, force, hard)
+        counts[status] = counts.get(status, 0) + 1
+        table.add_row(name, style_by_status.get(status, status), detail or "—")
+
+    console.print(table)
+
+    failed = counts.get("failed", 0)
+    if counts.get("updated", 0):
+        success(f"{counts['updated']} repository(ies) updated to [bold]{branch}[/bold].")
+    if counts.get("forced", 0):
+        success(
+            f"{counts['forced']} repository(ies) reset to [bold]{branch}[/bold]"
+            " (local changes discarded)."
+        )
+    if counts.get("up-to-date", 0):
+        info(f"{counts['up-to-date']} repository(ies) already up to date.")
+    if counts.get("skipped", 0):
+        warning(
+            f"{counts['skipped']} repository(ies) skipped "
+            "(branch missing on remote or checked out on another branch)."
+        )
+    if failed:
+        error(f"{failed} repository(ies) failed — resolve the reported issues and re-run.")
+        if not hard:
+            warning(
+                "If you want to discard ALL local changes and untracked files "
+                "and take the remote state as-is, re-run with [bold]--hard[/bold]."
+            )
+        raise SystemExit(1)
+
+    info("Next: [bold]faden dev up[/bold] to run the services against the new code.")

faden_cli/commands/dev/dev_status.py

@@ -0,0 +1,151 @@
+"""``faden dev status`` — show developer workspace status."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+import click
+from rich.table import Table
+
+from faden_cli.core.compose import ComposeContext, ps as compose_ps
+from faden_cli.core.console import console, info
+from faden_cli.core.git import current_branch
+from faden_cli.core.registry import DEV_PROCESSES
+from faden_cli.core.settings import REPO_DIR_MAP, load_config
+from faden_cli.core.workspace import find_service_dir, resolve_shared_compose
+
+from .dev_group import dev_group
+
+
+def _check_process(pattern: str) -> bool:
+    """Check if a process matching the pattern is running."""
+    import platform
+
+    try:
+        if platform.system() == "Windows":
+            result = subprocess.run(
+                ["powershell", "-Command",
+                 f"Get-Process | Where-Object {{ $_.CommandLine -like '*{pattern}*' }} | "
+                 f"Select-Object -First 1 | ForEach-Object {{ $_.Id }}"],
+                capture_output=True,
+                text=True,
+            )
+            return bool(result.stdout.strip())
+        else:
+            result = subprocess.run(
+                ["pgrep", "-f", pattern],
+                capture_output=True,
+            )
+            return result.returncode == 0
+    except Exception:
+        return False
+
+
+@dev_group.command("status")
+def dev_status() -> None:
+    """Show the status of the developer workspace.
+
+    Displays:
+      • Repository branches and git status
+      • Shared infrastructure containers
+      • Running dev processes (backend, worker, frontend)
+    """
+    from faden_cli.core.workspace import resolve_workspace
+
+    cfg = load_config()
+    workspace = resolve_workspace()
+
+    console.print("[bold magenta]fadenstack Developer Status[/bold magenta]\n")
+
+    # ── Repositories ──────────────────────────────────────────────
+    repo_table = Table(title="Repositories", show_header=True, header_style="bold cyan")
+    repo_table.add_column("Repository", style="bold")
+    repo_table.add_column("Branch")
+    repo_table.add_column("Status")
+
+    for _gh_name, local_name in sorted(REPO_DIR_MAP.items()):
+        repo_path = find_service_dir(workspace, local_name)
+        if repo_path.exists():
+            branch = current_branch(repo_path) or "—"
+            # Quick dirty check
+            try:
+                result = subprocess.run(
+                    ["git", "status", "--porcelain"],
+                    cwd=str(repo_path),
+                    capture_output=True,
+                    text=True,
+                )
+                if result.stdout.strip():
+                    status = f"[yellow]{len(result.stdout.strip().splitlines())} changed[/yellow]"
+                else:
+                    status = "[green]clean[/green]"
+            except Exception:
+                status = "[dim]unknown[/dim]"
+
+            repo_table.add_row(local_name, branch, status)
+        else:
+            repo_table.add_row(local_name, "—", "[dim]not cloned[/dim]")
+
+    console.print(repo_table)
+
+    # ── Shared infrastructure ─────────────────────────────────────
+    console.print()
+    compose_file = resolve_shared_compose(workspace)
+    if compose_file:
+        env_file = compose_file.parent / ".env"
+        if env_file.exists():
+            from faden_cli.commands.dev.dev_up import heal_dev_env
+
+            heal_dev_env(env_file)
+        ctx = ComposeContext(
+            compose_files=[str(compose_file)],
+            env_file=str(env_file) if env_file.exists() else None,
+            project_dir=str(compose_file.parent),
+        )
+        services = compose_ps(ctx)
+
+        if services:
+            svc_table = Table(title="Shared Infrastructure", show_header=True, header_style="bold cyan")
+            svc_table.add_column("Container", style="bold")
+            svc_table.add_column("State")
+            svc_table.add_column("Health")
+            svc_table.add_column("Ports")
+
+            state_styles = {
+                "running": "[green]running[/green]",
+                "exited": "[red]exited[/red]",
+                "restarting": "[yellow]restarting[/yellow]",
+            }
+            health_styles = {
+                "healthy": "[green]healthy[/green]",
+                "unhealthy": "[red]unhealthy[/red]",
+                "starting": "[yellow]starting[/yellow]",
+            }
+
+            for svc in sorted(services, key=lambda s: s.service):
+                svc_table.add_row(
+                    svc.service,
+                    state_styles.get(svc.state, svc.state or "—"),
+                    health_styles.get(svc.health, svc.health or "—"),
+                    svc.ports or "—",
+                )
+            console.print(svc_table)
+        else:
+            info("No shared infrastructure containers running.")
+    else:
+        info("Shared compose file not found.")
+
+    # ── Dev processes ─────────────────────────────────────────────
+    console.print()
+    proc_table = Table(title="Dev Processes", show_header=True, header_style="bold cyan")
+    proc_table.add_column("Process", style="bold")
+    proc_table.add_column("Status")
+    proc_table.add_column("URL")
+
+    for proc in DEV_PROCESSES:
+        running = _check_process(proc.pattern)
+        status = "[green]running[/green]" if running else "[dim]stopped[/dim]"
+        proc_table.add_row(proc.name, status, proc.url)
+
+    console.print(proc_table)