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

up/learn/__init__.py

@@ -0,0 +1,155 @@
+"""Learning system CLI commands.
+
+This module provides the main CLI entry points for the learning system.
+The implementation is split across several submodules:
+- utils: Shared utilities
+- analyzer: Project analysis
+- research: Topic and file learning
+- plan: PRD generation
+"""
+
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+
+from up.learn.utils import check_vision_map_exists, is_valid_path, find_skill_dir, display_profile, save_profile
+from up.learn.analyzer import analyze_project, learn_self_improvement
+from up.learn.research import learn_from_topic, learn_from_file, learn_from_project
+from up.learn.plan import learn_analyze, learn_plan, learn_status
+
+console = Console()
+
+
+@click.group(invoke_without_command=True)
+@click.argument("topic_or_path", required=False)
+@click.option("--workspace", "-w", type=click.Path(exists=True), help="Workspace path")
+@click.option("--no-ai", is_flag=True, help="Disable AI analysis")
+@click.pass_context
+def learn_cmd(ctx, topic_or_path: str, workspace: str, no_ai: bool):
+    """Learning system - analyze, research, and improve.
+    
+    \b
+    Usage:
+      up learn                    Auto-analyze and improve
+      up learn "topic"            Learn about a specific topic
+      up learn "file.md"          Analyze file with AI
+      up learn "project/path"     Compare and learn from another project
+    
+    \b
+    Subcommands:
+      up learn auto               Analyze project (no vision check)
+      up learn analyze            Analyze all research files
+      up learn plan               Generate improvement PRD
+      up learn status             Show learning system status
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+    
+    ctx.ensure_object(dict)
+    ctx.obj['workspace'] = workspace
+    ctx.obj['no_ai'] = no_ai
+    
+    # Check if topic_or_path is a subcommand
+    subcommands = ["auto", "analyze", "plan", "status"]
+    if topic_or_path in subcommands:
+        subcmd = ctx.command.commands[topic_or_path]
+        ctx.invoke(subcmd, workspace=workspace)
+        return
+    
+    ws = Path(workspace) if workspace else Path.cwd()
+    use_ai = not no_ai
+    
+    # No argument: self-improvement mode
+    if not topic_or_path:
+        vision_exists, vision_path = check_vision_map_exists(ws)
+        
+        if not vision_exists:
+            console.print(Panel.fit(
+                "[yellow]Vision Map Not Configured[/]",
+                border_style="yellow"
+            ))
+            console.print("\nThe learning system requires a configured vision map.")
+            console.print(f"\nPlease configure: [cyan]{vision_path}[/]")
+            console.print("\n[bold]Alternatives:[/]")
+            console.print("  • [cyan]up learn auto[/] - Analyze without vision map")
+            console.print("  • [cyan]up learn \"topic\"[/] - Learn about specific topic")
+            return
+        
+        learn_self_improvement(ws, use_ai=use_ai)
+        return
+    
+    # Has argument: determine if topic or path
+    if is_valid_path(topic_or_path):
+        learn_from_project(ws, topic_or_path, use_ai=use_ai)
+    else:
+        learn_from_topic(ws, topic_or_path, use_ai=use_ai)
+
+
+@learn_cmd.command("auto")
+@click.option("--workspace", "-w", type=click.Path(exists=True), help="Workspace path")
+def auto_cmd(workspace: str):
+    """Auto-analyze project and identify improvements."""
+    ws = Path(workspace) if workspace else Path.cwd()
+    
+    console.print(Panel.fit(
+        "[bold blue]Learning System[/] - Auto Analysis",
+        border_style="blue"
+    ))
+    
+    profile = analyze_project(ws)
+    
+    if profile is None:
+        console.print("[red]Error: Could not analyze project[/]")
+        return
+    
+    display_profile(profile)
+    
+    save_path = save_profile(ws, profile)
+    console.print(f"\n[green]✓[/] Profile saved to: [cyan]{save_path}[/]")
+    
+    console.print("\n[bold]Next Steps:[/]")
+    if profile.get("research_topics"):
+        console.print("  1. Research topics with: [cyan]up learn \"topic\"[/]")
+    console.print("  2. Generate PRD with: [cyan]up learn plan[/]")
+    console.print("  3. Start development with: [cyan]up start[/]")
+
+
+@learn_cmd.command("analyze")
+@click.option("--workspace", "-w", type=click.Path(exists=True), help="Workspace path")
+def analyze_cmd(workspace: str):
+    """Analyze all research files with AI."""
+    ws = Path(workspace) if workspace else Path.cwd()
+    learn_analyze(ws)
+
+
+@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 plan_cmd(workspace: str, output: str):
+    """Generate improvement PRD from analysis."""
+    ws = Path(workspace) if workspace else Path.cwd()
+    learn_plan(ws, output)
+
+
+@learn_cmd.command("status")
+@click.option("--workspace", "-w", type=click.Path(exists=True), help="Workspace path")
+def status_cmd(workspace: str):
+    """Show learning system status."""
+    ws = Path(workspace) if workspace else Path.cwd()
+    learn_status(ws)
+
+
+# Export for external use
+__all__ = [
+    "learn_cmd",
+    "analyze_project",
+    "learn_self_improvement",
+    "learn_from_topic",
+    "learn_from_file",
+    "learn_from_project",
+    "learn_analyze",
+    "learn_plan",
+    "learn_status",
+]

up/learn/analyzer.py

@@ -0,0 +1,227 @@
+"""Project analysis for the learning system."""
+
+import os
+import re
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+
+from up.learn.utils import find_skill_dir, display_profile, save_profile, load_profile, record_to_memory
+
+console = Console()
+
+
+def analyze_project(workspace: Path) -> dict:
+    """Analyze project and return profile."""
+    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 analyze_project_structure(project_path: Path) -> list:
+    """Analyze project directory structure for insights."""
+    insights = []
+    
+    good_patterns = {
+        "src": "Source code organization in src/ directory",
+        "tests": "Dedicated tests/ directory",
+        "docs": "Documentation directory present",
+        ".github": "GitHub workflows/CI present",
+        "scripts": "Automation scripts directory",
+        "__init__.py": "Proper Python package structure",
+        "pyproject.toml": "Modern Python packaging (PEP 517)",
+        "Makefile": "Make-based automation",
+        "docker-compose": "Docker containerization",
+    }
+    
+    for pattern, description in good_patterns.items():
+        if (project_path / pattern).exists() or any(project_path.glob(f"**/{pattern}")):
+            insights.append(description)
+    
+    return insights[:5]
+
+
+def learn_self_improvement(workspace: Path, use_ai: bool = True) -> dict:
+    """Analyze current project for self-improvement opportunities."""
+    from rich.panel import Panel
+    
+    console.print(Panel.fit(
+        "[bold blue]Learning System[/] - Self-Improvement Analysis",
+        border_style="blue"
+    ))
+    
+    profile = analyze_project(workspace)
+    if not profile:
+        return {}
+    
+    # Load existing profile to track improvements
+    old_profile = load_profile(workspace)
+    
+    # Identify what changed
+    improvements = {
+        "new_patterns": [],
+        "new_frameworks": [],
+        "addressed_improvements": [],
+        "remaining_improvements": [],
+    }
+    
+    old_patterns = set(old_profile.get("patterns_detected", []))
+    new_patterns = set(profile.get("patterns_detected", []))
+    improvements["new_patterns"] = list(new_patterns - old_patterns)
+    
+    old_frameworks = set(old_profile.get("frameworks", []))
+    new_frameworks = set(profile.get("frameworks", []))
+    improvements["new_frameworks"] = list(new_frameworks - old_frameworks)
+    
+    old_areas = set(old_profile.get("improvement_areas", []))
+    new_areas = set(profile.get("improvement_areas", []))
+    improvements["addressed_improvements"] = list(old_areas - new_areas)
+    improvements["remaining_improvements"] = list(new_areas)
+    
+    # Display results
+    display_profile(profile)
+    
+    if improvements["new_patterns"]:
+        console.print("\n[green]✓ New Patterns Adopted:[/]")
+        for p in improvements["new_patterns"]:
+            console.print(f"  • {p}")
+    
+    if improvements["addressed_improvements"]:
+        console.print("\n[green]✓ Improvements Addressed:[/]")
+        for a in improvements["addressed_improvements"]:
+            console.print(f"  • {a}")
+    
+    if improvements["remaining_improvements"]:
+        console.print("\n[yellow]○ Areas for Improvement:[/]")
+        for r in improvements["remaining_improvements"]:
+            console.print(f"  • {r}")
+    
+    # Save updated profile
+    save_path = save_profile(workspace, profile)
+    console.print(f"\n[green]✓[/] Profile updated: [cyan]{save_path}[/]")
+    
+    # Record to memory
+    content = f"Self-improvement analysis: Found {len(profile.get('patterns_detected', []))} patterns, "
+    content += f"{len(improvements.get('new_patterns', []))} new patterns adopted"
+    record_to_memory(workspace, content)
+    
+    return improvements