up-cli 0.2.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

up/commands/status.py

@@ -44,21 +44,128 @@ def collect_status(workspace: Path) -> dict:
     status = {
         "workspace": str(workspace),
         "initialized": False,
+        "state_version": None,
         "context_budget": None,
         "loop_state": None,
         "circuit_breaker": None,
+        "checkpoints": None,
+        "agents": None,
+        "doom_loop": None,
         "skills": [],
+        "hooks": None,
+        "memory": None,
     }
     
     # Check if initialized
     claude_dir = workspace / ".claude"
     cursor_dir = workspace / ".cursor"
-    status["initialized"] = claude_dir.exists() or cursor_dir.exists()
+    up_dir = workspace / ".up"
+    status["initialized"] = claude_dir.exists() or cursor_dir.exists() or up_dir.exists()
     
     if not status["initialized"]:
         return status
     
-    # Context budget
+    # Try to load unified state first
+    try:
+        from up.core.state import get_state_manager
+        manager = get_state_manager(workspace)
+        state = manager.state
+        status["state_version"] = state.version
+        
+        # Context budget from unified state
+        status["context_budget"] = {
+            "budget": state.context.budget,
+            "total_tokens": state.context.total_tokens,
+            "remaining_tokens": state.context.remaining_tokens,
+            "usage_percent": state.context.usage_percent,
+            "status": state.context.status,
+        }
+        
+        # Loop state from unified state
+        status["loop_state"] = {
+            "iteration": state.loop.iteration,
+            "phase": state.loop.phase,
+            "current_task": state.loop.current_task,
+            "tasks_completed": len(state.loop.tasks_completed),
+            "tasks_failed": len(state.loop.tasks_failed),
+            "success_rate": state.metrics.success_rate,
+            "last_checkpoint": state.loop.last_checkpoint,
+        }
+        
+        # Circuit breakers
+        status["circuit_breaker"] = {
+            name: {"state": cb.state, "failures": cb.failures}
+            for name, cb in state.circuit_breakers.items()
+        }
+        
+        # Checkpoints
+        status["checkpoints"] = {
+            "total": len(state.checkpoints),
+            "last": state.loop.last_checkpoint,
+            "recent": state.checkpoints[-5:] if state.checkpoints else [],
+        }
+        
+        # Agents
+        if state.agents:
+            status["agents"] = {
+                task_id: {
+                    "status": agent.status,
+                    "phase": agent.phase,
+                    "worktree": agent.worktree_path,
+                }
+                for task_id, agent in state.agents.items()
+            }
+        
+        # Doom loop detection
+        is_doom, doom_msg = manager.check_doom_loop()
+        if is_doom or state.loop.consecutive_failures > 0:
+            status["doom_loop"] = {
+                "triggered": is_doom,
+                "consecutive_failures": state.loop.consecutive_failures,
+                "threshold": state.loop.doom_loop_threshold,
+                "message": doom_msg if is_doom else None,
+            }
+            
+    except ImportError:
+        # Fallback to old state files
+        _collect_legacy_status(workspace, status)
+    
+    # Git hooks status
+    from up.commands.sync import check_hooks_installed
+    status["hooks"] = check_hooks_installed(workspace)
+    
+    # Memory status
+    memory_dir = workspace / ".up" / "memory"
+    if memory_dir.exists():
+        try:
+            from up.memory import MemoryManager
+            manager = MemoryManager(workspace, use_vectors=False)
+            stats = manager.get_stats()
+            status["memory"] = {
+                "total": stats.get("total", 0),
+                "branch": stats.get("current_branch", "unknown"),
+                "commit": stats.get("current_commit", "unknown"),
+            }
+        except Exception:
+            status["memory"] = {"total": 0}
+    
+    # Skills
+    skills_dirs = [
+        workspace / ".claude/skills",
+        workspace / ".cursor/skills",
+    ]
+    for skills_dir in skills_dirs:
+        if skills_dir.exists():
+            for skill_dir in skills_dir.iterdir():
+                if skill_dir.is_dir() and (skill_dir / "SKILL.md").exists():
+                    status["skills"].append(skill_dir.name)
+    
+    return status
+
+
+def _collect_legacy_status(workspace: Path, status: dict) -> None:
+    """Collect status from legacy state files."""
+    # Context budget (old location)
     context_file = workspace / ".claude/context_budget.json"
     if context_file.exists():
         try:
@@ -66,7 +173,7 @@ def collect_status(workspace: Path) -> dict:
         except json.JSONDecodeError:
             status["context_budget"] = {"error": "Invalid JSON"}
     
-    # Loop state
+    # Loop state (old location)
     loop_file = workspace / ".loop_state.json"
     if loop_file.exists():
         try:
@@ -82,19 +189,6 @@ def collect_status(workspace: Path) -> dict:
             status["circuit_breaker"] = data.get("circuit_breaker", {})
         except json.JSONDecodeError:
             status["loop_state"] = {"error": "Invalid JSON"}
-    
-    # Skills
-    skills_dirs = [
-        workspace / ".claude/skills",
-        workspace / ".cursor/skills",
-    ]
-    for skills_dir in skills_dirs:
-        if skills_dir.exists():
-            for skill_dir in skills_dir.iterdir():
-                if skill_dir.is_dir() and (skill_dir / "SKILL.md").exists():
-                    status["skills"].append(skill_dir.name)
-    
-    return status
 
 
 def display_status(status: dict) -> None:
@@ -162,7 +256,7 @@ def display_status(status: dict) -> None:
     else:
         console.print("  [dim]Not active[/]")
     
-    # Loop State
+    # Product Loop State
     console.print("\n[bold]Product Loop[/]")
     if status["loop_state"]:
         loop = status["loop_state"]
@@ -177,8 +271,9 @@ def display_status(status: dict) -> None:
                 console.print(f"  Current Task: [cyan]{current}[/]")
             
             completed = loop.get("tasks_completed", 0)
+            failed = loop.get("tasks_failed", 0)
             remaining = loop.get("tasks_remaining", 0)
-            total = completed + remaining
+            total = completed + failed + remaining if remaining else completed + failed
             
             if total > 0:
                 progress = completed / total * 100
@@ -189,9 +284,69 @@ def display_status(status: dict) -> None:
             
             success_rate = loop.get("success_rate", 1.0)
             console.print(f"  Success Rate: {success_rate * 100:.0f}%")
+            
+            last_cp = loop.get("last_checkpoint")
+            if last_cp:
+                console.print(f"  Last Checkpoint: [cyan]{last_cp}[/]")
     else:
         console.print("  [dim]Not active[/]")
     
+    # Doom Loop Detection
+    if status.get("doom_loop"):
+        doom = status["doom_loop"]
+        console.print("\n[bold]Doom Loop Detection[/]")
+        if doom["triggered"]:
+            console.print(f"  [red]⚠ TRIGGERED[/] - {doom['consecutive_failures']}/{doom['threshold']} failures")
+            console.print(f"  [dim]{doom.get('message', '')}[/]")
+        else:
+            console.print(f"  Consecutive Failures: {doom['consecutive_failures']}/{doom['threshold']}")
+    
+    # Checkpoints
+    if status.get("checkpoints"):
+        cp = status["checkpoints"]
+        console.print("\n[bold]Checkpoints[/]")
+        console.print(f"  Total: {cp['total']}")
+        if cp.get("recent"):
+            console.print(f"  Recent: {', '.join(cp['recent'][-3:])}")
+    
+    # Active Agents
+    if status.get("agents"):
+        console.print("\n[bold]Active Agents[/]")
+        for task_id, agent in status["agents"].items():
+            status_icon = "🟢" if agent["status"] == "passed" else "🟡" if agent["status"] in ["executing", "verifying"] else "🔴"
+            console.print(f"  {status_icon} {task_id}: {agent['status']} ({agent['phase']})")
+    
+    # Memory
+    console.print("\n[bold]Memory[/]")
+    if status["memory"]:
+        mem = status["memory"]
+        total = mem.get("total", 0)
+        branch = mem.get("branch", "unknown")
+        commit = mem.get("commit", "unknown")
+        console.print(f"  📚 {total} entries | Branch: [cyan]{branch}[/] @ {commit}")
+    else:
+        console.print("  [dim]Not initialized - run [cyan]up memory sync[/][/]")
+    
+    # Git Hooks
+    console.print("\n[bold]Auto-Sync (Git Hooks)[/]")
+    hooks = status.get("hooks", {})
+    if hooks.get("git"):
+        post_commit = hooks.get("post_commit", False)
+        post_checkout = hooks.get("post_checkout", False)
+        
+        if post_commit and post_checkout:
+            console.print("  [green]✓ Enabled[/] - commits auto-indexed to memory")
+        else:
+            console.print("  [yellow]⚠ Partially installed[/]")
+            if not post_commit:
+                console.print("    • Missing: post-commit hook")
+            if not post_checkout:
+                console.print("    • Missing: post-checkout hook")
+            console.print("\n  [dim]Run [cyan]up hooks[/] to install missing hooks[/]")
+    else:
+        console.print("  [yellow]✗ Not installed[/]")
+        console.print("  [dim]Run [cyan]up hooks[/] to enable auto-sync on commits[/]")
+    
     # Skills
     console.print("\n[bold]Skills[/]")
     if status["skills"]:

up/commands/sync.py

@@ -0,0 +1,317 @@
+"""up sync - Sync all systems."""
+
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+
+@click.command()
+@click.option("--memory/--no-memory", default=True, help="Sync memory system")
+@click.option("--docs/--no-docs", default=True, help="Update docs")
+@click.option("--full", is_flag=True, help="Full sync including file re-indexing")
+def sync_cmd(memory: bool, docs: bool, full: bool):
+    """Sync all up systems.
+    
+    Updates memory index, refreshes docs, and ensures all systems
+    are in sync with current project state.
+    
+    \b
+    Examples:
+      up sync              # Standard sync
+      up sync --full       # Full sync with file re-indexing
+      up sync --no-docs    # Memory only
+    """
+    cwd = Path.cwd()
+    
+    console.print(Panel.fit(
+        "[bold blue]Syncing Systems[/]",
+        border_style="blue"
+    ))
+    
+    results = {}
+    
+    # Initialize event system
+    from up.events import initialize_event_system
+    initialize_event_system(cwd)
+    
+    steps = []
+    if memory:
+        steps.append(("Memory", _sync_memory))
+    if docs:
+        steps.append(("Docs", _sync_docs))
+    if full:
+        steps.append(("Files", _sync_files))
+    
+    for name, func in steps:
+        console.print(f"[dim]Syncing {name}...[/]", end=" ")
+        try:
+            result = func(cwd, full)
+            results[name.lower()] = result
+            details = ", ".join(f"{k}={v}" for k, v in result.items() if v)
+            console.print(f"[green]✓[/] {details or 'done'}")
+        except Exception as e:
+            results[name.lower()] = {"error": str(e)}
+            console.print(f"[red]✗[/] {e}")
+    
+    # Summary
+    console.print()
+    errors = [k for k, v in results.items() if "error" in v]
+    if errors:
+        console.print(f"[yellow]Completed with {len(errors)} error(s)[/]")
+    else:
+        console.print("[green]✓[/] All systems synced")
+
+
+def _sync_memory(workspace: Path, full: bool) -> dict:
+    """Sync memory system."""
+    import os
+    import sys
+    import warnings
+    import logging
+    from up.memory import MemoryManager, _check_chromadb
+    
+    # Suppress noisy warnings and logs
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    warnings.filterwarnings("ignore")
+    logging.getLogger("chromadb").setLevel(logging.ERROR)
+    
+    # Redirect stderr temporarily to suppress ChromaDB noise
+    old_stderr = sys.stderr
+    sys.stderr = open(os.devnull, 'w')
+    
+    try:
+        # Use JSON backend if ChromaDB not available (faster, no model download)
+        use_vectors = _check_chromadb()
+        
+        manager = MemoryManager(workspace, use_vectors=use_vectors)
+        results = manager.sync()
+        
+        return {
+            "commits": results.get("commits_indexed", 0),
+            "files": results.get("files_indexed", 0),
+            "backend": manager._backend,
+        }
+    finally:
+        sys.stderr.close()
+        sys.stderr = old_stderr
+
+
+def _sync_docs(workspace: Path, full: bool) -> dict:
+    """Sync documentation."""
+    from datetime import date
+    import re
+    
+    updated = 0
+    
+    # Update CONTEXT.md date
+    context_file = workspace / "docs" / "CONTEXT.md"
+    if context_file.exists():
+        content = context_file.read_text()
+        today = date.today().isoformat()
+        new_content = re.sub(
+            r'\*\*Updated\*\*:\s*[\d-]+',
+            f'**Updated**: {today}',
+            content
+        )
+        if new_content != content:
+            context_file.write_text(new_content)
+            updated += 1
+    
+    # Check INDEX.md exists
+    index_file = workspace / "docs" / "INDEX.md"
+    if index_file.exists():
+        updated += 0  # Just checking
+    
+    return {"updated": updated}
+
+
+def _sync_files(workspace: Path, full: bool) -> dict:
+    """Sync file index."""
+    from up.memory import MemoryManager
+    
+    manager = MemoryManager(workspace)
+    indexed = manager.index_file_changes()
+    
+    return {"indexed": indexed}
+
+
+def check_hooks_installed(workspace: Path) -> dict:
+    """Check if up-cli hooks are installed.
+    
+    Returns dict with status of each hook.
+    """
+    git_dir = workspace / ".git"
+    if not git_dir.exists():
+        return {"git": False, "post_commit": False, "post_checkout": False}
+    
+    hooks_dir = git_dir / "hooks"
+    
+    result = {"git": True, "post_commit": False, "post_checkout": False}
+    
+    post_commit = hooks_dir / "post-commit"
+    if post_commit.exists() and "up-cli" in post_commit.read_text():
+        result["post_commit"] = True
+    
+    post_checkout = hooks_dir / "post-checkout"
+    if post_checkout.exists() and "up-cli" in post_checkout.read_text():
+        result["post_checkout"] = True
+    
+    return result
+
+
+@click.command()
+@click.option("--uninstall", is_flag=True, help="Remove hooks instead of installing")
+@click.option("--check", is_flag=True, help="Check if hooks are installed")
+def hooks_cmd(uninstall: bool, check: bool):
+    """Install or uninstall git hooks for automatic syncing.
+    
+    Installs:
+    - post-commit: Auto-index commits to memory
+    - post-checkout: Update context on branch switch
+    
+    \b
+    Examples:
+      up hooks              # Install hooks
+      up hooks --check      # Check status
+      up hooks --uninstall  # Remove hooks
+    """
+    cwd = Path.cwd()
+    git_dir = cwd / ".git"
+    
+    if not git_dir.exists():
+        console.print("[red]Error:[/] Not a git repository")
+        raise SystemExit(1)
+    
+    hooks_dir = git_dir / "hooks"
+    hooks_dir.mkdir(exist_ok=True)
+    
+    if check:
+        status = check_hooks_installed(cwd)
+        console.print("\n[bold]Git Hooks Status:[/]")
+        console.print(f"  post-commit:   {'[green]✓ installed[/]' if status['post_commit'] else '[yellow]✗ not installed[/]'}")
+        console.print(f"  post-checkout: {'[green]✓ installed[/]' if status['post_checkout'] else '[yellow]✗ not installed[/]'}")
+        
+        if not status['post_commit'] or not status['post_checkout']:
+            console.print("\n[dim]Run 'up hooks' to install missing hooks[/]")
+        return
+    
+    if uninstall:
+        _uninstall_hooks(hooks_dir)
+    else:
+        _install_hooks(hooks_dir)
+
+
+def _install_hooks(hooks_dir: Path):
+    """Install git hooks."""
+    
+    # Post-commit hook
+    post_commit = hooks_dir / "post-commit"
+    post_commit_content = '''#!/bin/bash
+# up-cli auto-sync hook
+# Indexes commits to memory automatically
+
+# Run in background to not slow down commits
+(
+    # Wait a moment for git to finish
+    sleep 1
+    
+    # Sync memory with latest commit
+    if command -v up &> /dev/null; then
+        up memory sync 2>/dev/null
+    elif command -v python3 &> /dev/null; then
+        python3 -m up.memory sync 2>/dev/null
+    fi
+) &
+
+exit 0
+'''
+    
+    _write_hook(post_commit, post_commit_content)
+    console.print("[green]✓[/] Installed post-commit hook")
+    
+    # Post-checkout hook (for branch switches)
+    post_checkout = hooks_dir / "post-checkout"
+    post_checkout_content = '''#!/bin/bash
+# up-cli context update hook
+# Updates context when switching branches
+
+PREV_HEAD=$1
+NEW_HEAD=$2
+BRANCH_CHECKOUT=$3
+
+# Only run on branch checkout, not file checkout
+if [ "$BRANCH_CHECKOUT" = "1" ]; then
+    (
+        sleep 1
+        if command -v up &> /dev/null; then
+            up sync --no-memory 2>/dev/null
+        fi
+    ) &
+fi
+
+exit 0
+'''
+    
+    _write_hook(post_checkout, post_checkout_content)
+    console.print("[green]✓[/] Installed post-checkout hook")
+    
+    console.print("\n[bold]Hooks installed![/]")
+    console.print("Memory will auto-sync on commits.")
+
+
+def _write_hook(path: Path, content: str):
+    """Write hook file with executable permissions."""
+    import stat
+    
+    # Check for existing hook
+    if path.exists():
+        existing = path.read_text()
+        if "up-cli" in existing:
+            # Already our hook, overwrite
+            pass
+        else:
+            # User has custom hook, append
+            content = existing + "\n\n" + content
+    
+    path.write_text(content)
+    path.chmod(path.stat().st_mode | stat.S_IEXEC)
+
+
+def _uninstall_hooks(hooks_dir: Path):
+    """Remove up-cli hooks."""
+    
+    for hook_name in ["post-commit", "post-checkout"]:
+        hook_path = hooks_dir / hook_name
+        if hook_path.exists():
+            content = hook_path.read_text()
+            if "up-cli" in content:
+                # Remove our section
+                lines = content.split("\n")
+                new_lines = []
+                skip = False
+                for line in lines:
+                    if "up-cli" in line:
+                        skip = True
+                    elif skip and line.startswith("exit"):
+                        skip = False
+                        continue
+                    elif not skip:
+                        new_lines.append(line)
+                
+                new_content = "\n".join(new_lines).strip()
+                if new_content:
+                    hook_path.write_text(new_content)
+                else:
+                    hook_path.unlink()
+                
+                console.print(f"[green]✓[/] Removed {hook_name} hook")
+    
+    console.print("\n[bold]Hooks uninstalled![/]")
+
+
+if __name__ == "__main__":
+    sync_cmd()