nexo-brain 2.1.0 → 2.2.0

package/src/scripts/nexo-followup-hygiene 2.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+import os
+"""
+NEXO Followup Hygiene — Weekly cleanup of followup/reminder statuses.
+
+Runs Sundays via LaunchAgent (or manually). Tasks:
+1. Normalize dirty statuses (COMPLETED YYYY-MM-DD -> COMPLETED)
+2. Flag PENDING followups >14 days without updates as STALE
+3. Generate summary of orphaned/forgotten followups for synthesis
+
+No CLI needed — this is pure mechanical cleanup.
+"""
+
+import json
+import sqlite3
+import sys
+from datetime import datetime, date, timedelta
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+
+NEXO_DB = NEXO_HOME / "data" / "nexo.db"
+COORD_DIR = NEXO_HOME / "coordination"
+LOG_FILE = NEXO_HOME / "logs" / "followup-hygiene.log"
+
+TODAY = date.today().isoformat()
+
+
+def log(msg):
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    line = f"[{ts}] {msg}"
+    print(line, flush=True)
+    LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    with open(LOG_FILE, "a") as f:
+        f.write(line + "\n")
+
+
+def main():
+    log("=== Followup Hygiene starting ===")
+
+    if not NEXO_DB.exists():
+        log("nexo.db not found")
+        return
+
+    conn = sqlite3.connect(str(NEXO_DB))
+    conn.row_factory = sqlite3.Row
+
+    # 1. Normalize dirty statuses
+    dirty_f = conn.execute("SELECT COUNT(*) FROM followups WHERE status LIKE 'COMPLETED %'").fetchone()[0]
+    dirty_r = conn.execute("SELECT COUNT(*) FROM reminders WHERE status LIKE 'COMPLETED %'").fetchone()[0]
+
+    if dirty_f > 0:
+        conn.execute("UPDATE followups SET status='COMPLETED' WHERE status LIKE 'COMPLETED %'")
+        log(f"Normalized {dirty_f} dirty followup statuses")
+
+    if dirty_r > 0:
+        conn.execute("UPDATE reminders SET status='COMPLETED' WHERE status LIKE 'COMPLETED %'")
+        log(f"Normalized {dirty_r} dirty reminder statuses")
+
+    # 2. Flag stale followups (PENDING >14 days, no updates)
+    cutoff = (date.today() - timedelta(days=14)).isoformat()
+    stale = conn.execute(
+        "SELECT id, description, date, updated_at FROM followups "
+        "WHERE status NOT LIKE 'COMPLETED%' "
+        "AND status NOT IN ('DELETED','archived','blocked','waiting') "
+        "AND date != '' AND date < ? "
+        "ORDER BY date",
+        (cutoff,)
+    ).fetchall()
+
+    if stale:
+        log(f"Found {len(stale)} stale followups (>14 days overdue):")
+        for s in stale[:10]:
+            log(f"  {s['id']}: {s['description'][:60]} (due: {s['date']})")
+
+    # 3. Orphaned followups (no date, no recent update)
+    orphans = conn.execute(
+        "SELECT id, description FROM followups "
+        "WHERE status NOT LIKE 'COMPLETED%' "
+        "AND status NOT IN ('DELETED','archived','blocked','waiting') "
+        "AND (date IS NULL OR date = '') "
+        "ORDER BY id"
+    ).fetchall()
+
+    if orphans:
+        log(f"Found {len(orphans)} orphaned followups (no date):")
+        for o in orphans[:10]:
+            log(f"  {o['id']}: {o['description'][:60]}")
+
+    conn.commit()
+    conn.close()
+
+    # 4. Write summary for synthesis
+    summary = {
+        "date": TODAY,
+        "dirty_normalized": dirty_f + dirty_r,
+        "stale_count": len(stale) if stale else 0,
+        "orphan_count": len(orphans) if orphans else 0,
+        "stale_ids": [s["id"] for s in stale[:20]] if stale else [],
+        "orphan_ids": [o["id"] for o in orphans[:20]] if orphans else [],
+    }
+
+    summary_file = COORD_DIR / "followup-hygiene-summary.json"
+    summary_file.parent.mkdir(parents=True, exist_ok=True)
+    summary_file.write_text(json.dumps(summary, indent=2))
+
+    log(f"Summary: {dirty_f + dirty_r} normalized, {len(stale) if stale else 0} stale, {len(orphans) if orphans else 0} orphans")
+    log("=== Followup Hygiene complete ===")
+
+
+if __name__ == "__main__":
+    main()

package/src/scripts/nexo-github-monitor 2.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+"""
+NEXO GitHub Monitor — Wrapper + CLI pattern.
+Python: gh CLI API calls, data collection.
+CLI: Generates rich analysis and suggested responses for issues/PRs.
+
+Runs at 08:00 via LaunchAgent.
+Results saved to ~/.nexo/github-status.json.
+"""
+
+import json
+import os
+import subprocess
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", Path.home() / ".nexo"))
+STATUS_FILE = NEXO_HOME / "github-status.json"
+LOG_FILE = NEXO_HOME / "logs" / "github-monitor.log"
+REPO = "wazionapps/nexo"
+CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
+
+
+def log(msg: str):
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    line = f"[{ts}] {msg}"
+    print(line, flush=True)
+    LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    with open(LOG_FILE, "a") as f:
+        f.write(line + "\n")
+
+
+def gh_api(endpoint: str) -> dict | list | None:
+    """Call GitHub API via gh."""
+    try:
+        result = subprocess.run(
+            ["gh", "api", endpoint],
+            capture_output=True, text=True, timeout=21600
+        )
+        if result.returncode == 0:
+            return json.loads(result.stdout)
+    except Exception:
+        pass
+    return None
+
+
+def collect_data():
+    """Collect all GitHub data — mechanical work."""
+    data = {
+        "timestamp": datetime.now().isoformat(),
+        "repo": REPO,
+        "issues": [],
+        "prs": [],
+        "latest_release": None,
+        "unreleased_commits": 0,
+    }
+
+    # Issues
+    log("Fetching issues...")
+    issues = gh_api(f"repos/{REPO}/issues?state=open&per_page=50")
+    if issues:
+        for issue in issues:
+            if "pull_request" in issue:
+                continue
+            item = {
+                "number": issue["number"],
+                "title": issue["title"][:80],
+                "body": (issue.get("body") or "")[:500],
+                "created": issue["created_at"][:10],
+                "comments": issue["comments"],
+                "labels": [l["name"] for l in issue.get("labels", [])],
+                "author": issue.get("user", {}).get("login", ""),
+            }
+            # Get comment bodies for context
+            if issue["comments"] > 0:
+                comments = gh_api(f"repos/{REPO}/issues/{issue['number']}/comments?per_page=5")
+                if comments:
+                    item["comment_bodies"] = [
+                        {"author": c.get("user", {}).get("login", ""), "body": c.get("body", "")[:300]}
+                        for c in comments[:5]
+                    ]
+            data["issues"].append(item)
+
+    # PRs
+    log("Fetching PRs...")
+    prs = gh_api(f"repos/{REPO}/pulls?state=open&per_page=50")
+    if prs:
+        for pr in prs:
+            reviews = gh_api(f"repos/{REPO}/pulls/{pr['number']}/reviews") or []
+            item = {
+                "number": pr["number"],
+                "title": pr["title"][:80],
+                "body": (pr.get("body") or "")[:500],
+                "author": pr["user"]["login"],
+                "created": pr["created_at"][:10],
+                "reviews": len(reviews),
+                "changed_files": pr.get("changed_files", 0),
+            }
+            data["prs"].append(item)
+
+    # Releases
+    log("Fetching releases...")
+    releases = gh_api(f"repos/{REPO}/releases?per_page=1")
+    if releases and len(releases) > 0:
+        data["latest_release"] = releases[0].get("tag_name", "none")
+        tag = releases[0].get("tag_name", "")
+        if tag:
+            try:
+                result = subprocess.run(
+                    ["gh", "api", f"repos/{REPO}/compare/{tag}...main"],
+                    capture_output=True, text=True, timeout=21600
+                )
+                if result.returncode == 0:
+                    compare = json.loads(result.stdout)
+                    data["unreleased_commits"] = compare.get("ahead_by", 0)
+            except Exception:
+                pass
+
+    return data
+
+
+def analyze_via_cli(data):
+    """Pass collected data to CLI for analysis and suggested responses."""
+    data_json = json.dumps(data, ensure_ascii=False)
+
+    prompt = f"""Analyze this GitHub repository status for NEXO Brain (wazionapps/nexo).
+
+DATA:
+{data_json}
+
+Generate a status report with:
+1. SUMMARY: counts of open issues, PRs, unresponded items
+2. For each UNRESPONDED ISSUE (comments=0): suggest a response in English (technical, helpful, friendly)
+3. For each PR: brief assessment (looks good / needs changes / needs review)
+4. RELEASE STATUS: if >10 unreleased commits, recommend a release
+5. ALERTS: anything needing immediate attention (stale issues >7d, etc.)
+
+Return as JSON:
+{{
+  "summary": {{
+    "open_issues": N,
+    "unresponded_issues": N,
+    "stale_issues": N,
+    "open_prs": N,
+    "unreviewed_prs": N,
+    "unreleased_commits": N
+  }},
+  "issue_responses": [
+    {{"number": N, "suggested_response": "text"}},
+    ...
+  ],
+  "pr_assessments": [
+    {{"number": N, "assessment": "text"}},
+    ...
+  ],
+  "alerts": ["alert1", ...],
+  "release_recommendation": "text or null"
+}}"""
+    )
+    if auth_check.returncode != 0:
+        # CLI not authenticated, skip gracefully
+        return ""
+
+    env = os.environ.copy()
+    env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
+    env.pop("CLAUDECODE", None)
+    env.pop("CLAUDE_CODE", None)
+
+    result = subprocess.run(
+        [str(CLAUDE_CLI), "-p", prompt,
+         "--model", "opus", "--output-format", "text",
+         "--allowedTools", "Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*"],
+        capture_output=True, text=True, timeout=21600, env=env
+    )
+
+    if result.returncode != 0:
+        log(f"CLI analysis failed: {result.stderr[:200]}")
+        return None
+
+    output = result.stdout.strip()
+    start = output.find("{")
+    end = output.rfind("}") + 1
+    if start >= 0 and end > start:
+        return json.loads(output[start:end])
+    return None
+
+
+def main():
+    log("=== NEXO GitHub Monitor ===")
+
+    # Step 1: Collect data (mechanical)
+    data = collect_data()
+
+    # Step 2: Analyze via CLI (intelligent)
+    log("Analyzing via CLI...")
+    analysis = analyze_via_cli(data)
+
+    # Build status file
+    status = {
+        "timestamp": data["timestamp"],
+        "repo": REPO,
+        "issues": {
+            "open": len(data["issues"]),
+            "unresponded": sum(1 for i in data["issues"] if i["comments"] == 0),
+            "stale": sum(1 for i in data["issues"]
+                        if i["comments"] == 0 and i["created"] < (datetime.now() - timedelta(days=7)).strftime('%Y-%m-%d')),
+            "items": [{"number": i["number"], "title": i["title"], "created": i["created"],
+                        "comments": i["comments"], "labels": i["labels"]} for i in data["issues"]],
+        },
+        "prs": {
+            "open": len(data["prs"]),
+            "unreviewed": sum(1 for p in data["prs"] if p["reviews"] == 0),
+            "items": [{"number": p["number"], "title": p["title"], "author": p["author"],
+                        "created": p["created"], "reviews": p["reviews"]} for p in data["prs"]],
+        },
+        "releases": {
+            "latest": data["latest_release"] or "none",
+            "unreleased_commits": data["unreleased_commits"],
+        },
+        "alerts": [],
+    }
+
+    # Merge CLI analysis
+    if analysis:
+        status["alerts"] = analysis.get("alerts", [])
+        status["issue_responses"] = analysis.get("issue_responses", [])
+        status["pr_assessments"] = analysis.get("pr_assessments", [])
+        status["release_recommendation"] = analysis.get("release_recommendation")
+    else:
+        # Fallback alerts without CLI
+        if status["issues"]["unresponded"] > 0:
+            status["alerts"].append(f"{status['issues']['unresponded']} issues without response")
+        if status["issues"]["stale"] > 0:
+            status["alerts"].append(f"{status['issues']['stale']} stale issues (>7d)")
+        if status["prs"]["unreviewed"] > 0:
+            status["alerts"].append(f"{status['prs']['unreviewed']} PRs awaiting review")
+        if data["unreleased_commits"] > 10:
+            status["alerts"].append(f"{data['unreleased_commits']} unreleased commits")
+
+    # Log summary
+    log(f"Issues: {status['issues']['open']} open ({status['issues']['unresponded']} unresponded)")
+    log(f"PRs: {status['prs']['open']} open ({status['prs']['unreviewed']} unreviewed)")
+    log(f"Latest release: {status['releases']['latest']}")
+    if status["alerts"]:
+        log(f"ALERTS: {'; '.join(status['alerts'])}")
+
+    # Save
+    STATUS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    STATUS_FILE.write_text(json.dumps(status, indent=2))
+    log(f"Status saved to {STATUS_FILE}")
+    log("=== Done ===")
+
+
+if __name__ == "__main__":
+    main()