gator-command 1.0.0__py3-none-any.whl

gator_command/scripts/gator-init-command-post.py

@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+"""
+gator init (command post) — Branded boot sequence for the Gator Command post.
+
+Shows fleet-level status: registered repos with their gator generation,
+charter coverage, active threads, inbox items, and issues. This is the
+command-post counterpart to gator-init.py (which runs in governed repos).
+
+Usage:
+    python gator-command/scripts/gator-init-command-post.py
+    python gator-command/scripts/gator-init-command-post.py --json
+
+@reads: gator-command/ directory, registry.md, active-threads/, inbox.md, issues.md, roadmap.md
+@reads: .gator/ in each registered repo (read-only fleet scan)
+@writes: .git/hooks/ (self-heal only when hooks are missing or stale)
+"""
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+from gator_core import (
+    get_version, find_command_post, normalize_path, parse_registry,
+    ensure_utf8_stdout, import_sibling, GATOR_MARK_LINES,
+)
+
+VERSION = get_version()
+
+TAGLINE = "command post online. fleet status follows."
+
+
+def scan_repo(repo_entry):
+    """Scan a registered repo's .gator/ for status info.
+
+    @reads: .gator/ in the repo (read-only)
+    @does-not-own: modifying any fleet repo files
+    """
+    repo_path = Path(normalize_path(repo_entry["path"]))
+    gator_dir = repo_path / ".gator"
+
+    info = {
+        "name": repo_entry["name"],
+        "exists": repo_path.is_dir(),
+        "has_gator": gator_dir.is_dir(),
+        "generation": None,
+        "charters": 0,
+        "threads": 0,
+        "status_icon": "?",
+    }
+
+    if not info["exists"]:
+        # Repo not found locally — may be on a different machine
+        has_remote = repo_entry.get("remote", "—") not in ("—", "", None)
+        info["status_icon"] = "~" if has_remote else "?"
+        info["note"] = "remote only" if has_remote else "not found locally"
+        return info
+
+    if not info["has_gator"]:
+        info["status_icon"] = "✗"
+        info["note"] = "no .gator/"
+        return info
+
+    # Read generation
+    version_file = gator_dir / ".gator-version"
+    if version_file.exists():
+        for line in version_file.read_text(encoding="utf-8", errors="replace").splitlines():
+            if line.startswith("generation:"):
+                info["generation"] = line.split(":", 1)[1].strip()
+    elif (gator_dir / "command-post.md").exists():
+        info["generation"] = "1"
+    else:
+        info["generation"] = "0"
+
+    # Count charters
+    charters_dir = gator_dir / "charters"
+    if charters_dir.is_dir():
+        skip = {"_template.md", "README.md", "INDEX.md"}
+        info["charters"] = len([
+            f for f in charters_dir.iterdir()
+            if f.suffix == ".md" and f.name not in skip
+        ])
+
+    # Count threads
+    for subdir_name in ("active-threads", "threads"):
+        subdir = gator_dir / subdir_name
+        if subdir.is_dir():
+            info["threads"] += len([
+                f for f in subdir.iterdir()
+                if f.suffix == ".md" and f.name != ".gitkeep"
+            ])
+
+    info["status_icon"] = "✓"
+    return info
+
+
+# --- Command post internals ---
+
+def count_active_threads(command_post):
+    """Count active threads in the command post.
+
+    @reads: gator-command/active-threads/
+    """
+    threads_dir = command_post / "gator-command" / "active-threads"
+    if not threads_dir.is_dir():
+        return 0
+    return len([f for f in threads_dir.iterdir() if f.suffix == ".md"])
+
+
+def count_inbox_items(command_post):
+    """Count pending inbox items.
+
+    @reads: gator-command/inbox.md
+    """
+    inbox = command_post / "gator-command" / "inbox.md"
+    if not inbox.exists():
+        return 0
+
+    count = 0
+    text = inbox.read_text(encoding="utf-8", errors="replace")
+    for line in text.splitlines():
+        if line.strip().startswith("- "):
+            count += 1
+    return count
+
+
+def count_issues(command_post):
+    """Count open issues.
+
+    @reads: gator-command/issues.md
+    """
+    issues = command_post / "gator-command" / "issues.md"
+    if not issues.exists():
+        return 0
+
+    count = 0
+    text = issues.read_text(encoding="utf-8", errors="replace")
+    for line in text.splitlines():
+        if "**Status**: Open" in line or "**Status**: Working" in line:
+            count += 1
+    return count
+
+
+def count_artifacts(command_post):
+    """Count artifacts.
+
+    @reads: gator-command/artifacts/
+    """
+    artifacts_dir = command_post / "gator-command" / "artifacts"
+    if not artifacts_dir.is_dir():
+        return 0
+    return len([f for f in artifacts_dir.iterdir() if f.suffix == ".md"])
+
+
+# --- Hook self-heal ---
+
+def _ensure_own_hooks(command_post):
+    """Self-heal git hooks for the command post's own repo.
+
+    The command post is itself a governed repo. Delegates to
+    gator-init.ensure_git_hooks() so hook format stays centralized.
+    """
+    gator_dir = command_post / ".gator"
+    if not gator_dir.is_dir():
+        return {"status": "unavailable", "detail": "no .gator/", "adds": 0, "updates": 0}
+
+    try:
+        gator_init = import_sibling("gator-init")
+    except ImportError:
+        return {"status": "error", "detail": "gator-init.py not found", "adds": 0, "updates": 0}
+    if gator_init is None:
+        return {"status": "error", "detail": "gator-init.py not found", "adds": 0, "updates": 0}
+
+    return gator_init.ensure_git_hooks(command_post, gator_dir)
+
+
+# --- Output formatting ---
+
+def format_check(label, value, width=16):
+    """Format a single status line."""
+    return f"  \u2713 {label:<{width}}{value}"
+
+
+def format_repo_line(info):
+    """Format a single fleet repo status line."""
+    icon = info["status_icon"]
+    name = info["name"]
+
+    # If repo isn't locally available, show the note instead of details
+    if "note" in info:
+        return f"    {icon} {name:<20}{info['note']}"
+
+    gen = f"gen {info['generation']}" if info["generation"] else "unknown"
+
+    parts = []
+    if info["charters"] > 0:
+        parts.append(f"{info['charters']} charters")
+    if info["threads"] > 0:
+        parts.append(f"{info['threads']} threads")
+
+    detail = " \u00b7 ".join(parts) if parts else "fresh"
+
+    return f"    {icon} {name:<20}{gen:<8}{detail}"
+
+
+def print_boot_sequence(command_post, hook_status):
+    """Print the command-post boot sequence.
+
+    @reads: all detection functions above
+    @writes: stdout
+    """
+    # Header
+    print()
+    for line in GATOR_MARK_LINES:
+        print(f"  {line}")
+    print()
+    print(f"  {VERSION}  ·  navigation coding, governed")
+    print()
+    print(f"  $ gator init")
+    print()
+
+    # Command post status
+    thread_count = count_active_threads(command_post)
+    inbox_count = count_inbox_items(command_post)
+    issue_count = count_issues(command_post)
+    artifact_count = count_artifacts(command_post)
+
+    print(f"    command post online")
+    print()
+    print(format_check("active threads", f"{thread_count}"))
+    print(format_check("inbox", f"{inbox_count} items pending" if inbox_count > 0 else "clear"))
+    print(format_check("issues", f"{issue_count} open" if issue_count > 0 else "none"))
+    print(format_check("artifacts", f"{artifact_count}"))
+    print(format_check("hooks", hook_status["detail"]))
+
+    # Fleet
+    repos = parse_registry(command_post)
+    if repos:
+        print()
+        print(f"    fleet: {len(repos)} repos")
+        print()
+        for entry in repos:
+            info = scan_repo(entry)
+            print(format_repo_line(info))
+
+    # Tagline
+    print()
+    print(f"  {TAGLINE}")
+    print(f"  \u25b8")
+    print()
+
+
+def print_json(command_post, hook_status):
+    """Print command post status as JSON."""
+    repos = parse_registry(command_post)
+    fleet = [scan_repo(entry) for entry in repos]
+
+    data = {
+        "version": VERSION,
+        "type": "command-post",
+        "active_threads": count_active_threads(command_post),
+        "inbox_items": count_inbox_items(command_post),
+        "open_issues": count_issues(command_post),
+        "artifacts": count_artifacts(command_post),
+        "hooks": hook_status,
+        "fleet": fleet,
+    }
+
+    print(json.dumps(data, indent=2))
+
+
+# --- Entry point ---
+
+def main():
+    ensure_utf8_stdout()
+
+    parser = argparse.ArgumentParser(
+        description="Gator init (command post) — fleet-level boot sequence."
+    )
+    parser.add_argument(
+        "--path", "-p",
+        help="Path to the command post (default: current directory)",
+    )
+    parser.add_argument(
+        "--json", "-j",
+        action="store_true",
+        help="Output as JSON instead of formatted display",
+    )
+    args = parser.parse_args()
+
+    command_post = find_command_post(args.path)
+
+    if not command_post:
+        print()
+        for line in GATOR_MARK_LINES:
+            print(f"  {line}")
+        print()
+        print(f"  {VERSION}  ·  navigation coding, governed")
+        print()
+        print("  no command post found.")
+        print()
+        sys.exit(1)
+
+    # Self-heal hooks for the command post's own repo
+    hook_status = _ensure_own_hooks(command_post)
+
+    if args.json:
+        print_json(command_post, hook_status)
+    else:
+        print_boot_sequence(command_post, hook_status)
+
+
+if __name__ == "__main__":
+    main()