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

up/commands/dashboard.py

@@ -0,0 +1,248 @@
+"""up dashboard - Interactive health dashboard."""
+
+import json
+import time
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.layout import Layout
+from rich.live import Live
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+console = Console()
+
+
+@click.command()
+@click.option("--refresh", "-r", default=5, help="Refresh interval in seconds")
+@click.option("--once", is_flag=True, help="Show once without refresh")
+def dashboard_cmd(refresh: int, once: bool):
+    """Show interactive health dashboard.
+    
+    Displays real-time status of all up systems:
+    - Context budget usage
+    - Circuit breaker states  
+    - Product loop progress
+    - Recent activity
+    """
+    if once:
+        dashboard = create_dashboard(Path.cwd())
+        console.print(dashboard)
+        return
+    
+    try:
+        with Live(create_dashboard(Path.cwd()), refresh_per_second=1, console=console) as live:
+            while True:
+                time.sleep(refresh)
+                live.update(create_dashboard(Path.cwd()))
+    except KeyboardInterrupt:
+        console.print("\n[dim]Dashboard stopped[/]")
+
+
+def create_dashboard(workspace: Path) -> Panel:
+    """Create the dashboard layout."""
+    layout = Layout()
+    
+    layout.split_column(
+        Layout(name="header", size=3),
+        Layout(name="main"),
+        Layout(name="footer", size=3),
+    )
+    
+    layout["main"].split_row(
+        Layout(name="left"),
+        Layout(name="right"),
+    )
+    
+    # Header
+    layout["header"].update(Panel(
+        Text("UP-CLI Health Dashboard", style="bold white", justify="center"),
+        style="blue"
+    ))
+    
+    # Left side - Status panels
+    left_content = Layout()
+    left_content.split_column(
+        Layout(create_context_panel(workspace), name="context"),
+        Layout(create_circuit_panel(workspace), name="circuit"),
+    )
+    layout["left"].update(left_content)
+    
+    # Right side - Progress and activity
+    right_content = Layout()
+    right_content.split_column(
+        Layout(create_progress_panel(workspace), name="progress"),
+        Layout(create_skills_panel(workspace), name="skills"),
+    )
+    layout["right"].update(right_content)
+    
+    # Footer
+    layout["footer"].update(Panel(
+        Text("Press Ctrl+C to exit | Refreshing every 5s", style="dim", justify="center"),
+        style="dim"
+    ))
+    
+    return Panel(layout, title="[bold]up-cli[/]", border_style="blue")
+
+
+def create_context_panel(workspace: Path) -> Panel:
+    """Create context budget panel."""
+    context_file = workspace / ".claude/context_budget.json"
+    
+    if not context_file.exists():
+        return Panel(
+            "[dim]Not configured[/]",
+            title="Context Budget",
+            border_style="dim"
+        )
+    
+    try:
+        data = json.loads(context_file.read_text())
+        usage = data.get("usage_percent", 0)
+        status = data.get("status", "OK")
+        remaining = data.get("remaining_tokens", 0)
+        
+        # Create progress bar
+        bar_width = 20
+        filled = int(bar_width * usage / 100)
+        bar = "█" * filled + "░" * (bar_width - filled)
+        
+        # Color based on status
+        if status == "CRITICAL":
+            color = "red"
+        elif status == "WARNING":
+            color = "yellow"
+        else:
+            color = "green"
+        
+        content = f"""[{color}]{status}[/]
+
+[{bar}] {usage:.1f}%
+
+Remaining: {remaining:,} tokens
+Entries: {data.get('entry_count', 0)}"""
+        
+        return Panel(content, title="Context Budget", border_style=color)
+        
+    except (json.JSONDecodeError, KeyError):
+        return Panel("[red]Error reading state[/]", title="Context Budget")
+
+
+def create_circuit_panel(workspace: Path) -> Panel:
+    """Create circuit breaker panel."""
+    loop_file = workspace / ".loop_state.json"
+    
+    if not loop_file.exists():
+        return Panel(
+            "[dim]Not active[/]",
+            title="Circuit Breaker",
+            border_style="dim"
+        )
+    
+    try:
+        data = json.loads(loop_file.read_text())
+        cb = data.get("circuit_breaker", {})
+        
+        lines = []
+        for name, state in cb.items():
+            if isinstance(state, dict):
+                cb_state = state.get("state", "UNKNOWN")
+                failures = state.get("failures", 0)
+                
+                if cb_state == "OPEN":
+                    icon = "🔴"
+                    color = "red"
+                elif cb_state == "HALF_OPEN":
+                    icon = "🟡"
+                    color = "yellow"
+                else:
+                    icon = "🟢"
+                    color = "green"
+                
+                lines.append(f"{icon} [{color}]{name}[/]: {cb_state} ({failures} failures)")
+        
+        content = "\n".join(lines) if lines else "[dim]No circuits[/]"
+        return Panel(content, title="Circuit Breaker", border_style="green")
+        
+    except (json.JSONDecodeError, KeyError):
+        return Panel("[red]Error[/]", title="Circuit Breaker")
+
+
+def create_progress_panel(workspace: Path) -> Panel:
+    """Create progress panel."""
+    loop_file = workspace / ".loop_state.json"
+    
+    if not loop_file.exists():
+        return Panel(
+            "[dim]No active loop[/]",
+            title="Product Loop",
+            border_style="dim"
+        )
+    
+    try:
+        data = json.loads(loop_file.read_text())
+        
+        iteration = data.get("iteration", 0)
+        phase = data.get("phase", "UNKNOWN")
+        current = data.get("current_task")
+        completed = len(data.get("tasks_completed", []))
+        remaining = len(data.get("tasks_remaining", []))
+        total = completed + remaining
+        
+        metrics = data.get("metrics", {})
+        success_rate = metrics.get("success_rate", 1.0)
+        
+        # Progress bar
+        if total > 0:
+            progress = completed / total
+            bar_width = 20
+            filled = int(bar_width * progress)
+            bar = "█" * filled + "░" * (bar_width - filled)
+            progress_line = f"[{bar}] {progress*100:.0f}%"
+        else:
+            progress_line = "[dim]No tasks[/]"
+        
+        content = f"""Iteration: {iteration}
+Phase: [cyan]{phase}[/]
+Current: {current or '[dim]None[/]'}
+
+{progress_line}
+Completed: {completed}/{total}
+Success: {success_rate*100:.0f}%"""
+        
+        return Panel(content, title="Product Loop", border_style="cyan")
+        
+    except (json.JSONDecodeError, KeyError):
+        return Panel("[red]Error[/]", title="Product Loop")
+
+
+def create_skills_panel(workspace: Path) -> Panel:
+    """Create skills panel."""
+    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():
+                    skills.append(skill_dir.name)
+    
+    if not skills:
+        return Panel(
+            "[dim]No skills installed[/]",
+            title="Skills",
+            border_style="dim"
+        )
+    
+    content = "\n".join(f"• {skill}" for skill in sorted(set(skills)))
+    return Panel(content, title="Skills", border_style="magenta")
+
+
+if __name__ == "__main__":
+    dashboard_cmd()

up/commands/init.py

@@ -1,6 +1,7 @@
 """up init - Initialize up systems in existing project."""
 
 import os
+import stat
 from pathlib import Path
 
 import click
@@ -27,13 +28,32 @@ console = Console()
     default=["all"],
     help="Systems to initialize",
 )
+@click.option(
+    "--hooks/--no-hooks",
+    default=True,
+    help="Install git hooks for auto-sync (default: yes)",
+)
+@click.option(
+    "--memory/--no-memory",
+    default=True,
+    help="Build initial memory from git history (default: yes)",
+)
 @click.option(
     "--force",
     is_flag=True,
     help="Overwrite existing files",
 )
-def init_cmd(ai: str, systems: tuple, force: bool):
-    """Initialize up systems in the current directory."""
+def init_cmd(ai: str, systems: tuple, hooks: bool, memory: bool, force: bool):
+    """Initialize up systems in the current directory.
+    
+    Automatically:
+    - Installs git hooks for memory auto-sync
+    - Indexes existing git history to memory
+    - Scans project structure for context
+    
+    Use --no-hooks to disable hooks.
+    Use --no-memory to skip initial memory build.
+    """
     cwd = Path.cwd()
 
     console.print(Panel.fit(
@@ -53,11 +73,177 @@ def init_cmd(ai: str, systems: tuple, force: bool):
         force=force,
     )
 
+    # Install git hooks automatically
+    hooks_installed = False
+    if hooks:
+        hooks_installed = _install_git_hooks(cwd)
+
+    # Build initial memory from existing project
+    memory_stats = None
+    if memory:
+        memory_stats = _build_initial_memory(cwd)
+
     console.print("\n[green]✓[/] Initialization complete!")
-    _print_next_steps(systems)
+    
+    if hooks_installed:
+        console.print("[green]✓[/] Git hooks installed for auto-sync")
+    
+    if memory_stats:
+        console.print(f"[green]✓[/] Memory initialized ({memory_stats['total']} entries)")
+    
+    _print_next_steps(systems, hooks_installed)
+
+
+def _build_initial_memory(workspace: Path) -> dict:
+    """Build initial memory from existing project.
+    
+    Indexes:
+    - Existing git commits (up to 50)
+    - Recent file changes
+    - Project structure metadata
+    
+    Returns stats dict or None if failed.
+    """
+    try:
+        import os
+        import warnings
+        from up.memory import MemoryManager
+        
+        # Suppress noisy warnings from tokenizers
+        os.environ["TOKENIZERS_PARALLELISM"] = "false"
+        warnings.filterwarnings("ignore", category=UserWarning)
+        
+        console.print("\n[dim]Building initial memory...[/]")
+        
+        manager = MemoryManager(workspace, use_vectors=False)  # Use fast JSON backend
+        
+        # Index existing commits
+        commits = manager.index_recent_commits(count=50)
+        console.print(f"  [dim]Indexed {commits} commits[/]")
+        
+        # Index recent file changes
+        files = manager.index_file_changes()
+        console.print(f"  [dim]Indexed {files} files[/]")
+        
+        # Record project initialization
+        import subprocess
+        
+        # Get project info
+        project_name = workspace.name
+        
+        # Detect languages/frameworks
+        languages = []
+        if (workspace / "pyproject.toml").exists() or (workspace / "requirements.txt").exists():
+            languages.append("Python")
+        if (workspace / "package.json").exists():
+            languages.append("JavaScript/TypeScript")
+        if (workspace / "go.mod").exists():
+            languages.append("Go")
+        if (workspace / "Cargo.toml").exists():
+            languages.append("Rust")
+        
+        # Record initialization as a learning
+        if languages:
+            manager.record_learning(
+                f"Project '{project_name}' initialized with up-cli. "
+                f"Languages detected: {', '.join(languages)}. "
+                f"Indexed {commits} commits and {files} files into memory."
+            )
+        
+        stats = manager.get_stats()
+        return {
+            "total": stats.get("total", 0),
+            "commits": commits,
+            "files": files,
+        }
+        
+    except Exception as e:
+        console.print(f"  [yellow]Warning: Could not build memory: {e}[/]")
+        return None
+
+
+def _install_git_hooks(workspace: Path) -> bool:
+    """Install git hooks for automatic memory sync.
+    
+    Returns True if hooks were installed successfully.
+    """
+    git_dir = workspace / ".git"
+    
+    if not git_dir.exists():
+        console.print("[yellow]⚠[/] Not a git repo, skipping hooks")
+        return False
+    
+    hooks_dir = git_dir / "hooks"
+    hooks_dir.mkdir(exist_ok=True)
+    
+    # Post-commit hook
+    post_commit = hooks_dir / "post-commit"
+    post_commit_content = '''#!/bin/bash
+# up-cli auto-sync hook (installed by up init)
+# Indexes commits to memory automatically
+
+# Run in background to not slow down commits
+(
+    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)
+    
+    # Post-checkout hook (for branch switches)
+    post_checkout = hooks_dir / "post-checkout"
+    post_checkout_content = '''#!/bin/bash
+# up-cli context update hook (installed by up init)
+# 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)
+    
+    return True
+
+
+def _write_hook(path: Path, content: str):
+    """Write hook file with executable permissions."""
+    # 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 _print_next_steps(systems: tuple):
+def _print_next_steps(systems: tuple, hooks_installed: bool):
     """Print next steps after initialization."""
     console.print("\n[bold]Next steps:[/]")
 
@@ -65,7 +251,10 @@ def _print_next_steps(systems: tuple):
         console.print("  • Edit [cyan]docs/roadmap/vision/PRODUCT_VISION.md[/]")
 
     if "learn" in systems:
-        console.print("  • Run [cyan]/learn auto[/] to analyze your project")
+        console.print("  • Run [cyan]up learn auto[/] to analyze your project")
 
     if "loop" in systems:
-        console.print("  • Run [cyan]/product-loop[/] to start development")
+        console.print("  • Run [cyan]up start[/] to start development")
+    
+    if hooks_installed:
+        console.print("\n[dim]Auto-sync enabled: commits will be indexed automatically[/]")