gator-command 1.0.0__py3-none-any.whl

gator_command/scripts/memex_formatters.py

@@ -0,0 +1,191 @@
+"""
+memex_formatters.py — Output formatters for the Memex CLI.
+
+Extracted from memex.py to reduce monolithic file size. Contains
+PrettyFormatter (terminal ANSI output) and JsonFormatter (structured
+JSON for agent consumption).
+
+Usage:
+    from memex_formatters import get_formatter
+    fmt = get_formatter("json")  # or "pretty"
+    print(fmt.status(data))
+"""
+
+import datetime as dt
+import json
+
+# ── Terminal colors ──────────────────────────────────────────────────────────
+
+RED = "\033[0;31m"
+YELLOW = "\033[0;33m"
+GREEN = "\033[0;32m"
+CYAN = "\033[0;36m"
+BOLD = "\033[1m"
+DIM = "\033[2m"
+NC = "\033[0m"
+
+TODAY = dt.date.today()
+
+
+class PrettyFormatter:
+    """Human-readable terminal output."""
+
+    def status(self, data: dict) -> str:
+        lines = []
+        role_info = data.get("role", {})
+        role_name = data.get("role_name", "architect")
+
+        # Header
+        lines.append(f"{BOLD}Memex Status{NC}  {DIM}role: {role_name}{NC}")
+        lines.append("")
+
+        # Graph health (if available)
+        health = data.get("graph_health")
+        if health:
+            verdict = health["verdict"]
+            score = health["overall"]
+            color = GREEN if verdict == "HEALTHY" else (YELLOW if verdict == "FAIR" else RED)
+            lines.append(f"  Graph:   {color}{verdict}{NC} ({score}/100)  "
+                         f"{DIM}{health['nodes']} threads, {health['edges']} edges{NC}")
+
+        # Inbox
+        inbox = data.get("inbox", [])
+        lines.append(f"  Inbox:   {len(inbox)} item(s)")
+
+        # Patterns due
+        patterns = data.get("patterns_due", [])
+        if patterns:
+            lines.append(f"  {YELLOW}Due:{NC}     {len(patterns)} payment(s) upcoming")
+            for p in patterns:
+                lines.append(f"           {p['vendor']} {p['amount']} — {p['due']}")
+
+        # Audit findings
+        findings = data.get("audit_findings", [])
+        if findings:
+            lines.append(f"  Audit:   {YELLOW}{len(findings)} open finding(s){NC}")
+
+        lines.append("")
+
+        # Active threads
+        threads = data.get("active_threads", [])
+        if threads:
+            lines.append(f"{BOLD}Active Threads{NC}  ({len(threads)})")
+            for t in threads:
+                stale_flag = f"  {DIM}({t['staleness_days']}d ago){NC}" if t["staleness_days"] > 7 else ""
+                hits_str = f"{DIM}hits:{t['hits']}{NC}"
+                lines.append(f"  {t['title']}  {hits_str}{stale_flag}")
+
+                # Next Up items (in full mode)
+                for item in t.get("next_up", []):
+                    lines.append(f"    {CYAN}→{NC} {item}")
+
+            lines.append("")
+
+        # Inbox items (full mode)
+        if data.get("show_inbox_items") and inbox:
+            lines.append(f"{BOLD}Inbox Items{NC}")
+            for i, item in enumerate(inbox, 1):
+                # Truncate long items for terminal readability
+                display = item if len(item) <= 120 else item[:117] + "..."
+                lines.append(f"  {i}. {display}")
+            lines.append("")
+
+        return "\n".join(lines)
+
+    def search_results(self, results: list[dict]) -> str:
+        if not results:
+            return f"{DIM}No results found.{NC}"
+        lines = [f"{BOLD}{len(results)} result(s){NC}", ""]
+        for r in results:
+            lines.append(f"  {GREEN}{r['file']}{NC}  {DIM}{r['type']}{NC}")
+            for match in r.get("matches", [])[:3]:
+                lines.append(f"    {match['line_num']}: {match['text'].strip()}")
+            lines.append("")
+        return "\n".join(lines)
+
+    def thread_view(self, data: dict) -> str:
+        lines = []
+        lines.append(f"{BOLD}{data['title']}{NC}")
+
+        # Build metadata line based on what's available
+        meta_parts = [data['tier']]
+        if data.get("status"):
+            status_colors = {"building": YELLOW, "shipped": GREEN, "designing": CYAN,
+                             "considering": DIM, "maintaining": GREEN}
+            sc = status_colors.get(data["status"], "")
+            meta_parts.append(f"status: {sc}{data['status']}{NC}")
+        if data.get("hits"):
+            meta_parts.append(f"hits: {data['hits']}")
+        if data.get("owner"):
+            meta_parts.append(f"owner: {data['owner']}")
+        meta_parts.append(f"last-touched: {data['last_touched']}")
+        if data.get("tags"):
+            meta_parts.append(f"tags: {', '.join(data['tags'])}")
+        lines.append(f"{DIM}{' | '.join(meta_parts)}{NC}")
+        lines.append("")
+
+        # If showing a specific section, show just that
+        if data.get("_section_content") is not None:
+            lines.append(f"{BOLD}{data['_section_name']}{NC}")
+            for line in data["_section_content"]:
+                lines.append(f"  {line}")
+            lines.append("")
+            return "\n".join(lines)
+
+        # Summary / Overview
+        if data.get("summary"):
+            label = "Overview" if data["tier"] == "system" else "Summary"
+            lines.append(f"{BOLD}{label}{NC}")
+            for line in data["summary"]:
+                lines.append(f"  {line}")
+            lines.append("")
+
+        # Section list (for system docs — shows navigable structure)
+        if data["tier"] in ("system", "report") and data.get("sections"):
+            lines.append(f"{BOLD}Sections{NC}")
+            for s in data["sections"]:
+                lines.append(f"  {DIM}--section{NC} \"{s}\"")
+            lines.append("")
+
+        if data.get("connections"):
+            lines.append(f"{BOLD}Connections{NC}")
+            for line in data["connections"]:
+                if line.strip():
+                    lines.append(f"  {line.strip()}")
+            lines.append("")
+        if data.get("next_up"):
+            lines.append(f"{BOLD}Next Up{NC}")
+            for item in data["next_up"]:
+                lines.append(f"  {CYAN}→{NC} {item}")
+            lines.append("")
+        return "\n".join(lines)
+
+
+class JsonFormatter:
+    """Structured JSON output for agent consumption."""
+
+    def status(self, data: dict) -> str:
+        output = {
+            "role": data.get("role_name", "pi"),
+            "date": TODAY.isoformat(),
+            "graph_health": data.get("graph_health"),
+            "inbox_count": len(data.get("inbox", [])),
+            "inbox_items": data.get("inbox") if data.get("show_inbox_items") else None,
+            "patterns_due": data.get("patterns_due", []),
+            "audit_findings": data.get("audit_findings", []),
+            "active_threads": data.get("active_threads", []),
+        }
+        return json.dumps(output, indent=2, default=str)
+
+    def search_results(self, results: list[dict]) -> str:
+        return json.dumps({"results": results, "count": len(results)}, indent=2, default=str)
+
+    def thread_view(self, data: dict) -> str:
+        return json.dumps(data, indent=2, default=str)
+
+
+def get_formatter(fmt: str):
+    """Return the appropriate formatter."""
+    if fmt == "json":
+        return JsonFormatter()
+    return PrettyFormatter()

gator_command/scripts/memex_state.py

@@ -0,0 +1,236 @@
+"""Shared state and parsing helpers for the Memex CLI."""
+
+from __future__ import annotations
+
+import calendar
+import datetime as dt
+import re
+from pathlib import Path
+
+from generate_wiki import Thread, parse_frontmatter, parse_sections
+
+
+SCRIPTS_DIR = Path(__file__).resolve().parent
+TODAY = dt.date.today()
+
+
+def find_repo_root(override: str | None = None) -> Path:
+    """Walk up from the script to find the repo root (contains gator-command/)."""
+    if override:
+        path = Path(override).resolve()
+        if (path / "gator-command").is_dir():
+            return path
+        print(f"Not a Memex repo: {path} (no gator-command/ directory)")
+        raise SystemExit(1)
+
+    candidate = SCRIPTS_DIR.parent.parent.parent
+    if (candidate / "gator-command").is_dir():
+        return candidate
+
+    cwd = Path.cwd()
+    if (cwd / "gator-command").is_dir():
+        return cwd
+    return candidate
+
+
+def load_roles(repo_root: Path) -> dict:
+    """Load role definitions from gator-command/roles.yaml."""
+    roles_path = repo_root / "gator-command" / "roles.yaml"
+    if not roles_path.exists():
+        return {}
+    try:
+        import yaml
+
+        return yaml.safe_load(roles_path.read_text(encoding="utf-8")).get("roles", {})
+    except ImportError:
+        return parse_simple_yaml(roles_path)
+
+
+def parse_simple_yaml(path: Path) -> dict:
+    """Bare-minimum YAML parser for roles.yaml when PyYAML is unavailable."""
+    text = path.read_text(encoding="utf-8")
+    roles: dict = {}
+    current_role: str | None = None
+
+    for line in text.splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+
+        if stripped == "roles:":
+            continue
+
+        if line.startswith("  ") and not line.startswith("    ") and stripped.endswith(":"):
+            current_role = stripped[:-1]
+            roles[current_role] = {}
+            continue
+
+        if line.startswith("    ") and current_role and ":" in stripped:
+            key, value = stripped.split(":", 1)
+            key = key.strip()
+            value = value.strip()
+
+            if value.startswith("[") and value.endswith("]"):
+                value = [item.strip() for item in value[1:-1].split(",") if item.strip()]
+            elif value == "null":
+                value = None
+
+            roles[current_role][key] = value
+
+    return roles
+
+
+def get_role(roles: dict, role_name: str | None) -> dict:
+    """Get role config, defaulting to architect for humans."""
+    role_name = role_name or "architect"
+    if role_name not in roles:
+        return {
+            "description": f"Unknown role: {role_name}",
+            "permissions": ["read"],
+            "provenance": f"-{role_name}",
+            "session-open-emphasis": [],
+        }
+    return roles[role_name]
+
+
+def read_file_safe(path: Path) -> str:
+    """Read a file, returning empty string if it doesn't exist."""
+    if not path.exists():
+        return ""
+    return path.read_text(encoding="utf-8")
+
+
+def parse_inbox(memex_dir: Path) -> list[str]:
+    """Parse inbox items (lines starting with '- ')."""
+    items = []
+    for line in read_file_safe(memex_dir / "inbox.md").splitlines():
+        stripped = line.strip()
+        if stripped.startswith("- ") and not stripped.startswith("- Drop anything"):
+            items.append(stripped[2:])
+    return items
+
+
+def parse_patterns(memex_dir: Path) -> list[dict]:
+    """Parse monthly bills/patterns and find items due within 2 days."""
+    bills_path = memex_dir / "patterns" / "monthly-bills.md"
+    if not bills_path.exists():
+        return []
+
+    text = bills_path.read_text(encoding="utf-8")
+    upcoming = []
+    days_in_month = calendar.monthrange(TODAY.year, TODAY.month)[1]
+
+    for line in text.splitlines():
+        stripped = line.strip()
+        if not stripped.startswith("|"):
+            continue
+        cols = [col.strip() for col in stripped.split("|")]
+        if len(cols) < 4:
+            continue
+
+        day_str = cols[1]
+        try:
+            day = int(re.sub(r"(st|nd|rd|th)", "", day_str))
+        except (ValueError, IndexError):
+            continue
+
+        try:
+            if day >= TODAY.day:
+                due_date = TODAY.replace(day=min(day, days_in_month))
+            else:
+                next_month = TODAY.month + 1
+                next_year = TODAY.year
+                if next_month > 12:
+                    next_month = 1
+                    next_year += 1
+                next_days_in_month = calendar.monthrange(next_year, next_month)[1]
+                due_date = dt.date(next_year, next_month, min(day, next_days_in_month))
+        except ValueError:
+            continue
+
+        delta = (due_date - TODAY).days
+        if 0 <= delta <= 2:
+            upcoming.append({
+                "day": day,
+                "vendor": cols[2] if len(cols) > 2 else "?",
+                "amount": cols[3] if len(cols) > 3 else "?",
+                "due": "today" if delta == 0 else f"in {delta} day(s)",
+            })
+
+    return upcoming
+
+
+def parse_audit_tracker(memex_dir: Path) -> list[str]:
+    """Parse open findings from audit-tracker.md."""
+    findings = []
+    in_open = False
+    for line in read_file_safe(memex_dir / "audit-tracker.md").splitlines():
+        stripped = line.strip()
+        if stripped == "## Open":
+            in_open = True
+            continue
+        if stripped.startswith("## "):
+            in_open = False
+        if in_open and stripped.startswith("- "):
+            findings.append(stripped[2:])
+    return findings
+
+
+def get_thread_next_up(thread_path: Path) -> list[str]:
+    """Extract Next Up items from a thread file."""
+    text = read_file_safe(thread_path)
+    _, sections = parse_sections(text.split("---\n", 2)[-1] if text.startswith("---") else text)
+    return [
+        line.strip()[2:]
+        for line in sections.get("Next Up", [])
+        if line.strip().startswith("- ")
+    ]
+
+
+def thread_staleness(thread: Thread) -> int:
+    """Days since last touched."""
+    try:
+        last = dt.date.fromisoformat(thread.last_touched)
+        return (TODAY - last).days
+    except (ValueError, TypeError):
+        return 999
+
+
+def resolve_thread(memex_dir: Path, name: str) -> Path | None:
+    """Resolve a thread name to a file path (active-threads/ then threads/)."""
+    for subdir in ("active-threads", "threads"):
+        dirpath = memex_dir / subdir
+        if not dirpath.is_dir():
+            continue
+        exact = dirpath / f"{name}.md"
+        if exact.exists():
+            return exact
+        for path in dirpath.glob("*.md"):
+            if path.name == "_TEMPLATE.md":
+                continue
+            if name.lower() in path.stem.lower():
+                return path
+    return None
+
+
+def list_thread_names(memex_dir: Path) -> list[str]:
+    """List all thread stems for error suggestions."""
+    names = []
+    for subdir in ("active-threads", "threads"):
+        dirpath = memex_dir / subdir
+        if dirpath.is_dir():
+            names.extend(
+                path.stem for path in dirpath.glob("*.md") if path.name != "_TEMPLATE.md"
+            )
+    return sorted(names)
+
+
+def get_thread_title(path: Path) -> str:
+    """Extract the title from a thread file (frontmatter title or H1)."""
+    frontmatter, _ = parse_frontmatter(path.read_text(encoding="utf-8"))
+    if frontmatter.get("title"):
+        return frontmatter["title"]
+    for line in path.read_text(encoding="utf-8").splitlines():
+        if line.startswith("# ") and not line.startswith("## "):
+            return line[2:].strip()
+    return path.stem