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

up/cli.py

@@ -5,23 +5,49 @@ from rich.console import Console
 
 from up.commands.init import init_cmd
 from up.commands.new import new_cmd
+from up.commands.status import status_cmd
+from up.commands.learn import learn_cmd
+from up.commands.summarize import summarize_cmd
+from up.commands.dashboard import dashboard_cmd
+from up.commands.start import start_cmd
 
 console = Console()
 
 
 @click.group()
-@click.version_option(version="0.1.0", prog_name="up")
+@click.version_option(version="0.2.0", prog_name="up")
 def main():
     """up - AI-powered project scaffolding.
 
     Create projects with built-in docs, learn, and product-loop systems
     for Claude Code and Cursor AI.
+    
+    \b
+    Quick Start:
+      up new my-project       Create new project
+      up init                 Initialize in existing project
+      up start                Start the product loop
+      up status               Show system health
+      up dashboard            Live health dashboard
+      up learn auto           Analyze project for improvements
+      up summarize            Summarize AI conversations
+    
+    \b
+    Project Templates:
+      up new api --template fastapi      FastAPI backend
+      up new app --template nextjs       Next.js frontend
+      up new lib --template python-lib   Python library
     """
     pass
 
 
 main.add_command(init_cmd, name="init")
 main.add_command(new_cmd, name="new")
+main.add_command(start_cmd, name="start")
+main.add_command(status_cmd, name="status")
+main.add_command(dashboard_cmd, name="dashboard")
+main.add_command(learn_cmd, name="learn")
+main.add_command(summarize_cmd, name="summarize")
 
 
 if __name__ == "__main__":

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/learn.py

@@ -0,0 +1,381 @@
+"""up learn - Learning system CLI commands."""
+
+import json
+import sys
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+console = Console()
+
+
+@click.group()
+def learn_cmd():
+    """Learning system commands.
+    
+    Research best practices, analyze code, and generate improvement plans.
+    """
+    pass
+
+
+@learn_cmd.command("auto")
+@click.option("--workspace", "-w", type=click.Path(exists=True), help="Workspace path")
+def learn_auto(workspace: str):
+    """Auto-analyze project and identify improvements.
+    
+    Scans the codebase to detect technologies, patterns, and
+    generate research topics for improvement.
+    """
+    ws = Path(workspace) if workspace else Path.cwd()
+    
+    console.print(Panel.fit(
+        "[bold blue]Learning System[/] - Auto Analysis",
+        border_style="blue"
+    ))
+    
+    # Run project analyzer
+    profile = analyze_project(ws)
+    
+    if profile is None:
+        console.print("[red]Error: Could not analyze project[/]")
+        return
+    
+    # Display results
+    display_profile(profile)
+    
+    # Save profile
+    save_path = save_profile(ws, profile)
+    console.print(f"\n[green]✓[/] Profile saved to: [cyan]{save_path}[/]")
+    
+    # Suggest next steps
+    console.print("\n[bold]Next Steps:[/]")
+    if profile.get("research_topics"):
+        console.print("  1. Research topics with: [cyan]up learn research \"topic\"[/]")
+    console.print("  2. Generate PRD with: [cyan]up learn plan[/]")
+    console.print("  3. Start development with: [cyan]/product-loop[/]")
+
+
+@learn_cmd.command("analyze")
+@click.option("--workspace", "-w", type=click.Path(exists=True), help="Workspace path")
+def learn_analyze(workspace: str):
+    """Analyze all research files and extract patterns."""
+    ws = Path(workspace) if workspace else Path.cwd()
+    
+    research_dir = find_skill_dir(ws, "learning-system") / "research"
+    insights_dir = find_skill_dir(ws, "learning-system") / "insights"
+    
+    if not research_dir.exists():
+        console.print("[yellow]No research files found.[/]")
+        console.print("Run [cyan]up learn research \"topic\"[/] first.")
+        return
+    
+    console.print(Panel.fit(
+        "[bold blue]Learning System[/] - Analyze Research",
+        border_style="blue"
+    ))
+    
+    # Count research files
+    research_files = list(research_dir.glob("*.md"))
+    console.print(f"Found [cyan]{len(research_files)}[/] research files")
+    
+    for f in research_files:
+        console.print(f"  • {f.name}")
+    
+    console.print("\n[bold]Analysis:[/]")
+    console.print("  Use Claude/Cursor to analyze research files and update:")
+    console.print(f"  • [cyan]{insights_dir}/patterns.md[/]")
+    console.print(f"  • [cyan]{insights_dir}/gap-analysis.md[/]")
+
+
+@learn_cmd.command("plan")
+@click.option("--workspace", "-w", type=click.Path(exists=True), help="Workspace path")
+@click.option("--output", "-o", type=click.Path(), help="Output file path")
+def learn_plan(workspace: str, output: str):
+    """Generate improvement plan (PRD) from analysis."""
+    ws = Path(workspace) if workspace else Path.cwd()
+    
+    console.print(Panel.fit(
+        "[bold blue]Learning System[/] - Generate PRD",
+        border_style="blue"
+    ))
+    
+    # Check for gap analysis
+    skill_dir = find_skill_dir(ws, "learning-system")
+    gap_file = skill_dir / "insights/gap-analysis.md"
+    
+    if not gap_file.exists():
+        console.print("[yellow]No gap analysis found.[/]")
+        console.print("Run analysis first to identify gaps.")
+        return
+    
+    # Load profile if exists
+    profile_file = skill_dir / "project_profile.json"
+    profile = {}
+    if profile_file.exists():
+        try:
+            profile = json.loads(profile_file.read_text())
+        except json.JSONDecodeError:
+            pass
+    
+    # Generate PRD template
+    output_path = Path(output) if output else skill_dir / "prd.json"
+    prd = generate_prd_template(profile)
+    
+    output_path.write_text(json.dumps(prd, indent=2))
+    console.print(f"[green]✓[/] PRD template created: [cyan]{output_path}[/]")
+    console.print("\nEdit the PRD to add specific user stories based on gap analysis.")
+    console.print("Then run [cyan]/product-loop[/] to start development.")
+
+
+@learn_cmd.command("status")
+@click.option("--workspace", "-w", type=click.Path(exists=True), help="Workspace path")
+def learn_status(workspace: str):
+    """Show learning system status."""
+    ws = Path(workspace) if workspace else Path.cwd()
+    
+    console.print(Panel.fit(
+        "[bold blue]Learning System[/] - Status",
+        border_style="blue"
+    ))
+    
+    skill_dir = find_skill_dir(ws, "learning-system")
+    
+    if not skill_dir.exists():
+        console.print("[yellow]Learning system not initialized.[/]")
+        console.print("Run [cyan]up init[/] to set up.")
+        return
+    
+    # Check files
+    files = {
+        "Project Profile": skill_dir / "project_profile.json",
+        "Sources Config": skill_dir / "sources.json",
+        "Patterns": skill_dir / "insights/patterns.md",
+        "Gap Analysis": skill_dir / "insights/gap-analysis.md",
+        "PRD": skill_dir / "prd.json",
+    }
+    
+    table = Table(title="Learning System Files")
+    table.add_column("File", style="cyan")
+    table.add_column("Status")
+    
+    for name, path in files.items():
+        if path.exists():
+            table.add_row(name, "[green]✓ exists[/]")
+        else:
+            table.add_row(name, "[dim]○ not created[/]")
+    
+    console.print(table)
+    
+    # Count research files
+    research_dir = skill_dir / "research"
+    if research_dir.exists():
+        research_count = len(list(research_dir.glob("*.md")))
+        console.print(f"\nResearch files: [cyan]{research_count}[/]")
+
+
+def find_skill_dir(workspace: Path, skill_name: str) -> Path:
+    """Find skill directory (Claude or Cursor)."""
+    claude_skill = workspace / f".claude/skills/{skill_name}"
+    cursor_skill = workspace / f".cursor/skills/{skill_name}"
+    
+    if claude_skill.exists():
+        return claude_skill
+    if cursor_skill.exists():
+        return cursor_skill
+    
+    # Default to Claude
+    return claude_skill
+
+
+def analyze_project(workspace: Path) -> dict:
+    """Analyze project and return profile."""
+    import os
+    import re
+    
+    profile = {
+        "name": workspace.name,
+        "languages": [],
+        "frameworks": [],
+        "patterns_detected": [],
+        "improvement_areas": [],
+        "research_topics": [],
+    }
+    
+    # Extension to language mapping
+    extensions = {
+        ".py": "Python",
+        ".js": "JavaScript",
+        ".ts": "TypeScript",
+        ".tsx": "TypeScript",
+        ".go": "Go",
+        ".rs": "Rust",
+        ".java": "Java",
+        ".rb": "Ruby",
+    }
+    
+    # Framework indicators
+    framework_indicators = {
+        "fastapi": "FastAPI",
+        "django": "Django",
+        "flask": "Flask",
+        "react": "React",
+        "next": "Next.js",
+        "vue": "Vue.js",
+        "langchain": "LangChain",
+        "langgraph": "LangGraph",
+        "express": "Express",
+        "pytest": "pytest",
+    }
+    
+    # Detect languages
+    skip_dirs = {".git", "node_modules", "__pycache__", ".venv", "venv", "build", "dist"}
+    found_languages = set()
+    
+    for root, dirs, files in os.walk(workspace):
+        dirs[:] = [d for d in dirs if d not in skip_dirs]
+        for f in files:
+            ext = Path(f).suffix.lower()
+            if ext in extensions:
+                found_languages.add(extensions[ext])
+    
+    profile["languages"] = sorted(found_languages)
+    
+    # Detect frameworks
+    config_files = [
+        workspace / "pyproject.toml",
+        workspace / "requirements.txt",
+        workspace / "package.json",
+    ]
+    
+    found_frameworks = set()
+    for config in config_files:
+        if config.exists():
+            try:
+                content = config.read_text().lower()
+                for key, name in framework_indicators.items():
+                    if key in content:
+                        found_frameworks.add(name)
+            except Exception:
+                pass
+    
+    profile["frameworks"] = sorted(found_frameworks)
+    
+    # Detect patterns
+    pattern_indicators = {
+        r"class.*Repository": "Repository Pattern",
+        r"class.*Service": "Service Layer",
+        r"@dataclass": "Dataclasses",
+        r"async def": "Async/Await",
+        r"def test_": "Unit Tests",
+        r"Protocol\)": "Protocol Pattern",
+    }
+    
+    src_dir = workspace / "src"
+    if not src_dir.exists():
+        src_dir = workspace
+    
+    found_patterns = set()
+    for py_file in src_dir.rglob("*.py"):
+        try:
+            content = py_file.read_text()
+            for pattern, name in pattern_indicators.items():
+                if re.search(pattern, content, re.IGNORECASE):
+                    found_patterns.add(name)
+        except Exception:
+            continue
+    
+    profile["patterns_detected"] = sorted(found_patterns)
+    
+    # Identify improvements
+    improvements = []
+    if "Python" in profile["languages"]:
+        if "Unit Tests" not in profile["patterns_detected"]:
+            improvements.append("add-unit-tests")
+        if "Protocol Pattern" not in profile["patterns_detected"]:
+            improvements.append("add-interfaces")
+    
+    if any(f in profile["frameworks"] for f in ["FastAPI", "Django", "Flask"]):
+        improvements.append("add-caching")
+    
+    profile["improvement_areas"] = improvements
+    
+    # Generate research topics
+    topic_map = {
+        "add-unit-tests": "testing best practices",
+        "add-interfaces": "Python Protocol patterns",
+        "add-caching": "caching strategies",
+    }
+    
+    topics = [topic_map[i] for i in improvements if i in topic_map]
+    for fw in profile["frameworks"][:2]:
+        topics.append(f"{fw} best practices")
+    
+    profile["research_topics"] = topics[:5]
+    
+    return profile
+
+
+def display_profile(profile: dict) -> None:
+    """Display profile in rich format."""
+    table = Table(title="Project Profile")
+    table.add_column("Aspect", style="cyan")
+    table.add_column("Detected")
+    
+    table.add_row("Name", profile.get("name", "Unknown"))
+    table.add_row("Languages", ", ".join(profile.get("languages", [])) or "None")
+    table.add_row("Frameworks", ", ".join(profile.get("frameworks", [])) or "None")
+    table.add_row("Patterns", ", ".join(profile.get("patterns_detected", [])) or "None")
+    table.add_row("Improvements", ", ".join(profile.get("improvement_areas", [])) or "None")
+    table.add_row("Research Topics", ", ".join(profile.get("research_topics", [])) or "None")
+    
+    console.print(table)
+
+
+def save_profile(workspace: Path, profile: dict) -> Path:
+    """Save profile to JSON file."""
+    skill_dir = find_skill_dir(workspace, "learning-system")
+    skill_dir.mkdir(parents=True, exist_ok=True)
+    
+    filepath = skill_dir / "project_profile.json"
+    filepath.write_text(json.dumps(profile, indent=2))
+    return filepath
+
+
+def generate_prd_template(profile: dict) -> dict:
+    """Generate PRD template from profile."""
+    from datetime import date
+    
+    prd = {
+        "project": profile.get("name", "Project") + " Improvements",
+        "branchName": "feature/improvements",
+        "description": "Improvements identified by learning system",
+        "createdAt": date.today().isoformat(),
+        "userStories": [],
+    }
+    
+    # Generate user stories from improvement areas
+    for i, area in enumerate(profile.get("improvement_areas", []), 1):
+        story = {
+            "id": f"US-{i:03d}",
+            "title": area.replace("-", " ").title(),
+            "description": f"Implement {area.replace('-', ' ')}",
+            "acceptanceCriteria": [
+                "Implementation complete",
+                "Tests passing",
+                "Documentation updated",
+            ],
+            "priority": i,
+            "effort": "medium",
+            "passes": False,
+            "notes": "",
+        }
+        prd["userStories"].append(story)
+    
+    return prd
+
+
+if __name__ == "__main__":
+    learn_cmd()