evo-cli 0.11.3__tar.gz → 0.11.4__tar.gz

{evo_cli-0.11.3 → evo_cli-0.11.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.11.3
+Version: 0.11.4
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli
@@ -16,6 +16,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cryptography>=41.0
 Requires-Dist: paramiko>=2.7.0
+Requires-Dist: PyYAML>=6.0
 Requires-Dist: rich>=13.0
 Requires-Dist: rich-click>=1.8
 Provides-Extra: test
@@ -112,3 +113,24 @@ Options:
 - `-y, --yes` - Skip the confirmation prompt
 - `-f, --force` - Apply the fix even if the version is not in the affected range
 - `--unpin` - Undo the fix: re-enable the auto-updater and install the latest build
+
+#### Harness Repositories
+
+Fast-forward every available repository declared in a harness manifest:
+
+```bash
+evo harness pull
+```
+
+Run the command from a harness directory or any registered member repository. Use `--harness PATH`
+when a repository belongs to multiple harnesses or the harness is not registered.
+
+```bash
+evo harness pull --harness ~/github/my-project-harness
+evo harness pull --repo backend --repo frontend
+evo harness pull --dry-run
+```
+
+The command reads `harness.yaml` and its optional `harness.local.yaml` overlay. Repositories marked
+`present: false` are skipped. Repositories with uncommitted changes are not modified, and every pull
+uses `git pull --ff-only` so the command never creates merge commits.

{evo_cli-0.11.3 → evo_cli-0.11.4}/README.md

@@ -85,3 +85,24 @@ Options:
 - `-y, --yes` - Skip the confirmation prompt
 - `-f, --force` - Apply the fix even if the version is not in the affected range
 - `--unpin` - Undo the fix: re-enable the auto-updater and install the latest build
+
+#### Harness Repositories
+
+Fast-forward every available repository declared in a harness manifest:
+
+```bash
+evo harness pull
+```
+
+Run the command from a harness directory or any registered member repository. Use `--harness PATH`
+when a repository belongs to multiple harnesses or the harness is not registered.
+
+```bash
+evo harness pull --harness ~/github/my-project-harness
+evo harness pull --repo backend --repo frontend
+evo harness pull --dry-run
+```
+
+The command reads `harness.yaml` and its optional `harness.local.yaml` overlay. Repositories marked
+`present: false` are skipped. Repositories with uncommitted changes are not modified, and every pull
+uses `git pull --ff-only` so the command never creates merge commits.

evo_cli-0.11.4/evo_cli/VERSION

@@ -0,0 +1 @@
+0.11.4

{evo_cli-0.11.3 → evo_cli-0.11.4}/evo_cli/cli.py

@@ -7,6 +7,7 @@ from evo_cli.commands.download import download
 from evo_cli.commands.fix_claude import f_claude
 from evo_cli.commands.gdrive import gdrive
 from evo_cli.commands.gh import setup_gh
+from evo_cli.commands.harness import harness_group
 from evo_cli.commands.hwid import hwid
 from evo_cli.commands.hwid_reset import hwid_reset
 from evo_cli.commands.localproxy import localproxy
@@ -58,6 +59,7 @@ cli.add_command(cfssh)
 cli.add_command(download)
 cli.add_command(f_claude)
 cli.add_command(gdrive)
+cli.add_command(harness_group)
 cli.add_command(hwid)
 cli.add_command(hwid_reset)
 cli.add_command(site2s)

evo_cli-0.11.4/evo_cli/commands/harness.py

@@ -0,0 +1,213 @@
+import json
+import os
+import shutil
+import subprocess
+from pathlib import Path
+
+import rich_click as click
+import yaml
+
+
+def _read_yaml(path, required=True):
+    if not path.is_file():
+        if required:
+            raise click.ClickException(f"Harness manifest not found: {path}")
+        return {}
+    try:
+        data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    except (OSError, yaml.YAMLError) as exc:
+        raise click.ClickException(f"Cannot read {path}: {exc}") from exc
+    if not isinstance(data, dict):
+        raise click.ClickException(f"Expected a YAML mapping in {path}")
+    return data
+
+
+def _resolve_path(value, base):
+    path = Path(os.path.expandvars(str(value))).expanduser()
+    return (path if path.is_absolute() else base / path).resolve()
+
+
+def _load_repos(manifest_path):
+    manifest = _read_yaml(manifest_path)
+    local = _read_yaml(manifest_path.with_name("harness.local.yaml"), required=False)
+    root = manifest_path.parent.resolve()
+    workspace_value = (
+        os.environ.get("EVO_HARNESS_WORKSPACE") or local.get("workspace") or manifest.get("workspace") or root.parent
+    )
+    workspace = _resolve_path(workspace_value, root)
+    entries = manifest.get("repos", [])
+    if not isinstance(entries, list):
+        raise click.ClickException(f"Expected 'repos' to be a list in {manifest_path}")
+    present_overrides = local.get("present", {}) or {}
+    if not isinstance(present_overrides, dict):
+        raise click.ClickException(
+            f"Expected 'present' to be a mapping in {manifest_path.with_name('harness.local.yaml')}"
+        )
+
+    repos = []
+    names = set()
+    for index, entry in enumerate(entries):
+        if not isinstance(entry, dict):
+            raise click.ClickException(f"Expected repos[{index}] to be a mapping in {manifest_path}")
+        name = str(entry.get("name", "")).strip()
+        if not name:
+            raise click.ClickException(f"Expected repos[{index}].name in {manifest_path}")
+        if name in names:
+            raise click.ClickException(f"Duplicate repo name '{name}' in {manifest_path}")
+        names.add(name)
+        fallback = workspace / name
+        declared = _resolve_path(entry["path"], workspace) if entry.get("path") else None
+        path = declared if declared and declared.exists() else fallback.resolve()
+        present = present_overrides.get(name, entry.get("present", True))
+        repos.append({"name": name, "path": path, "present": bool(present)})
+    return manifest, repos
+
+
+def _contains(parent, child):
+    try:
+        child.relative_to(parent)
+        return True
+    except ValueError:
+        return False
+
+
+def _as_manifest(value):
+    path = _resolve_path(value, Path.cwd())
+    return path / "harness.yaml" if path.is_dir() else path
+
+
+def _find_manifest(value=None):
+    configured = value or os.environ.get("EVO_HARNESS")
+    if configured:
+        manifest_path = _as_manifest(configured)
+        if not manifest_path.is_file():
+            raise click.ClickException(f"Harness manifest not found: {manifest_path}")
+        return manifest_path
+
+    cwd = Path.cwd().resolve()
+    for base in (cwd, *cwd.parents):
+        candidate = base / "harness.yaml"
+        if candidate.is_file():
+            return candidate
+
+    registry_path = _resolve_path(
+        os.environ.get("EVO_HARNESS_REGISTRY", Path.home() / ".claude" / "harness" / "registry.json"),
+        Path.cwd(),
+    )
+    matches = []
+    if registry_path.is_file():
+        try:
+            registry = json.loads(registry_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as exc:
+            raise click.ClickException(f"Cannot read {registry_path}: {exc}") from exc
+        for cluster in registry.get("clusters", []):
+            if not isinstance(cluster, dict) or not cluster.get("root"):
+                continue
+            candidate = _as_manifest(cluster["root"])
+            if not candidate.is_file():
+                continue
+            try:
+                _, repos = _load_repos(candidate)
+            except click.ClickException:
+                continue
+            root = candidate.parent.resolve()
+            if _contains(root, cwd) or any(_contains(repo["path"], cwd) for repo in repos):
+                matches.append(candidate)
+
+    matches = list(dict.fromkeys(matches))
+    if len(matches) == 1:
+        return matches[0]
+    if len(matches) > 1:
+        choices = ", ".join(str(path.parent) for path in matches)
+        raise click.ClickException(f"Current directory belongs to multiple harnesses: {choices}. Use --harness PATH.")
+    raise click.ClickException("Cannot find harness.yaml. Run inside a harness repo or use --harness PATH.")
+
+
+def _git(path, *args):
+    return subprocess.run(
+        ["git", "-C", str(path), *args],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=False,
+    )
+
+
+@click.group("harness", help="Manage repositories declared by a harness manifest.")
+def harness_group():
+    pass
+
+
+@harness_group.command("pull", help="Fast-forward all available repositories in a harness.")
+@click.option(
+    "--harness",
+    "harness_path",
+    type=click.Path(path_type=Path),
+    help="Harness directory or harness.yaml path. Defaults to auto-discovery.",
+)
+@click.option("--repo", "repos", multiple=True, help="Pull only this repo name. Repeat for multiple repos.")
+@click.option("--prune/--no-prune", default=True, show_default=True, help="Prune deleted remote refs while pulling.")
+@click.option("--dry-run", is_flag=True, help="Show repositories that would be pulled.")
+def pull(harness_path, repos, prune, dry_run):
+    if shutil.which("git") is None:
+        raise click.ClickException("git is not installed or is not on PATH")
+
+    manifest_path = _find_manifest(harness_path)
+    manifest, entries = _load_repos(manifest_path)
+    available = {entry["name"] for entry in entries}
+    unknown = sorted(set(repos) - available)
+    if unknown:
+        raise click.ClickException(f"Unknown repo name(s): {', '.join(unknown)}")
+    selected = [entry for entry in entries if not repos or entry["name"] in repos]
+
+    click.echo(f"Harness: {manifest.get('name') or manifest_path.parent.name}")
+    click.echo(f"Manifest: {manifest_path}")
+    results = []
+    incomplete = 0
+
+    for entry in selected:
+        name = entry["name"]
+        path = entry["path"]
+        if not entry["present"]:
+            results.append((name, "skipped (present: false)"))
+            continue
+        if not path.is_dir():
+            results.append((name, f"failed (missing: {path})"))
+            incomplete += 1
+            continue
+
+        status = _git(path, "status", "--porcelain")
+        if status.returncode != 0:
+            detail = (status.stderr or status.stdout).strip().splitlines()
+            results.append((name, f"failed ({detail[-1] if detail else 'not a git repository'})"))
+            incomplete += 1
+            continue
+        if status.stdout.strip():
+            results.append((name, "skipped (uncommitted changes)"))
+            incomplete += 1
+            continue
+        if dry_run:
+            results.append((name, "would pull"))
+            continue
+
+        args = ["pull", "--ff-only"]
+        if prune:
+            args.append("--prune")
+        update = _git(path, *args)
+        if update.returncode != 0:
+            detail = (update.stderr or update.stdout).strip().splitlines()
+            results.append((name, f"failed ({detail[-1] if detail else 'git pull failed'})"))
+            incomplete += 1
+            continue
+        head = _git(path, "log", "-1", "--oneline")
+        results.append((name, head.stdout.strip() or "updated"))
+
+    click.echo()
+    click.secho("Summary", bold=True)
+    width = max((len(name) for name, _ in results), default=0)
+    for name, status in results:
+        color = "red" if status.startswith("failed") else "yellow" if status.startswith("skipped") else "green"
+        click.secho(f"  {name:<{width}}  {status}", fg=color)
+    if incomplete:
+        raise click.exceptions.Exit(1)

{evo_cli-0.11.3 → evo_cli-0.11.4}/evo_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.11.3
+Version: 0.11.4
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli
@@ -16,6 +16,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cryptography>=41.0
 Requires-Dist: paramiko>=2.7.0
+Requires-Dist: PyYAML>=6.0
 Requires-Dist: rich>=13.0
 Requires-Dist: rich-click>=1.8
 Provides-Extra: test
@@ -112,3 +113,24 @@ Options:
 - `-y, --yes` - Skip the confirmation prompt
 - `-f, --force` - Apply the fix even if the version is not in the affected range
 - `--unpin` - Undo the fix: re-enable the auto-updater and install the latest build
+
+#### Harness Repositories
+
+Fast-forward every available repository declared in a harness manifest:
+
+```bash
+evo harness pull
+```
+
+Run the command from a harness directory or any registered member repository. Use `--harness PATH`
+when a repository belongs to multiple harnesses or the harness is not registered.
+
+```bash
+evo harness pull --harness ~/github/my-project-harness
+evo harness pull --repo backend --repo frontend
+evo harness pull --dry-run
+```
+
+The command reads `harness.yaml` and its optional `harness.local.yaml` overlay. Repositories marked
+`present: false` are skipped. Repositories with uncommitted changes are not modified, and every pull
+uses `git pull --ff-only` so the command never creates merge commits.

{evo_cli-0.11.3 → evo_cli-0.11.4}/evo_cli.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ evo_cli/commands/download.py
 evo_cli/commands/fix_claude.py
 evo_cli/commands/gdrive.py
 evo_cli/commands/gh.py
+evo_cli/commands/harness.py
 evo_cli/commands/hwid.py
 evo_cli/commands/hwid_reset.py
 evo_cli/commands/localproxy.py
@@ -43,6 +44,7 @@ tests/test_console.py
 tests/test_download.py
 tests/test_fix_claude.py
 tests/test_gh.py
+tests/test_harness.py
 tests/test_mcp.py
 tests/test_opencode.py
 tests/test_plantuml.py

{evo_cli-0.11.3 → evo_cli-0.11.4}/evo_cli.egg-info/requires.txt

@@ -1,5 +1,6 @@
 cryptography>=41.0
 paramiko>=2.7.0
+PyYAML>=6.0
 rich>=13.0
 rich-click>=1.8
 

{evo_cli-0.11.3 → evo_cli-0.11.4}/pyproject.toml

@@ -20,6 +20,7 @@ classifiers = [
 dependencies = [
     "cryptography>=41.0",
     "paramiko>=2.7.0",
+    "PyYAML>=6.0",
     "rich>=13.0",
     "rich-click>=1.8",
 ]

evo_cli-0.11.4/tests/test_harness.py

@@ -0,0 +1,136 @@
+import json
+import subprocess
+
+from click.testing import CliRunner
+
+from evo_cli.cli import cli
+from evo_cli.commands import harness as harness_command
+
+
+def _result(returncode=0, stdout="", stderr=""):
+    return subprocess.CompletedProcess([], returncode, stdout, stderr)
+
+
+def _write_harness(root, workspace):
+    root.mkdir()
+    (root / "harness.yaml").write_text(
+        f"name: test-cluster\nworkspace: {workspace.as_posix()}\nrepos:\n"
+        "- name: alpha\n  present: true\n"
+        "- name: beta\n  present: true\n",
+        encoding="utf-8",
+    )
+
+
+def test_harness_command_is_registered():
+    assert "harness" in cli.commands
+    assert "pull" in cli.commands["harness"].commands
+
+
+def test_pull_dry_run_honors_local_present_override(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    (workspace / "alpha").mkdir()
+    (workspace / "beta").mkdir()
+    root = tmp_path / "cluster"
+    _write_harness(root, workspace)
+    (root / "harness.local.yaml").write_text("present:\n  beta: false\n", encoding="utf-8")
+    calls = []
+
+    def fake_git(path, *args):
+        calls.append((path, args))
+        return _result()
+
+    monkeypatch.setattr(harness_command, "_git", fake_git)
+    result = CliRunner().invoke(cli, ["harness", "pull", "--harness", str(root), "--dry-run"])
+
+    assert result.exit_code == 0
+    assert "alpha  would pull" in result.output
+    assert "beta   skipped (present: false)" in result.output
+    assert calls == [(workspace / "alpha", ("status", "--porcelain"))]
+
+
+def test_pull_refuses_dirty_repo(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    (workspace / "alpha").mkdir()
+    root = tmp_path / "cluster"
+    _write_harness(root, workspace)
+    (root / "harness.local.yaml").write_text("present:\n  beta: false\n", encoding="utf-8")
+    monkeypatch.setattr(harness_command, "_git", lambda path, *args: _result(stdout=" M local.txt\n"))
+
+    result = CliRunner().invoke(cli, ["harness", "pull", "--harness", str(root)])
+
+    assert result.exit_code == 1
+    assert "alpha  skipped (uncommitted changes)" in result.output
+
+
+def test_pull_uses_fast_forward_and_prune(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    (workspace / "alpha").mkdir()
+    root = tmp_path / "cluster"
+    _write_harness(root, workspace)
+    calls = []
+
+    def fake_git(path, *args):
+        calls.append((path, args))
+        if args[0] == "log":
+            return _result(stdout="abc123 Latest change\n")
+        return _result()
+
+    monkeypatch.setattr(harness_command, "_git", fake_git)
+    result = CliRunner().invoke(cli, ["harness", "pull", "--harness", str(root), "--repo", "alpha"])
+
+    assert result.exit_code == 0
+    assert "abc123 Latest change" in result.output
+    assert calls == [
+        (workspace / "alpha", ("status", "--porcelain")),
+        (workspace / "alpha", ("pull", "--ff-only", "--prune")),
+        (workspace / "alpha", ("log", "-1", "--oneline")),
+    ]
+
+
+def test_pull_discovers_manifest_from_environment(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    (workspace / "alpha").mkdir()
+    root = tmp_path / "cluster"
+    _write_harness(root, workspace)
+    monkeypatch.setenv("EVO_HARNESS", str(root))
+    monkeypatch.setattr(harness_command, "_git", lambda path, *args: _result())
+
+    result = CliRunner().invoke(cli, ["harness", "pull", "--repo", "alpha", "--dry-run"])
+
+    assert result.exit_code == 0
+    assert "Harness: test-cluster" in result.output
+
+
+def test_pull_discovers_registered_member_repo(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    member = workspace / "alpha"
+    member.mkdir()
+    root = tmp_path / "cluster"
+    _write_harness(root, workspace)
+    registry = tmp_path / "registry.json"
+    registry.write_text(json.dumps({"clusters": [{"root": str(root)}]}), encoding="utf-8")
+    monkeypatch.chdir(member)
+    monkeypatch.setenv("EVO_HARNESS_REGISTRY", str(registry))
+    monkeypatch.setattr(harness_command, "_git", lambda path, *args: _result())
+
+    result = CliRunner().invoke(cli, ["harness", "pull", "--repo", "alpha", "--dry-run"])
+
+    assert result.exit_code == 0
+    assert f"Manifest: {root / 'harness.yaml'}" in result.output
+
+
+def test_pull_rejects_unknown_repo(tmp_path):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    root = tmp_path / "cluster"
+    _write_harness(root, workspace)
+
+    result = CliRunner().invoke(cli, ["harness", "pull", "--harness", str(root), "--repo", "missing"])
+
+    assert result.exit_code == 1
+    assert "Unknown repo name(s): missing" in result.output

evo_cli-0.11.3/evo_cli/VERSION

@@ -1 +0,0 @@
-0.11.3