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

up/templates/learn/__init__.py

@@ -1,6 +1,7 @@
 """Learn system templates."""
 
 from pathlib import Path
+from datetime import date
 
 
 def create_learn_system(target_dir: Path, ai_target: str, force: bool = False) -> None:
@@ -20,12 +21,16 @@ def create_learn_system(target_dir: Path, ai_target: str, force: bool = False) -
     _create_skill_md(skill_dir, force)
     _create_sources_json(skill_dir, force)
     _create_patterns_md(skill_dir, force)
+    _create_gap_analysis_md(skill_dir, force)
+    _create_project_analyzer(skill_dir, force)
+    _create_prd_template(skill_dir, force)
 
 
 def _write_file(path: Path, content: str, force: bool) -> None:
     """Write file if it doesn't exist or force is True."""
     if path.exists() and not force:
         return
+    path.parent.mkdir(parents=True, exist_ok=True)
     path.write_text(content)
 
 
@@ -35,32 +40,206 @@ def _create_skill_md(skill_dir: Path, force: bool) -> None:
 name: learn
 description: Research and create improvement plans
 user-invocable: true
-allowed-tools: Read, Write, Bash, WebFetch, WebSearch
+allowed-tools: Read, Write, Bash, WebFetch, WebSearch, Glob, Grep
+version: "1.0.0"
+min-claude-version: "2024.01"
 ---
 
 # Learning System
 
-Research best practices and create actionable plans.
+Research best practices from open source projects and blogs, then create actionable improvement plans.
 
 ## Workflow
 
 ```
-RESEARCH → ANALYZE → COMPARE → PLAN
+RESEARCH → ANALYZE → COMPARE → PLAN → IMPLEMENT
 ```
 
 ## Commands
 
-- `/learn auto` - Auto-analyze project
-- `/learn research [topic]` - Research topic
-- `/learn plan` - Generate improvement PRD
+| Command | Description |
+|---------|-------------|
+| `/learn auto` | Auto-analyze project and generate insights |
+| `/learn research [topic]` | Research a specific topic |
+| `/learn analyze` | Analyze all research files |
+| `/learn compare` | Compare findings with current code |
+| `/learn plan` | Generate improvement PRD |
+| `/learn full` | Run complete pipeline |
 
-## Output Files
+## Phase 1: RESEARCH
+
+### Default Sources
+
+Read `sources.json` for configured sources. Research from:
+
+**Open Source Projects:**
+- semgrep/semgrep - Pattern-based code analysis
+- github/codeql - Query-based analysis
+- High-quality projects in your tech stack
+
+**Blogs & Documentation:**
+- Official documentation for your frameworks
+- Engineering blogs from top companies
+
+### Actions
+
+1. Use `WebSearch` to find recent articles/releases
+2. Use `WebFetch` to read project READMEs and docs
+3. Extract architecture patterns
+4. Note innovative approaches
+
+### Output
+
+Save findings to `research/YYYY-MM-DD-topic.md`:
+
+```markdown
+# Research: [Topic Name]
+
+**Created**: YYYY-MM-DD
+**Status**: 📋 Reference
+**Source**: [Project/Blog Name]
+
+---
+
+## Key Findings
+
+1. Finding 1
+2. Finding 2
+
+## Applicable Patterns
+
+- Pattern A: Description
+- Pattern B: Description
+
+## Code Examples
+
+```language
+// example code
+```
+```
+
+---
+
+## Phase 2: ANALYZE
+
+Read all research files and extract:
+
+1. **Design Patterns** - Architectural approaches
+2. **Key Innovations** - Novel techniques
+3. **Best Practices** - Industry standards
+4. **Reusable Components** - Code/concepts to adopt
+
+### Output
+
+Update `insights/patterns.md` with extracted patterns.
+
+---
+
+## Phase 3: COMPARE
+
+Compare insights with current implementation:
+
+1. Read project's main documentation (CLAUDE.md, README.md)
+2. Scan source code for current patterns
+3. Identify gaps and opportunities
+
+### Output
+
+Update `insights/gap-analysis.md` with findings.
+
+---
+
+## Phase 4: PLAN
+
+Create improvement plan as PRD:
+
+1. Prioritize gaps by impact/effort
+2. Create user stories with acceptance criteria
+3. Order by dependencies
+4. Save as `prd.json`
+
+### PRD Schema
+
+```json
+{
+  "project": "Project Name",
+  "branchName": "feature/improvements",
+  "description": "Brief description",
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "Story title",
+      "description": "Description",
+      "acceptanceCriteria": ["Criterion 1", "Criterion 2"],
+      "priority": 1,
+      "effort": "low|medium|high",
+      "passes": false
+    }
+  ]
+}
+```
+
+---
+
+## Phase 5: IMPLEMENT
+
+Hand off to Product Loop:
+
+```
+/product-loop
+```
+
+The product loop will:
+1. Read `prd.json` generated by learning system
+2. Execute tasks with circuit breaker protection
+3. Checkpoint before risky changes
+4. Track progress
+
+---
+
+## AUTO Mode
+
+When `/learn auto` is invoked:
+
+1. Scan the codebase to detect technologies and patterns
+2. Identify improvement areas automatically
+3. Generate research topics based on findings
+4. Research each topic (limit: 3 topics)
+5. Continue with analyze → compare → plan
+
+### Auto Mode Output
+
+```
+Project Profile:
+- Languages: Python, TypeScript
+- Frameworks: FastAPI, React
+- Patterns: Repository Pattern, React Hooks
+- Improvements: add-caching, optimize-queries
+- Topics: FastAPI caching best practices, React performance
+```
+
+---
+
+## State Files
 
 | File | Purpose |
 |------|---------|
-| `research/*.md` | Research notes |
+| `sources.json` | Research sources config |
+| `research/*.md` | Raw research notes |
 | `insights/patterns.md` | Extracted patterns |
-| `prd.json` | Improvement plan |
+| `insights/gap-analysis.md` | Gap analysis |
+| `prd.json` | Generated improvement plan |
+
+---
+
+## Context Budget
+
+This skill is context-aware:
+- Estimates token usage before reading files
+- Warns when approaching budget limits
+- Suggests summarization when needed
+
+Check budget: Read `.claude/context_budget.json`
 """
     _write_file(skill_dir / "SKILL.md", content, force)
 
@@ -68,9 +247,27 @@ RESEARCH → ANALYZE → COMPARE → PLAN
 def _create_sources_json(skill_dir: Path, force: bool) -> None:
     """Create sources.json config."""
     content = """{
-  "projects": [],
-  "blogs": [],
-  "topics": []
+  "version": "1.0",
+  "updated": "",
+  "projects": [
+    {
+      "name": "example-project",
+      "repo": "owner/repo",
+      "category": "reference",
+      "topics": ["topic1", "topic2"],
+      "docs_url": "https://docs.example.com/"
+    }
+  ],
+  "blogs": [
+    {
+      "name": "Example Blog",
+      "url": "https://blog.example.com/",
+      "topics": ["topic1", "topic2"]
+    }
+  ],
+  "research_topics": [
+    "Add topics relevant to your project"
+  ]
 }
 """
     _write_file(skill_dir / "sources.json", content, force)
@@ -78,16 +275,372 @@ def _create_sources_json(skill_dir: Path, force: bool) -> None:
 
 def _create_patterns_md(skill_dir: Path, force: bool) -> None:
     """Create patterns template."""
-    content = """# Extracted Patterns
+    today = date.today().isoformat()
+    content = f"""# Extracted Patterns
 
+**Created**: {today}
+**Updated**: {today}
 **Status**: 🔄 Active
 
 ---
 
+## How to Use
+
+Add patterns discovered during research phases.
+
+---
+
 ## Pattern Template
 
+### Pattern: [Name]
+
 - **Source**: Project/Blog
+- **Category**: Architecture | Design | Performance | Security
 - **Description**: What it does
-- **Applicability**: How to use it
+- **Implementation**: How it works
+- **Applicability**: How we can use it
+- **Trade-offs**: Pros and cons
+
+### Code Example
+
+```language
+// Example implementation
+```
+
+---
+
+## Patterns
+
+*Add patterns below this line*
+
+---
 """
     _write_file(skill_dir / "insights/patterns.md", content, force)
+
+
+def _create_gap_analysis_md(skill_dir: Path, force: bool) -> None:
+    """Create gap analysis template."""
+    today = date.today().isoformat()
+    content = f"""# Gap Analysis
+
+**Created**: {today}
+**Updated**: {today}
+**Status**: 🔄 Active
+
+---
+
+## Summary
+
+| Impact | Count | Description |
+|--------|-------|-------------|
+| 🔴 High | 0 | Critical gaps |
+| 🟡 Medium | 0 | Important gaps |
+| 🟢 Low | 0 | Nice-to-have |
+
+---
+
+## Gap Template
+
+### Gap: [Name]
+
+- **Current State**: What we have now
+- **Best Practice**: What leading projects do
+- **Impact**: 🔴 High | 🟡 Medium | 🟢 Low
+- **Effort**: Low | Medium | High
+- **Recommendation**: What to do
+
+---
+
+## Identified Gaps
+
+*Add gaps below this line*
+
+---
+"""
+    _write_file(skill_dir / "insights/gap-analysis.md", content, force)
+
+
+def _create_project_analyzer(skill_dir: Path, force: bool) -> None:
+    """Create project analyzer script."""
+    content = '''#!/usr/bin/env python3
+"""
+Project Analyzer - Automatically identifies improvement areas in the codebase.
+
+Usage:
+    python project_analyzer.py [--workspace /path/to/project]
+"""
+
+import json
+import os
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass
+class ProjectProfile:
+    """Profile of the current project."""
+    name: str
+    languages: list[str] = field(default_factory=list)
+    frameworks: list[str] = field(default_factory=list)
+    patterns_detected: list[str] = field(default_factory=list)
+    improvement_areas: list[str] = field(default_factory=list)
+    research_topics: list[str] = field(default_factory=list)
+
+
+class ProjectAnalyzer:
+    """Analyzes project to identify improvement opportunities."""
+
+    # File extension to language mapping
+    EXTENSIONS = {
+        ".py": "Python",
+        ".js": "JavaScript",
+        ".ts": "TypeScript",
+        ".tsx": "TypeScript",
+        ".jsx": "JavaScript",
+        ".go": "Go",
+        ".rs": "Rust",
+        ".java": "Java",
+        ".rb": "Ruby",
+        ".php": "PHP",
+        ".swift": "Swift",
+        ".kt": "Kotlin",
+    }
+    
+    # Framework indicators
+    FRAMEWORK_INDICATORS = {
+        # Python
+        "fastapi": "FastAPI",
+        "django": "Django",
+        "flask": "Flask",
+        "langchain": "LangChain",
+        "langgraph": "LangGraph",
+        "pytest": "pytest",
+        "sqlalchemy": "SQLAlchemy",
+        # JavaScript/TypeScript
+        "react": "React",
+        "next": "Next.js",
+        "vue": "Vue.js",
+        "express": "Express",
+        "nestjs": "NestJS",
+        # Others
+        "spring": "Spring",
+        "rails": "Rails",
+    }
+    
+    # Pattern indicators (regex patterns)
+    PATTERN_INDICATORS = {
+        r"class.*Repository": "Repository Pattern",
+        r"class.*Factory": "Factory Pattern",
+        r"class.*Service": "Service Layer",
+        r"@dataclass": "Dataclasses",
+        r"class.*Protocol": "Protocol Pattern",
+        r"async def": "Async/Await",
+        r"useEffect|useState": "React Hooks",
+        r"def test_": "Unit Tests",
+    }
+
+    def __init__(self, workspace: Optional[Path] = None):
+        self.workspace = workspace or Path.cwd()
+
+    def analyze(self) -> ProjectProfile:
+        """Analyze the project and return a profile."""
+        profile = ProjectProfile(name=self.workspace.name)
+        
+        profile.languages = self._detect_languages()
+        profile.frameworks = self._detect_frameworks()
+        profile.patterns_detected = self._detect_patterns()
+        profile.improvement_areas = self._identify_improvements(profile)
+        profile.research_topics = self._generate_topics(profile)
+        
+        return profile
+
+    def _detect_languages(self) -> list[str]:
+        """Detect programming languages in the project."""
+        found = set()
+        skip_dirs = {".git", "node_modules", "__pycache__", ".venv", "venv", "build", "dist"}
+        
+        for root, dirs, files in os.walk(self.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 self.EXTENSIONS:
+                    found.add(self.EXTENSIONS[ext])
+        
+        return sorted(found)
+
+    def _detect_frameworks(self) -> list[str]:
+        """Detect frameworks and tools in use."""
+        frameworks = []
+        
+        # Check common config files
+        config_files = [
+            self.workspace / "pyproject.toml",
+            self.workspace / "requirements.txt",
+            self.workspace / "package.json",
+            self.workspace / "Cargo.toml",
+            self.workspace / "go.mod",
+        ]
+        
+        for config in config_files:
+            if config.exists():
+                try:
+                    content = config.read_text().lower()
+                    for key, name in self.FRAMEWORK_INDICATORS.items():
+                        if key in content:
+                            frameworks.append(name)
+                except Exception:
+                    pass
+        
+        return list(set(frameworks))
+
+    def _detect_patterns(self) -> list[str]:
+        """Detect code patterns in use."""
+        patterns = set()
+        skip_dirs = {".git", "node_modules", "__pycache__", ".venv"}
+        
+        src_dir = self.workspace / "src"
+        if not src_dir.exists():
+            src_dir = self.workspace
+        
+        code_extensions = {".py", ".js", ".ts", ".tsx", ".jsx", ".go", ".rs", ".java"}
+        
+        for root, dirs, files in os.walk(src_dir):
+            dirs[:] = [d for d in dirs if d not in skip_dirs]
+            
+            for f in files:
+                if Path(f).suffix.lower() not in code_extensions:
+                    continue
+                    
+                filepath = Path(root) / f
+                try:
+                    content = filepath.read_text()
+                    for pattern, name in self.PATTERN_INDICATORS.items():
+                        if re.search(pattern, content, re.IGNORECASE):
+                            patterns.add(name)
+                except Exception:
+                    continue
+        
+        return sorted(patterns)
+
+    def _identify_improvements(self, profile: ProjectProfile) -> list[str]:
+        """Identify areas that could be improved."""
+        improvements = []
+        
+        # Check for missing patterns
+        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 "TypeScript" in profile.languages:
+            if "Unit Tests" not in profile.patterns_detected:
+                improvements.append("add-unit-tests")
+        
+        # Check for optimization opportunities
+        if any(f in profile.frameworks for f in ["FastAPI", "Django", "Flask"]):
+            improvements.append("add-caching")
+            improvements.append("optimize-queries")
+        
+        if "React" in profile.frameworks:
+            improvements.append("optimize-renders")
+        
+        return list(set(improvements))
+
+    def _generate_topics(self, profile: ProjectProfile) -> list[str]:
+        """Generate research topics based on profile."""
+        topics = []
+        
+        # Map improvements to research topics
+        topic_map = {
+            "add-unit-tests": "testing best practices",
+            "add-interfaces": "Python Protocol and ABC patterns",
+            "add-caching": "caching strategies",
+            "optimize-queries": "database query optimization",
+            "optimize-renders": "React performance optimization",
+        }
+        
+        for improvement in profile.improvement_areas:
+            if improvement in topic_map:
+                topics.append(topic_map[improvement])
+        
+        # Add framework-specific topics
+        for framework in profile.frameworks[:2]:  # Limit to 2
+            topics.append(f"{framework} best practices")
+        
+        return topics[:5]  # Limit to 5 topics
+
+    def save_profile(self, profile: ProjectProfile) -> Path:
+        """Save profile to JSON file."""
+        filepath = self.workspace / ".claude/skills/learning-system/project_profile.json"
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+        
+        data = {
+            "name": profile.name,
+            "languages": profile.languages,
+            "frameworks": profile.frameworks,
+            "patterns_detected": profile.patterns_detected,
+            "improvement_areas": profile.improvement_areas,
+            "research_topics": profile.research_topics,
+        }
+        
+        filepath.write_text(json.dumps(data, indent=2))
+        return filepath
+
+
+def main():
+    import sys
+    
+    workspace = None
+    if len(sys.argv) > 2 and sys.argv[1] == "--workspace":
+        workspace = Path(sys.argv[2])
+    
+    analyzer = ProjectAnalyzer(workspace)
+    profile = analyzer.analyze()
+    
+    print(f"Project: {profile.name}")
+    print(f"Languages: {', '.join(profile.languages) or 'None detected'}")
+    print(f"Frameworks: {', '.join(profile.frameworks) or 'None detected'}")
+    print(f"Patterns: {', '.join(profile.patterns_detected) or 'None detected'}")
+    print(f"Improvements: {', '.join(profile.improvement_areas) or 'None identified'}")
+    print(f"Topics: {', '.join(profile.research_topics) or 'None generated'}")
+    
+    # Save profile
+    path = analyzer.save_profile(profile)
+    print(f"\\nProfile saved to: {path}")
+
+
+if __name__ == "__main__":
+    main()
+'''
+    _write_file(skill_dir / "project_analyzer.py", content, force)
+
+
+def _create_prd_template(skill_dir: Path, force: bool) -> None:
+    """Create PRD template file."""
+    content = """{
+  "project": "Project Improvements",
+  "branchName": "feature/improvements",
+  "description": "Improvements identified by learning system",
+  "createdAt": "",
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "Example User Story",
+      "description": "As a developer, I want X so that Y",
+      "acceptanceCriteria": [
+        "Criterion 1",
+        "Criterion 2"
+      ],
+      "priority": 1,
+      "effort": "medium",
+      "passes": false,
+      "notes": ""
+    }
+  ]
+}
+"""
+    _write_file(skill_dir / "prd_template.json", content, force)