compound-engineering-pi 0.2.3

package/plugins/coding-tutor/skills/coding-tutor/scripts/quiz_priority.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""
+Prioritize tutorials for quizzing based on spaced repetition.
+
+Usage: python3 quiz_priority.py
+       python3 quiz_priority.py --tutorials-dir /path/to/tutorials
+
+Returns tutorials ordered by quiz urgency (most urgent first).
+"""
+
+import argparse
+import re
+import subprocess
+from datetime import datetime
+from pathlib import Path
+
+
+def get_tutorials_directory():
+    """Get the tutorials directory (~/coding-tutor-tutorials/)."""
+    return Path.home() / "coding-tutor-tutorials"
+
+# Ideal days between quizzes based on understanding score
+# Lower scores = more frequent review needed
+INTERVALS = {
+    0: 1,    # Never assessed - urgent
+    1: 2,
+    2: 3,
+    3: 5,
+    4: 8,
+    5: 13,
+    6: 21,
+    7: 34,
+    8: 55,
+    9: 89,
+    10: 144  # Fibonacci-ish progression
+}
+
+
+def parse_frontmatter(filepath):
+    """Extract YAML frontmatter from tutorial."""
+    content = filepath.read_text()
+
+    # Match YAML frontmatter between --- delimiters
+    match = re.match(r'^---\s*\n(.*?)\n---\s*\n', content, re.DOTALL)
+    if not match:
+        return None
+
+    frontmatter_text = match.group(1)
+    metadata = {'filepath': str(filepath)}
+
+    # Parse simple YAML key: value pairs
+    for line in frontmatter_text.split('\n'):
+        line = line.strip()
+        if ':' in line:
+            key, value = line.split(':', 1)
+            key = key.strip()
+            value = value.strip()
+
+            # Handle null values
+            if value == 'null':
+                value = None
+            # Convert understanding_score to int
+            elif key == 'understanding_score' and value:
+                try:
+                    value = int(value)
+                except ValueError:
+                    pass
+            # Handle list values for concepts
+            elif key == 'concepts' and value.startswith('['):
+                value = value.strip('[]').strip()
+                if value:
+                    value = [item.strip() for item in value.split(',')]
+                else:
+                    value = []
+
+            metadata[key] = value
+
+    return metadata
+
+
+def parse_date(date_value):
+    """Parse date from string DD-MM-YYYY format."""
+    if isinstance(date_value, str):
+        return datetime.strptime(date_value, '%d-%m-%Y').date()
+    return date_value
+
+
+def calculate_priority(tutorial, today):
+    """
+    Calculate quiz priority score. Higher = more urgent.
+
+    Priority logic:
+    1. No last_quizzed = never assessed, use created date + urgency bonus
+    2. Has last_quizzed = calculate days overdue based on score interval
+    3. Missing created date = assume max urgency (100)
+    """
+    score = tutorial.get('understanding_score') or 0  # Default to 0 if null
+    ideal_interval = INTERVALS.get(score, INTERVALS[5])
+
+    last_quizzed = tutorial.get('last_quizzed')
+
+    if not last_quizzed:
+        # Never quizzed - need baseline assessment
+        created = tutorial.get('created')
+        if created:
+            created = parse_date(created)
+            days_since_created = (today - created).days
+            # Bonus ensures never-quizzed items surface early
+            return days_since_created / ideal_interval + 10
+        # No date info at all - max urgency
+        return 100
+
+    # Normal case: has been quizzed before
+    last_quizzed = parse_date(last_quizzed)
+    days_since_quiz = (today - last_quizzed).days
+    days_overdue = days_since_quiz - ideal_interval
+
+    return days_overdue / ideal_interval
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Prioritize tutorials for quizzing based on spaced repetition"
+    )
+    parser.add_argument(
+        "--tutorials-dir",
+        help="Path to tutorials directory (defaults to ~/coding-tutor-tutorials/)",
+        default=None
+    )
+
+    args = parser.parse_args()
+
+    today = datetime.now().date()
+    tutorials = []
+
+    if args.tutorials_dir:
+        tutorials_path = Path(args.tutorials_dir)
+    else:
+        tutorials_path = get_tutorials_directory()
+
+    if not tutorials_path.exists():
+        print("No tutorials found in ~/coding-tutor-tutorials/")
+        return
+
+    for filepath in tutorials_path.glob("*.md"):
+        if filepath.name == "learner_profile.md":
+            continue
+        metadata = parse_frontmatter(filepath)
+        if metadata:
+            metadata['priority'] = calculate_priority(metadata, today)
+            tutorials.append(metadata)
+
+    if not tutorials:
+        print("No tutorials found")
+        return
+
+    # Sort by priority (highest first = most urgent)
+    tutorials.sort(key=lambda t: t['priority'], reverse=True)
+
+    print("=" * 60)
+    print("QUIZ PRIORITY (most urgent first)")
+    print("=" * 60)
+    print()
+
+    for i, t in enumerate(tutorials, 1):
+        score = t.get('understanding_score') or 0
+        last_q = t.get('last_quizzed')
+        concepts = t.get('concepts', [])
+        if isinstance(concepts, list):
+            concepts_str = ', '.join(concepts[:2])  # First 2 concepts
+        else:
+            concepts_str = str(concepts)
+
+        # Calculate days ago
+        if last_q:
+            last_q = parse_date(last_q)
+            days_ago = (today - last_q).days
+            last_quizzed_str = f"{days_ago} days ago"
+        else:
+            last_quizzed_str = "never"
+
+        print(f"{i}. {concepts_str}")
+        print(f"   understanding_score: {score}/10")
+        print(f"   last_quizzed: {last_quizzed_str}")
+        print(f"   file: {t['filepath']}")
+        print()
+
+
+if __name__ == "__main__":
+    main()

package/plugins/coding-tutor/skills/coding-tutor/scripts/setup_tutorials.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""
+Set up the central tutorials repository for coding-tutor.
+
+Usage:
+    python setup_tutorials.py
+    python setup_tutorials.py --create-github-repo
+
+Creates ~/coding-tutor-tutorials/ if it doesn't exist, initializes git,
+and optionally creates a private GitHub repository.
+"""
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+
+def get_tutorials_repo_path():
+    """Get the path for the tutorials repo (~/coding-tutor-tutorials/)."""
+    return Path.home() / "coding-tutor-tutorials"
+
+
+README_CONTENT = """# Coding Tutor - My Learning Journey
+
+This repository contains my personalized coding tutorials created with the [coding-tutor](https://github.com/nityeshaga/claude-code-essentials) Claude Code plugin.
+
+## What's Here
+
+- **Tutorials**: Markdown files with concepts learned from various codebases
+- **Learner Profile**: My background, goals, and learning preferences
+- **Quiz History**: Spaced repetition quiz results tracking my progress
+
+## How It Works
+
+Each tutorial includes:
+- `source_repo`: Which codebase the examples come from
+- `concepts`: What concepts are covered
+- `understanding_score`: How well I've retained this (1-10, updated via quizzes)
+- Real code examples from actual projects I'm learning from
+
+This is my personal learning trail - tutorials are written specifically for me, using my vocabulary and building on my existing knowledge.
+"""
+
+
+def setup_tutorials_repo(create_github=False):
+    """
+    Set up the central tutorials repository.
+
+    Returns:
+        tuple: (success: bool, message: str)
+    """
+    repo_path = get_tutorials_repo_path()
+
+    if repo_path.exists():
+        return True, f"Tutorials repo already exists at {repo_path.resolve()}"
+
+    try:
+        # Create directory
+        repo_path.mkdir(parents=True)
+
+        # Initialize git
+        subprocess.run(['git', 'init'], cwd=repo_path, check=True, capture_output=True)
+
+        # Create README
+        readme_path = repo_path / "README.md"
+        readme_path.write_text(README_CONTENT)
+
+        # Create .gitignore
+        gitignore_path = repo_path / ".gitignore"
+        gitignore_path.write_text(".DS_Store\n*.swp\n*.swo\n")
+
+        # Initial commit
+        subprocess.run(['git', 'add', '-A'], cwd=repo_path, check=True, capture_output=True)
+        subprocess.run(
+            ['git', 'commit', '-m', 'Initial commit: coding learning journey'],
+            cwd=repo_path, check=True, capture_output=True
+        )
+
+        message = f"Created tutorials repo at {repo_path.resolve()}"
+
+        # Optionally create GitHub repo
+        if create_github:
+            result = subprocess.run(
+                ['gh', 'repo', 'create', 'coding-tutor-tutorials', '--private', '--source=.', '--push'],
+                cwd=repo_path, capture_output=True, text=True
+            )
+            if result.returncode == 0:
+                message += "\nCreated private GitHub repo and pushed"
+            else:
+                message += f"\nNote: Could not create GitHub repo: {result.stderr}"
+
+        return True, message
+
+    except Exception as e:
+        return False, f"Error setting up tutorials repo: {e}"
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Set up the central tutorials repository for coding-tutor"
+    )
+    parser.add_argument(
+        "--create-github-repo",
+        action="store_true",
+        help="Also create a private GitHub repository"
+    )
+
+    args = parser.parse_args()
+
+    success, message = setup_tutorials_repo(create_github=args.create_github_repo)
+    print(message)
+
+    return 0 if success else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/plugins/compound-engineering/.claude-plugin/plugin.json

@@ -0,0 +1,33 @@
+{
+  "name": "compound-engineering",
+  "version": "2.31.1",
+  "description": "AI-powered development tools. 29 agents, 24 commands, 18 skills, 1 MCP server for code review, research, design, and workflow automation.",
+  "author": {
+    "name": "Kieran Klaassen",
+    "email": "kieran@every.to",
+    "url": "https://github.com/kieranklaassen"
+  },
+  "homepage": "https://every.to/source-code/my-ai-had-already-fixed-the-code-before-i-saw-it",
+  "repository": "https://github.com/EveryInc/compound-engineering-plugin",
+  "license": "MIT",
+  "keywords": [
+    "ai-powered",
+    "compound-engineering",
+    "workflow-automation",
+    "code-review",
+    "rails",
+    "ruby",
+    "python",
+    "typescript",
+    "knowledge-management",
+    "image-generation",
+    "agent-browser",
+    "browser-automation"
+  ],
+  "mcpServers": {
+    "context7": {
+      "type": "http",
+      "url": "https://mcp.context7.com/mcp"
+    }
+  }
+}