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

up/commands/status.py

@@ -0,0 +1,205 @@
+"""up status - Show system health and status."""
+
+import json
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+console = Console()
+
+
+@click.command()
+@click.option(
+    "--json", "as_json",
+    is_flag=True,
+    help="Output as JSON",
+)
+def status_cmd(as_json: bool):
+    """Show current status of all up systems.
+    
+    Displays health information for:
+    - Context budget (token usage)
+    - Circuit breaker states
+    - Product loop progress
+    - Learning system state
+    """
+    cwd = Path.cwd()
+    
+    status = collect_status(cwd)
+    
+    if as_json:
+        console.print(json.dumps(status, indent=2))
+        return
+    
+    # Display rich formatted output
+    display_status(status)
+
+
+def collect_status(workspace: Path) -> dict:
+    """Collect status from all systems."""
+    status = {
+        "workspace": str(workspace),
+        "initialized": False,
+        "context_budget": None,
+        "loop_state": None,
+        "circuit_breaker": None,
+        "skills": [],
+    }
+    
+    # Check if initialized
+    claude_dir = workspace / ".claude"
+    cursor_dir = workspace / ".cursor"
+    status["initialized"] = claude_dir.exists() or cursor_dir.exists()
+    
+    if not status["initialized"]:
+        return status
+    
+    # Context budget
+    context_file = workspace / ".claude/context_budget.json"
+    if context_file.exists():
+        try:
+            status["context_budget"] = json.loads(context_file.read_text())
+        except json.JSONDecodeError:
+            status["context_budget"] = {"error": "Invalid JSON"}
+    
+    # Loop state
+    loop_file = workspace / ".loop_state.json"
+    if loop_file.exists():
+        try:
+            data = json.loads(loop_file.read_text())
+            status["loop_state"] = {
+                "iteration": data.get("iteration", 0),
+                "phase": data.get("phase", "UNKNOWN"),
+                "current_task": data.get("current_task"),
+                "tasks_completed": len(data.get("tasks_completed", [])),
+                "tasks_remaining": len(data.get("tasks_remaining", [])),
+                "success_rate": data.get("metrics", {}).get("success_rate", 1.0),
+            }
+            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:
+    """Display status in rich format."""
+    
+    # Header
+    workspace_name = Path(status["workspace"]).name
+    if status["initialized"]:
+        header = f"[bold green]✓[/] {workspace_name} - up systems active"
+    else:
+        header = f"[bold yellow]○[/] {workspace_name} - not initialized"
+        console.print(Panel(header, border_style="yellow"))
+        console.print("\nRun [cyan]up init[/] to initialize up systems.")
+        return
+    
+    console.print(Panel(header, border_style="green"))
+    
+    # Context Budget
+    console.print("\n[bold]Context Budget[/]")
+    if status["context_budget"]:
+        budget = status["context_budget"]
+        if "error" in budget:
+            console.print(f"  [red]Error: {budget['error']}[/]")
+        else:
+            usage = budget.get("usage_percent", 0)
+            remaining = budget.get("remaining_tokens", 0)
+            budget_status = budget.get("status", "OK")
+            
+            # Color based on status
+            if budget_status == "CRITICAL":
+                color = "red"
+                icon = "🔴"
+            elif budget_status == "WARNING":
+                color = "yellow"
+                icon = "🟡"
+            else:
+                color = "green"
+                icon = "🟢"
+            
+            console.print(f"  {icon} Status: [{color}]{budget_status}[/]")
+            console.print(f"  Usage: {usage:.1f}% ({remaining:,} tokens remaining)")
+    else:
+        console.print("  [dim]Not configured[/]")
+    
+    # Circuit Breaker
+    console.print("\n[bold]Circuit Breaker[/]")
+    if status["circuit_breaker"]:
+        cb = status["circuit_breaker"]
+        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"
+                
+                console.print(f"  {icon} {name}: [{color}]{cb_state}[/] (failures: {failures})")
+    else:
+        console.print("  [dim]Not active[/]")
+    
+    # Loop State
+    console.print("\n[bold]Product Loop[/]")
+    if status["loop_state"]:
+        loop = status["loop_state"]
+        if "error" in loop:
+            console.print(f"  [red]Error: {loop['error']}[/]")
+        else:
+            console.print(f"  Iteration: {loop.get('iteration', 0)}")
+            console.print(f"  Phase: {loop.get('phase', 'UNKNOWN')}")
+            
+            current = loop.get("current_task")
+            if current:
+                console.print(f"  Current Task: [cyan]{current}[/]")
+            
+            completed = loop.get("tasks_completed", 0)
+            remaining = loop.get("tasks_remaining", 0)
+            total = completed + remaining
+            
+            if total > 0:
+                progress = completed / total * 100
+                bar_len = 20
+                filled = int(bar_len * completed / total)
+                bar = "█" * filled + "░" * (bar_len - filled)
+                console.print(f"  Progress: [{bar}] {progress:.0f}% ({completed}/{total})")
+            
+            success_rate = loop.get("success_rate", 1.0)
+            console.print(f"  Success Rate: {success_rate * 100:.0f}%")
+    else:
+        console.print("  [dim]Not active[/]")
+    
+    # Skills
+    console.print("\n[bold]Skills[/]")
+    if status["skills"]:
+        for skill in status["skills"]:
+            console.print(f"  • {skill}")
+    else:
+        console.print("  [dim]No skills installed[/]")
+
+
+if __name__ == "__main__":
+    status_cmd()

up/commands/summarize.py

@@ -0,0 +1,122 @@
+"""up summarize - Summarize AI conversation history."""
+
+import sys
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+
+@click.command()
+@click.option(
+    "--format", "-f",
+    type=click.Choice(["markdown", "json"]),
+    default="markdown",
+    help="Output format",
+)
+@click.option(
+    "--output", "-o",
+    type=click.Path(),
+    help="Output file path",
+)
+@click.option(
+    "--project", "-p",
+    help="Filter by project path",
+)
+@click.option(
+    "--source",
+    type=click.Choice(["cursor", "claude", "all"]),
+    default="cursor",
+    help="Conversation source to analyze",
+)
+def summarize_cmd(format: str, output: str, project: str, source: str):
+    """Summarize AI conversation history.
+    
+    Analyzes your Cursor or Claude chat history to extract:
+    - Common topics and patterns
+    - Frequent errors encountered
+    - Actionable insights
+    - Code snippets
+    
+    \b
+    Examples:
+      up summarize                     # Markdown to stdout
+      up summarize -f json -o out.json # JSON to file
+      up summarize -p myproject        # Filter by project
+    """
+    console.print(Panel.fit(
+        "[bold blue]Conversation Summarizer[/]",
+        border_style="blue"
+    ))
+    
+    try:
+        if source in ("cursor", "all"):
+            result = _summarize_cursor(format, project)
+            _output_result(result, output, format)
+        
+        if source == "claude":
+            console.print("[yellow]Claude history summarization not yet implemented.[/]")
+            console.print("Use [cyan]--source cursor[/] for Cursor history.")
+            
+    except FileNotFoundError as e:
+        console.print(f"[red]Error:[/] {e}")
+        console.print("\nMake sure Cursor is installed and has chat history.")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/] {e}")
+        sys.exit(1)
+
+
+def _summarize_cursor(format: str, project_filter: str = None) -> str:
+    """Summarize Cursor conversation history."""
+    # Add scripts to path
+    scripts_path = Path(__file__).parent.parent.parent.parent / "scripts"
+    if scripts_path.exists():
+        sys.path.insert(0, str(scripts_path))
+    
+    try:
+        from export_cursor_history import load_all_data
+    except ImportError:
+        raise FileNotFoundError(
+            "Could not import export_cursor_history. "
+            "Make sure scripts/export_cursor_history.py exists."
+        )
+    
+    from up.summarizer import ConversationSummarizer
+    
+    console.print("Loading Cursor history...", style="dim")
+    conversations = load_all_data(project_filter=project_filter)
+    
+    if not conversations:
+        raise ValueError("No conversations found in Cursor history.")
+    
+    console.print(f"Found [cyan]{len(conversations)}[/] conversations")
+    console.print("Analyzing...", style="dim")
+    
+    summarizer = ConversationSummarizer(conversations)
+    
+    if format == "json":
+        return summarizer.to_json()
+    return summarizer.to_markdown()
+
+
+def _output_result(result: str, output_path: str, format: str) -> None:
+    """Output result to file or stdout."""
+    if output_path:
+        Path(output_path).write_text(result)
+        console.print(f"\n[green]✓[/] Summary saved to [cyan]{output_path}[/]")
+    else:
+        console.print("\n")
+        if format == "markdown":
+            # Use rich markdown rendering
+            from rich.markdown import Markdown
+            console.print(Markdown(result))
+        else:
+            console.print(result)
+
+
+if __name__ == "__main__":
+    summarize_cmd()

up/context.py

@@ -0,0 +1,367 @@
+"""Context window management for AI sessions.
+
+Tracks estimated token usage and provides warnings when approaching limits.
+"""
+
+import json
+import re
+from dataclasses import dataclass, field, asdict
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+
+# Token estimation constants (rough estimates)
+CHARS_PER_TOKEN = 4  # Average characters per token
+CODE_MULTIPLIER = 1.3  # Code typically uses more tokens
+DEFAULT_BUDGET = 100_000  # Default context budget in tokens
+
+
+@dataclass
+class ContextEntry:
+    """A single context entry (file read, message, etc.)."""
+    
+    timestamp: str
+    entry_type: str  # 'file', 'message', 'tool_output'
+    source: str  # File path or description
+    estimated_tokens: int
+    
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass
+class ContextBudget:
+    """Tracks context window usage."""
+    
+    budget: int = DEFAULT_BUDGET
+    warning_threshold: float = 0.8  # Warn at 80%
+    critical_threshold: float = 0.9  # Critical at 90%
+    entries: list[ContextEntry] = field(default_factory=list)
+    total_tokens: int = 0
+    session_start: str = field(default_factory=lambda: datetime.now().isoformat())
+    
+    @property
+    def usage_percent(self) -> float:
+        """Get usage as percentage."""
+        return (self.total_tokens / self.budget) * 100 if self.budget > 0 else 0
+    
+    @property
+    def remaining_tokens(self) -> int:
+        """Get remaining token budget."""
+        return max(0, self.budget - self.total_tokens)
+    
+    @property
+    def status(self) -> str:
+        """Get status: OK, WARNING, or CRITICAL."""
+        ratio = self.total_tokens / self.budget if self.budget > 0 else 0
+        if ratio >= self.critical_threshold:
+            return "CRITICAL"
+        elif ratio >= self.warning_threshold:
+            return "WARNING"
+        return "OK"
+    
+    def to_dict(self) -> dict:
+        return {
+            "budget": self.budget,
+            "total_tokens": self.total_tokens,
+            "remaining_tokens": self.remaining_tokens,
+            "usage_percent": round(self.usage_percent, 1),
+            "status": self.status,
+            "warning_threshold": self.warning_threshold,
+            "critical_threshold": self.critical_threshold,
+            "session_start": self.session_start,
+            "entry_count": len(self.entries),
+            "entries": [e.to_dict() for e in self.entries[-20:]],  # Last 20 entries
+        }
+
+
+def estimate_tokens(text: str, is_code: bool = False) -> int:
+    """Estimate token count for text.
+    
+    Args:
+        text: The text to estimate
+        is_code: Whether the text is code (uses higher multiplier)
+        
+    Returns:
+        Estimated token count
+    """
+    if not text:
+        return 0
+    
+    # Basic character-based estimation
+    base_tokens = len(text) / CHARS_PER_TOKEN
+    
+    # Apply code multiplier if needed
+    if is_code:
+        base_tokens *= CODE_MULTIPLIER
+    
+    return int(base_tokens)
+
+
+def estimate_file_tokens(path: Path) -> int:
+    """Estimate tokens for a file.
+    
+    Args:
+        path: Path to the file
+        
+    Returns:
+        Estimated token count
+    """
+    if not path.exists():
+        return 0
+    
+    try:
+        content = path.read_text()
+    except (UnicodeDecodeError, PermissionError):
+        return 0
+    
+    # Detect if it's code
+    code_extensions = {
+        '.py', '.js', '.ts', '.tsx', '.jsx', '.go', '.rs', '.java',
+        '.c', '.cpp', '.h', '.hpp', '.rb', '.sh', '.bash', '.zsh'
+    }
+    is_code = path.suffix.lower() in code_extensions
+    
+    return estimate_tokens(content, is_code)
+
+
+class ContextManager:
+    """Manages context window budget for AI sessions."""
+    
+    def __init__(
+        self,
+        workspace: Optional[Path] = None,
+        budget: int = DEFAULT_BUDGET
+    ):
+        self.workspace = workspace or Path.cwd()
+        self.state_file = self.workspace / ".claude" / "context_budget.json"
+        self.budget = ContextBudget(budget=budget)
+        self._load_state()
+    
+    def _load_state(self) -> None:
+        """Load state from file."""
+        if self.state_file.exists():
+            try:
+                data = json.loads(self.state_file.read_text())
+                self.budget.budget = data.get("budget", DEFAULT_BUDGET)
+                self.budget.total_tokens = data.get("total_tokens", 0)
+                self.budget.session_start = data.get("session_start", datetime.now().isoformat())
+                # Reconstruct entries
+                entries_data = data.get("entries", [])
+                self.budget.entries = [
+                    ContextEntry(**e) for e in entries_data
+                ]
+            except (json.JSONDecodeError, KeyError, TypeError):
+                pass
+    
+    def _save_state(self) -> None:
+        """Save state to file."""
+        self.state_file.parent.mkdir(parents=True, exist_ok=True)
+        self.state_file.write_text(json.dumps(self.budget.to_dict(), indent=2))
+    
+    def record_file_read(self, path: Path) -> ContextEntry:
+        """Record a file being read into context.
+        
+        Args:
+            path: Path to the file read
+            
+        Returns:
+            The context entry created
+        """
+        tokens = estimate_file_tokens(path)
+        entry = ContextEntry(
+            timestamp=datetime.now().isoformat(),
+            entry_type="file",
+            source=str(path),
+            estimated_tokens=tokens
+        )
+        self.budget.entries.append(entry)
+        self.budget.total_tokens += tokens
+        self._save_state()
+        return entry
+    
+    def record_message(self, message: str, role: str = "user") -> ContextEntry:
+        """Record a message in context.
+        
+        Args:
+            message: The message content
+            role: 'user' or 'assistant'
+            
+        Returns:
+            The context entry created
+        """
+        tokens = estimate_tokens(message)
+        entry = ContextEntry(
+            timestamp=datetime.now().isoformat(),
+            entry_type="message",
+            source=f"{role} message",
+            estimated_tokens=tokens
+        )
+        self.budget.entries.append(entry)
+        self.budget.total_tokens += tokens
+        self._save_state()
+        return entry
+    
+    def record_tool_output(self, tool: str, output_size: int) -> ContextEntry:
+        """Record tool output in context.
+        
+        Args:
+            tool: Name of the tool
+            output_size: Size of output in characters
+            
+        Returns:
+            The context entry created
+        """
+        tokens = estimate_tokens("x" * output_size)  # Rough estimate
+        entry = ContextEntry(
+            timestamp=datetime.now().isoformat(),
+            entry_type="tool_output",
+            source=f"tool:{tool}",
+            estimated_tokens=tokens
+        )
+        self.budget.entries.append(entry)
+        self.budget.total_tokens += tokens
+        self._save_state()
+        return entry
+    
+    def get_status(self) -> dict:
+        """Get current context budget status.
+        
+        Returns:
+            Status dictionary with usage info
+        """
+        return self.budget.to_dict()
+    
+    def check_budget(self) -> tuple[str, str]:
+        """Check budget and return status with message.
+        
+        Returns:
+            Tuple of (status, message)
+        """
+        status = self.budget.status
+        usage = self.budget.usage_percent
+        remaining = self.budget.remaining_tokens
+        
+        if status == "CRITICAL":
+            msg = (
+                f"⚠️ CRITICAL: Context at {usage:.1f}% ({remaining:,} tokens remaining). "
+                "Consider summarizing and creating a checkpoint."
+            )
+        elif status == "WARNING":
+            msg = (
+                f"⚡ WARNING: Context at {usage:.1f}% ({remaining:,} tokens remaining). "
+                "Start planning for handoff."
+            )
+        else:
+            msg = f"✅ OK: Context at {usage:.1f}% ({remaining:,} tokens remaining)."
+        
+        return status, msg
+    
+    def reset(self) -> None:
+        """Reset context budget for new session."""
+        self.budget = ContextBudget(budget=self.budget.budget)
+        self._save_state()
+    
+    def estimate_file_impact(self, path: Path) -> dict:
+        """Estimate impact of reading a file on budget.
+        
+        Args:
+            path: Path to the file
+            
+        Returns:
+            Impact analysis dictionary
+        """
+        tokens = estimate_file_tokens(path)
+        new_total = self.budget.total_tokens + tokens
+        new_percent = (new_total / self.budget.budget) * 100 if self.budget.budget > 0 else 0
+        
+        return {
+            "file": str(path),
+            "estimated_tokens": tokens,
+            "current_total": self.budget.total_tokens,
+            "new_total": new_total,
+            "current_percent": round(self.budget.usage_percent, 1),
+            "new_percent": round(new_percent, 1),
+            "will_exceed_warning": new_percent >= self.budget.warning_threshold * 100,
+            "will_exceed_critical": new_percent >= self.budget.critical_threshold * 100,
+        }
+    
+    def suggest_files_to_drop(self, target_reduction: int) -> list[str]:
+        """Suggest files that could be dropped to reduce context.
+        
+        Args:
+            target_reduction: Target token reduction
+            
+        Returns:
+            List of file paths to consider dropping
+        """
+        # Get file entries sorted by tokens (largest first)
+        file_entries = [
+            e for e in self.budget.entries
+            if e.entry_type == "file"
+        ]
+        file_entries.sort(key=lambda e: e.estimated_tokens, reverse=True)
+        
+        suggestions = []
+        reduction = 0
+        
+        for entry in file_entries:
+            if reduction >= target_reduction:
+                break
+            suggestions.append(entry.source)
+            reduction += entry.estimated_tokens
+        
+        return suggestions
+
+
+def create_context_budget_file(target_dir: Path, budget: int = DEFAULT_BUDGET) -> Path:
+    """Create initial context budget file for a project.
+    
+    Args:
+        target_dir: Project directory
+        budget: Token budget
+        
+    Returns:
+        Path to created file
+    """
+    manager = ContextManager(workspace=target_dir, budget=budget)
+    manager.reset()
+    return manager.state_file
+
+
+# CLI integration
+if __name__ == "__main__":
+    import sys
+    
+    manager = ContextManager()
+    
+    if len(sys.argv) > 1:
+        cmd = sys.argv[1]
+        
+        if cmd == "status":
+            status, msg = manager.check_budget()
+            print(msg)
+            print(json.dumps(manager.get_status(), indent=2))
+            
+        elif cmd == "reset":
+            manager.reset()
+            print("Context budget reset for new session.")
+            
+        elif cmd == "estimate" and len(sys.argv) > 2:
+            path = Path(sys.argv[2])
+            impact = manager.estimate_file_impact(path)
+            print(json.dumps(impact, indent=2))
+            
+        elif cmd == "record" and len(sys.argv) > 2:
+            path = Path(sys.argv[2])
+            entry = manager.record_file_read(path)
+            print(f"Recorded: {entry.source} ({entry.estimated_tokens} tokens)")
+            status, msg = manager.check_budget()
+            print(msg)
+            
+        else:
+            print("Usage: python context.py [status|reset|estimate <file>|record <file>]")
+    else:
+        status, msg = manager.check_budget()
+        print(msg)