nexo-brain 2.0.0 → 2.1.0

package/src/scripts/deep-sleep/analyze_session.py

@@ -1,217 +0,0 @@
-#!/usr/bin/env python3
-"""
-Deep Sleep — Step 2: Analyze transcripts with Claude CLI (bare mode).
-Sends each session to Claude opus for analysis, then consolidates findings.
-"""
-import json
-import os
-import subprocess
-import sys
-from datetime import datetime
-from pathlib import Path
-
-NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-
-PROMPT_FILE = Path(__file__).parent / "prompt.md"
-DEEP_SLEEP_DIR = NEXO_HOME / "operations" / "deep-sleep"
-MAX_TRANSCRIPT_CHARS = 150_000
-
-
-def build_transcript_text(session: dict) -> str:
-    """Build a readable transcript from a session."""
-    lines = [
-        f"## Session: {session['session_file']}",
-        f"Modified: {session['modified']}",
-        f"Messages: {session['message_count']}, Tool uses: {session['tool_use_count']}",
-        "",
-        "### Conversation"
-    ]
-    for msg in session["messages"]:
-        role = "USER" if msg["role"] == "user" else "NEXO"
-        lines.append(f"\n**{role}:**")
-        lines.append(msg["text"])
-
-    if session["tool_uses"]:
-        lines.append("\n### Tool Usage Log")
-        for tu in session["tool_uses"]:
-            file_info = f" [{tu['file'][:80]}]" if tu.get("file") else ""
-            lines.append(f"- {tu['tool']}{file_info}")
-
-    return "\n".join(lines)
-
-
-def find_api_key() -> str | None:
-    """Find Anthropic API key from common locations."""
-    # Environment variable
-    key = os.environ.get("ANTHROPIC_API_KEY", "")
-    if key:
-        return key
-
-    # Common file locations
-    for path in [
-        Path.home() / ".claude" / "anthropic-api-key.txt",
-        Path.home() / ".anthropic" / "api_key",
-        Path.home() / ".config" / "anthropic" / "api_key",
-    ]:
-        if path.exists():
-            return path.read_text().strip()
-
-    return None
-
-
-def analyze_with_claude(transcript: str, prompt: str) -> dict | None:
-    """Send transcript to Claude CLI for analysis."""
-    full_prompt = (
-        f"{prompt}\n\n---\n\n# TODAY'S TRANSCRIPT\n\n{transcript}\n\n---\n\n"
-        "Analyze this transcript and return the JSON output as specified. "
-        "Return ONLY the JSON, no markdown code fences."
-    )
-
-    api_key = find_api_key()
-    env = os.environ.copy()
-    if api_key:
-        env["ANTHROPIC_API_KEY"] = api_key
-
-    try:
-        result = subprocess.run(
-            ["claude", "-p", full_prompt, "--model", "opus", "--output-format", "text", "--bare"],
-            capture_output=True, text=True, timeout=300, env=env
-        )
-
-        if result.returncode != 0:
-            print(f"Claude CLI error: {result.stderr[:500]}", file=sys.stderr)
-            return None
-
-        response_text = result.stdout.strip()
-
-        # Strip markdown code fences if present
-        if response_text.startswith("```"):
-            lines = response_text.split("\n")
-            response_text = "\n".join(lines[1:-1] if lines[-1].strip() == "```" else lines[1:])
-            response_text = response_text.strip()
-
-        # Find JSON object in response
-        json_start = response_text.find("{")
-        json_end = response_text.rfind("}") + 1
-        if json_start >= 0 and json_end > json_start:
-            response_text = response_text[json_start:json_end]
-
-        return json.loads(response_text)
-
-    except subprocess.TimeoutExpired:
-        print("Claude CLI timeout (300s)", file=sys.stderr)
-        return None
-    except json.JSONDecodeError as e:
-        print(f"Failed to parse Claude response: {e}", file=sys.stderr)
-        return None
-    except FileNotFoundError:
-        print("Claude CLI not found. Install: npm install -g @anthropic-ai/claude-code", file=sys.stderr)
-        return None
-
-
-def consolidate_findings(results: list[dict]) -> dict:
-    """Merge findings from multiple sessions into one report."""
-    consolidated = {
-        "uncaptured_corrections": [],
-        "uncaptured_ideas": [],
-        "missed_commitments": [],
-        "protocol_compliance": {
-            "guard_check": {"required": 0, "executed": 0},
-            "heartbeat_quality": {"total": 0, "with_good_context": 0},
-            "trust_adjustments": {"corrections_detected": 0, "adjusted": 0},
-            "learning_capture": {"errors_resolved": 0, "captured": 0},
-            "change_log": {"production_edits": 0, "logged": 0},
-            "feedback_capture": {"corrections": 0, "captured": 0},
-        },
-        "protocol_violations": [],
-        "quality_issues": [],
-        "auto_reinforcements": [],
-    }
-
-    for r in results:
-        if not r:
-            continue
-        for key in ["uncaptured_corrections", "uncaptured_ideas", "missed_commitments",
-                     "protocol_violations", "quality_issues", "auto_reinforcements"]:
-            consolidated[key].extend(r.get(key, []))
-
-        pc = r.get("protocol_compliance", {})
-        for key in consolidated["protocol_compliance"]:
-            if key in pc and isinstance(pc[key], dict):
-                for subkey in consolidated["protocol_compliance"][key]:
-                    consolidated["protocol_compliance"][key][subkey] += pc[key].get(subkey, 0)
-
-    # Calculate rates
-    for key, vals in consolidated["protocol_compliance"].items():
-        keys = list(vals.keys())
-        if len(keys) == 2:
-            denominator = vals[keys[0]]
-            numerator = vals[keys[1]]
-            vals["rate"] = round(numerator / denominator, 2) if denominator > 0 else 1.0
-
-    rates = [v.get("rate", 1.0) for v in consolidated["protocol_compliance"].values()]
-    consolidated["protocol_compliance"]["overall_compliance"] = round(sum(rates) / len(rates), 2) if rates else 1.0
-    consolidated["auto_reinforcements"] = list(set(consolidated["auto_reinforcements"]))
-
-    return consolidated
-
-
-def main():
-    date = sys.argv[1] if len(sys.argv) > 1 else datetime.now().strftime("%Y-%m-%d")
-
-    transcripts_file = DEEP_SLEEP_DIR / f"{date}-transcripts.json"
-    if not transcripts_file.exists():
-        print(f"No transcripts found for {date}. Run collect_transcripts.py first.")
-        sys.exit(1)
-
-    with open(transcripts_file) as f:
-        data = json.load(f)
-
-    sessions = data["sessions"]
-    print(f"Analyzing {len(sessions)} sessions from {date}...")
-
-    prompt = PROMPT_FILE.read_text()
-
-    results = []
-    for i, session in enumerate(sessions):
-        transcript = build_transcript_text(session)
-
-        if len(transcript) < 500:
-            print(f"  Session {i+1}/{len(sessions)}: skipped (too short)")
-            continue
-
-        if len(transcript) > MAX_TRANSCRIPT_CHARS:
-            transcript = transcript[:MAX_TRANSCRIPT_CHARS] + "\n\n[TRUNCATED]"
-
-        print(f"  Session {i+1}/{len(sessions)}: {session['session_file'][:12]}... ({len(transcript)} chars)")
-        result = analyze_with_claude(transcript, prompt)
-        if result:
-            results.append(result)
-            print(f"    → {len(result.get('uncaptured_corrections', []))} corrections, "
-                  f"{len(result.get('protocol_violations', []))} violations")
-        else:
-            print(f"    → Analysis failed")
-
-    consolidated = consolidate_findings(results)
-    consolidated["date"] = date
-    consolidated["sessions_analyzed"] = len(results)
-
-    n_corrections = len(consolidated["uncaptured_corrections"])
-    n_violations = len(consolidated["protocol_violations"])
-    compliance = consolidated["protocol_compliance"]["overall_compliance"]
-    consolidated["summary"] = (
-        f"Analyzed {len(results)} sessions. "
-        f"Found {n_corrections} uncaptured corrections, {n_violations} protocol violations. "
-        f"Overall compliance: {compliance:.0%}."
-    )
-
-    output_file = DEEP_SLEEP_DIR / f"{date}-analysis.json"
-    with open(output_file, "w") as f:
-        json.dump(consolidated, f, indent=2, ensure_ascii=False)
-
-    print(f"\nResults: {output_file}")
-    print(consolidated["summary"])
-
-
-if __name__ == "__main__":
-    main()

package/src/scripts/deep-sleep/collect_transcripts.py

@@ -1,145 +0,0 @@
-#!/usr/bin/env python3
-"""
-Deep Sleep — Step 1: Collect today's session transcripts.
-Reads Claude Code .jsonl files, extracts clean conversation text + tool usage.
-"""
-import json
-import os
-import sys
-from datetime import datetime
-from pathlib import Path
-
-NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-
-MIN_USER_MESSAGES = 3  # Skip trivial sessions
-
-
-def find_sessions_dir() -> Path:
-    """Find the Claude Code sessions directory dynamically."""
-    claude_dir = Path.home() / ".claude" / "projects"
-    if not claude_dir.exists():
-        return claude_dir
-
-    # Find the project directory (usually named after the home path)
-    for d in claude_dir.iterdir():
-        if d.is_dir() and list(d.glob("*.jsonl")):
-            return d
-
-    # Fallback: look for any .jsonl in the projects dir tree
-    for jsonl in claude_dir.rglob("*.jsonl"):
-        return jsonl.parent
-
-    return claude_dir
-
-
-def extract_session(jsonl_path: str) -> dict | None:
-    """Extract clean transcript from a session JSONL file."""
-    messages = []
-    tool_uses = []
-    user_msg_count = 0
-
-    try:
-        with open(jsonl_path, "r") as f:
-            for line in f:
-                line = line.strip()
-                if not line:
-                    continue
-                try:
-                    d = json.loads(line)
-                except json.JSONDecodeError:
-                    continue
-
-                msg_type = d.get("type")
-
-                # User messages
-                if msg_type == "user":
-                    content = d.get("message", {}).get("content", "")
-                    if isinstance(content, str) and content.strip():
-                        if content.startswith("<system-reminder>"):
-                            continue
-                        messages.append({
-                            "role": "user",
-                            "text": content[:5000],
-                            "uuid": d.get("uuid", "")
-                        })
-                        user_msg_count += 1
-
-                # Assistant messages
-                elif msg_type in ("message", "assistant"):
-                    msg = d.get("message", {})
-                    content_blocks = msg.get("content", [])
-                    text_parts = []
-                    for block in content_blocks:
-                        if isinstance(block, dict):
-                            if block.get("type") == "text":
-                                text_parts.append(block.get("text", ""))
-                            elif block.get("type") == "tool_use":
-                                tool_uses.append({
-                                    "tool": block.get("name", ""),
-                                    "input_keys": list(block.get("input", {}).keys()) if isinstance(block.get("input"), dict) else [],
-                                    "file": block.get("input", {}).get("file_path", "") or block.get("input", {}).get("command", "")[:100] if isinstance(block.get("input"), dict) else ""
-                                })
-                    if text_parts:
-                        combined = "\n".join(text_parts)[:5000]
-                        messages.append({
-                            "role": "assistant",
-                            "text": combined
-                        })
-
-    except Exception as e:
-        print(f"Error reading {jsonl_path}: {e}", file=sys.stderr)
-        return None
-
-    if user_msg_count < MIN_USER_MESSAGES:
-        return None
-
-    return {
-        "session_file": os.path.basename(jsonl_path),
-        "message_count": len(messages),
-        "user_message_count": user_msg_count,
-        "tool_use_count": len(tool_uses),
-        "messages": messages,
-        "tool_uses": tool_uses
-    }
-
-
-def collect_date(target_date: str, sessions_dir: Path) -> list[dict]:
-    """Collect all sessions modified on a given date."""
-    sessions = []
-    for f in sessions_dir.glob("*.jsonl"):
-        mtime = datetime.fromtimestamp(f.stat().st_mtime)
-        if mtime.strftime("%Y-%m-%d") == target_date:
-            session = extract_session(str(f))
-            if session:
-                session["modified"] = mtime.isoformat()
-                sessions.append(session)
-    sessions.sort(key=lambda s: s["modified"])
-    return sessions
-
-
-def main():
-    date_arg = sys.argv[1] if len(sys.argv) > 1 else datetime.now().strftime("%Y-%m-%d")
-    sessions_dir = find_sessions_dir()
-
-    sessions = collect_date(date_arg, sessions_dir)
-
-    output = {
-        "date": date_arg,
-        "sessions_found": len(sessions),
-        "total_messages": sum(s["message_count"] for s in sessions),
-        "total_tool_uses": sum(s["tool_use_count"] for s in sessions),
-        "sessions": sessions
-    }
-
-    output_dir = NEXO_HOME / "operations" / "deep-sleep"
-    output_dir.mkdir(parents=True, exist_ok=True)
-    output_file = output_dir / f"{output['date']}-transcripts.json"
-    with open(output_file, "w") as f:
-        json.dump(output, f, indent=2, ensure_ascii=False)
-
-    print(f"Collected {len(sessions)} sessions, {output['total_messages']} messages, {output['total_tool_uses']} tool uses")
-    print(f"Output: {output_file}")
-
-
-if __name__ == "__main__":
-    main()

package/src/scripts/deep-sleep/prompt.md

@@ -1,109 +0,0 @@
-# Deep Sleep Analyst — Session Transcript Analysis
-
-You are NEXO's overnight analyst. You read the COMPLETE transcripts of today's sessions between the user and NEXO, and you find what NEXO missed.
-
-## Your job
-
-NEXO captures feedback, learnings, and corrections during sessions — but it misses things. Your job is to find the gaps by reading what ACTUALLY happened (the transcript), not what NEXO thinks happened (the diary).
-
-## What you analyze
-
-### 1. Uncaptured corrections
-The user corrected NEXO but NEXO didn't save a learning or feedback memory.
-Signals: frustration tone, repeating the same instruction 2+ times, the user having to explain something twice, explicit corrections ("no", "wrong", "that's not it").
-
-### 2. Repeated patterns
-The same correction appears multiple times in the day. This is a SYSTEMIC failure — it needs a strong learning with high severity.
-
-### 3. Uncaptured ideas
-The user mentioned an idea, plan, or intention that nobody formalized. Signals: "we could", "we should", "I want", "I need", future-tense plans without deadlines.
-
-### 4. Missed commitments
-The user said "I'll look at it tomorrow", "this week", "when I can" — was a followup created? If not, flag it.
-
-### 5. Protocol compliance (from tool_uses)
-Check if NEXO followed its own protocols:
-- `nexo_guard_check` before Edit/Write on production files?
-- `nexo_heartbeat` called with meaningful context_hint?
-- `nexo_cognitive_trust` called after corrections?
-- `nexo_learning_add` called after resolving errors?
-- `nexo_followup_complete` called when the user confirmed completion ("done", "fixed", "already handled")?
-- `nexo_change_log` called after production code changes?
-- Feedback memory saved after corrections?
-
-### 6. Quality assessment
-- Did NEXO declare work "complete"/"perfect" and the user had to correct after?
-- Was NEXO too verbose when the user wanted action?
-- Did NEXO delegate to subagents when it should have done the work directly?
-
-## Output format
-
-Return ONLY valid JSON:
-
-```json
-{
-  "date": "YYYY-MM-DD",
-  "sessions_analyzed": 5,
-  "uncaptured_corrections": [
-    {
-      "quote": "User's exact words (max 100 chars)",
-      "context": "What they were working on",
-      "what_nexo_should_have_saved": "The learning/feedback content",
-      "action": "learning_add|feedback_write|preference_set",
-      "category": "ui|code|process|communication",
-      "severity": "low|medium|high|critical",
-      "times_repeated": 1
-    }
-  ],
-  "uncaptured_ideas": [
-    {
-      "quote": "User's words",
-      "idea": "What the idea is",
-      "action": "reminder_create|followup_create",
-      "suggested_date": "YYYY-MM-DD or null"
-    }
-  ],
-  "missed_commitments": [
-    {
-      "quote": "User's words",
-      "commitment": "What was promised",
-      "action": "followup_create",
-      "due_date": "YYYY-MM-DD"
-    }
-  ],
-  "protocol_compliance": {
-    "guard_check": {"required": 0, "executed": 0, "rate": 1.0},
-    "heartbeat_quality": {"total": 0, "with_good_context": 0, "rate": 1.0},
-    "trust_adjustments": {"corrections_detected": 0, "adjusted": 0, "rate": 1.0},
-    "learning_capture": {"errors_resolved": 0, "captured": 0, "rate": 1.0},
-    "change_log": {"production_edits": 0, "logged": 0, "rate": 1.0},
-    "feedback_capture": {"corrections": 0, "captured": 0, "rate": 1.0},
-    "overall_compliance": 1.0
-  },
-  "protocol_violations": [
-    {
-      "protocol": "guard_check|trust_adjustment|feedback_capture|...",
-      "context": "What happened",
-      "severity": "low|medium|high|critical"
-    }
-  ],
-  "quality_issues": [
-    {
-      "issue": "Description of quality problem",
-      "example": "Specific instance",
-      "severity": "low|medium|high"
-    }
-  ],
-  "auto_reinforcements": [
-    "Specific rule to add or reinforce in CLAUDE.md or guard"
-  ],
-  "summary": "2-3 sentence overall assessment of the day"
-}
-```
-
-## Rules
-- Be SPECIFIC. Quote the user's exact words.
-- Only flag REAL issues. If NEXO did capture something correctly, don't flag it.
-- severity=critical means the user repeated the same correction 3+ times or expressed strong frustration
-- For protocol compliance, count ACTUAL tool_use entries in the transcript
-- If no issues found in a category, return empty array — don't invent problems