ag-cortex 0.1.0

package/.agent/skills/coding-tutor/commands/sync-tutorials.md

@@ -0,0 +1,25 @@
+# Sync Coding Tutor Tutorials
+
+Commit and push your tutorials to the GitHub repository for backup and mobile reading.
+
+## Instructions
+
+1. **Go to the tutorials repo**: `cd ~/coding-tutor-tutorials`
+
+2. **Check for changes**: Run `git status` to see what's new or modified
+
+3. **If there are changes**:
+   - Stage all changes: `git add -A`
+   - Create a commit with a message summarizing what was added/updated (e.g., "Add tutorial on React hooks" or "Update quiz scores")
+   - Push to origin: `git push`
+
+4. **If no GitHub remote exists**:
+   - Create the repo: `gh repo create coding-tutor-tutorials --private --source=. --push`
+
+5. **Report results**: Tell the user what was synced or that everything is already up to date
+
+## Notes
+
+- The tutorials repo is at: `~/coding-tutor-tutorials/`
+- Always use `--private` when creating the GitHub repo
+- This is your personal learning journey - keep it backed up!

package/.agent/skills/coding-tutor/commands/teach-me.md

@@ -0,0 +1 @@
+Teach me something using the coding-tutor skill

package/.agent/skills/coding-tutor/skills/coding-tutor/SKILL.md

@@ -0,0 +1,214 @@
+---
+name: coding-tutor
+description: Personalized coding tutorials that build on your existing knowledge and use your actual codebase for examples. Creates a persistent learning trail that compounds over time using the power of AI, spaced repetition and quizes.
+---
+
+This skill creates personalized coding tutorials that evolve with the learner. Each tutorial builds on previous ones, uses real examples from the current codebase, and maintains a persistent record of concepts mastered.
+
+The user asks to learn something - either a specific concept or an open "teach me something new" request.
+
+## Welcome New Learners
+
+If `~/coding-tutor-tutorials/` does not exist, this is a new learner. Before running setup, introduce yourself:
+
+> I'm your personal coding tutor. I create tutorials tailored to you - using real code from your projects, building on what you already know, and tracking your progress over time.
+>
+> All your tutorials live in one central library (`~/coding-tutor-tutorials/`) that works across all your projects. Use `/teach-me` to learn something new, `/quiz-me` to test your retention with spaced repetition.
+
+Then proceed with setup and onboarding.
+
+## Setup: Ensure Tutorials Repo Exists
+
+**Before doing anything else**, run the setup script to ensure the central tutorials repository exists:
+
+```bash
+python3 ${ANTIGRAVITY_PLUGIN_ROOT}/skills/coding-tutor/scripts/setup_tutorials.py
+```
+
+This creates `~/coding-tutor-tutorials/` if it doesn't exist. All tutorials and the learner profile are stored there, shared across all your projects.
+
+## First Step: Know Your Learner
+
+**Always start by reading `~/coding-tutor-tutorials/learner_profile.md` if it exists.** This profile contains crucial context about who you're teaching - their background, goals, and personality. Use it to calibrate everything: what analogies will land, how fast to move, what examples resonate.
+
+If no tutorials exist in `~/coding-tutor-tutorials/` AND no learner profile exists at `~/coding-tutor-tutorials/learner_profile.md`, this is a brand new learner. Before teaching anything, you need to understand who you're teaching.
+
+**Onboarding Interview:**
+
+Ask these three questions, one at a time. Wait for each answer before asking the next.
+
+1. **Prior exposure**: What's your background with programming? - Understand if they've built anything before, followed tutorials, or if this is completely new territory.
+
+2. **Ambitious goal**: This is your private AI tutor whose goal is to make you a top 1% programmer. Where do you want this to take you? - Understand what success looks like for them: a million-dollar product, a job at a company they admire, or something else entirely.
+
+3. **Who are you**: Tell me a bit about yourself - imagine we just met at a coworking space. - Get context that shapes how to teach them.
+
+4. **Optional**: Based on the above answers, you may ask upto one optional 4th question if it will make your understanding of the learner richer.
+
+After gathering responses, create `~/coding-tutor-tutorials/learner_profile.md` and put the interview Q&A there (along with your commentary):
+
+```yaml
+---
+created: DD-MM-YYYY
+last_updated: DD-MM-YYYY
+---
+
+**Q1. <insert question you asked>**
+**Answer**. <insert user's answer>
+**your internal commentary**
+
+**Q2. <insert question you asked>**
+**Answer**. <insert user's answer>
+**your internal commentary**
+
+**Q3. <insert question you asked>**
+**Answer**. <insert user's answer>
+**your internal commentary**
+
+**Q4. <optional>
+```
+
+## Teaching Philosophy
+
+Our general goal is to take the user from newbie to a senior engineer in record time. One at par with engineers at companies like 37 Signals or Vercel.
+
+Before creating a tutorial, make a plan by following these steps:
+
+- **Load learner context**: Read `~/coding-tutor-tutorials/learner_profile.md` to understand who you're teaching - their background, goals, and personality.
+- **Survey existing knowledge**: Run `python3 ${ANTIGRAVITY_PLUGIN_ROOT}/skills/coding-tutor/scripts/index_tutorials.py` to understand what concepts have been covered, at what depth, and how well they landed (understanding scores). Optionally, dive into particular tutorials in `~/coding-tutor-tutorials/` to read them.
+- **Identify the gap**: What's the next concept that would be most valuable? Consider both what they've asked for AND what naturally follows from their current knowledge. Think of a curriculum that would get them from their current point to Senior Engineer - what should be the next 3 topics they need to learn to advance their programming knowledge in this direction?
+- **Find the anchor**: Locate real examples in the codebase that demonstrate this concept. Learning from abstract examples is forgettable; learning from YOUR code is sticky.
+- **(Optional) Use ask-user-question tool**: Ask clarifying questions to the learner to understand their intent, goals or expectations if it'll help you make a better plan.
+
+Then show this curriculum plan of **next 3 TUTORIALS** to the user and proceed to the tutorial creation step only if the user approves. If the user rejects, create a new plan using steps mentioned above.
+
+## Tutorial Creation
+
+Each tutorial is a markdown file in `~/coding-tutor-tutorials/` with this structure:
+```yaml
+---
+concepts: [primary_concept, related_concept_1, related_concept_2]
+source_repo: my-app  # Auto-detected: which repo this tutorial's examples come from
+description: One-paragraph summary of what this tutorial covers
+understanding_score: null  # null until quizzed, then 1-10 based on quiz performance
+last_quizzed: null  # null until first quiz, then DD-MM-YYYY
+prerequisites: [~/coding-tutor-tutorials/tutorial_1_name.md, ~/coding-tutor-tutorials/tutorial_2_name.md, (upto 3 other existing tutorials)]
+created: DD-MM-YYYY
+last_updated: DD-MM-YYYY
+---
+
+Full contents of tutorial go here
+
+---
+
+## Q&A
+
+Cross-questions during learning go here.
+
+## Quiz History
+
+Quiz sessions recorded here.
+```
+
+Run `scripts/create_tutorial.py` like this to create a new tutorial with template:
+
+```bash
+python3 ${ANTIGRAVITY_PLUGIN_ROOT}/skills/coding-tutor/scripts/create_tutorial.py "Topic Name" --concepts "Concept1,Concept2"
+```
+
+This creates an empty template of the tutorial. Then you should edit the newly created file to write in the actual tutorial.
+Qualities of a great tutorial should:
+
+- **Start with the "why"**: Not "here's how callbacks work" but "here's the problem in your code that callbacks solve"
+- **Use their code**: Every concept demonstrated with examples pulled from the actual codebase. Reference specific files and line numbers.
+- **Build mental models**: Diagrams, analogies, the underlying "shape" of the concept - not just syntax, ELI5
+- **Predict confusion**: Address the questions they're likely to ask before they ask them, don't skim over things, don't write in a notes style
+- **End with a challenge**: A small exercise they could try in this codebase to cement understanding
+
+### Tutorial Writing Style
+
+Write personal tutorials like the best programming educators: Julia Evans, Dan Abramov. Not like study notes or documentation. There's a difference between a well-structured tutorial and one that truly teaches.
+
+- Show the struggle - "Here's what you might try... here's why it doesn't work... here's the insight that unlocks it."
+- Fewer concepts, more depth - A tutorial that teaches 3 things deeply beats one that mentions 10 things.
+- Tell stories - a great tutorial is one coherent story, dives deep into a single concept, using storytelling techniques that engage readers
+
+We should make the learner feel like Julia Evans or Dan Abramov is their private tutor.
+
+Note: If you're not sure about a fact or capability or new features/APIs, do web research, look at documentation to make sure you're teaching accurate up-to-date things. NEVER commit the sin of teaching something incorrect.
+
+## The Living Tutorial
+
+Tutorials aren't static documents - they evolve:
+
+- **Q&A is mandatory**: When the learner asks ANY clarifying question about a tutorial, you MUST append it to the tutorial's `## Q&A` section. This is not optional - these exchanges are part of their personalized learning record and improve future teaching.
+- If the learner says they can't follow the tutorial or need you to take a different approach, update the tutorial like they ask
+- Update `last_updated` timestamp
+- If a question reveals a gap in prerequisites, note it for future tutorial planning
+
+Note: `understanding_score` is only updated through Quiz Mode, not during teaching.
+
+## What Makes Great Teaching
+**DO**: Meet them where they are. Use their vocabulary. Reference their past struggles. Make connections to concepts they already own. Be encouraging but honest about complexity.
+
+**DON'T**: Assume knowledge not demonstrated in previous tutorials. Use generic blog-post examples when codebase examples exist. Overwhelm with every edge case upfront. Be condescending about gaps.
+
+**CALIBRATE**: A learner with 3 tutorials is different from one with 30. Early tutorials need more scaffolding and encouragement. Later tutorials can move faster and reference the shared history you've built.
+
+Remember: The goal isn't to teach programming in the abstract. It's to teach THIS person, using THEIR code, building on THEIR specific journey. Every tutorial should feel like it was written specifically for them - because it was.
+
+## Quiz Mode
+
+Tutorials teach. Quizzes verify. The score should reflect what the learner actually retained, not what was presented to them.
+
+**Triggers:**
+- Explicit: "Quiz me on React hooks" → quiz that specific concept
+- Open: "Quiz me on something" → run `python3 ${ANTIGRAVITY_PLUGIN_ROOT}/skills/coding-tutor/scripts/quiz_priority.py` to get a prioritized list based on spaced repetition, then choose what to quiz
+
+**Spaced Repetition:**
+
+When the user requests an open quiz, the priority script uses spaced repetition intervals to surface:
+- Never-quizzed tutorials (need baseline assessment)
+- Low-scored concepts that are overdue for review
+- High-scored concepts whose review interval has elapsed
+
+The script uses Fibonacci-ish intervals: score 1 = review in 2 days, score 5 = 13 days, score 8 = 55 days, score 10 = 144 days. This means weak concepts get drilled frequently while mastered ones fade into long-term review.
+
+The script gives you an ordered list with `understanding_score` and `last_quizzed` for each tutorial. Use this to make an informed choice about what to quiz, and explain to the learner why you picked that concept ("You learned callbacks 5 days ago but scored 4/10 - let's see if it's sticking better now").
+
+**Philosophy:**
+
+A quiz isn't an exam - it's a conversation that reveals understanding. Ask questions that expose mental models, not just syntax recall. The goal is to find the edges of their knowledge: where does solid understanding fade into uncertainty?
+
+**Ask only 1 question at a time.** Wait for the learner's answer before asking the next question.
+
+Mix question types based on what the concept demands:
+- Conceptual ("when would you use X over Y?")
+- Code reading ("what does this code in your app do?")
+- Code writing ("write a scope that does X")
+- Debugging ("what's wrong here?")
+
+Use their codebase for examples whenever possible. "What does line 47 of `app/models/user.rb` do?" is more valuable than abstract snippets.
+
+**Scoring:**
+
+After the quiz, update `understanding_score` honestly:
+- **1-3**: Can't recall the concept, needs re-teaching
+- **4-5**: Vague memory, partial answers
+- **6-7**: Solid understanding, minor gaps
+- **8-9**: Strong grasp, handles edge cases
+- **10**: Could teach this to someone else
+
+Also update `last_quizzed: DD-MM-YYYY` in the frontmatter.
+
+**Recording:**
+
+Append to the tutorial's `## Quiz History` section:
+```
+### Quiz - DD-MM-YYYY
+**Q:** [Question asked]
+**A:** [Brief summary of their response and what it revealed about understanding]
+Score updated: 5 → 7
+```
+
+This history helps future quizzes avoid repetition and track progression over time.

package/.agent/skills/coding-tutor/skills/coding-tutor/scripts/create_tutorial.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""
+Create a new coding tutorial template with proper frontmatter.
+
+Usage:
+    python create_tutorial.py "React Hooks"
+    python create_tutorial.py "State Management" --concepts "Redux,Context,State"
+"""
+
+import argparse
+import subprocess
+import sys
+from datetime import datetime
+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"
+
+
+def get_repo_name():
+    """Get the current git repository name."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"], capture_output=True, text=True
+        )
+        if result.returncode == 0:
+            return result.stdout.strip().split("/")[-1]
+    except Exception:
+        pass
+    return "unknown"
+
+
+def check_uncommitted_changes():
+    """Check for uncommitted changes and print a warning if any exist."""
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"], capture_output=True, text=True
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            lines = result.stdout.strip().split("\n")
+            print(
+                f"WARNING: You have {len(lines)} uncommitted change(s). Commit and push before proceeding."
+            )
+            print(result.stdout)
+    except Exception:
+        pass
+
+
+def slugify(text):
+    """Convert text to URL-friendly slug."""
+    return text.lower().replace(" ", "-").replace("_", "-")
+
+
+def create_tutorial(topic, concepts=None, output_dir=None):
+    """
+    Create a new tutorial template file.
+
+    Args:
+        topic: Main topic of the tutorial
+        concepts: Comma-separated concepts (defaults to topic)
+        output_dir: Directory to save tutorial (defaults to ~/coding-tutor-tutorials/)
+
+    Returns:
+        Path to created tutorial file
+    """
+    # Default output directory is the central tutorials repo (sibling to git root)
+    if output_dir is None:
+        output_dir = get_tutorials_repo_path()
+    else:
+        output_dir = Path(output_dir)
+
+    # Create output directory if it doesn't exist
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Generate filename: YYYY-MM-DD-topic-slug.md
+    date_str_filename = datetime.now().strftime("%Y-%m-%d")
+    date_str_frontmatter = datetime.now().strftime("%d-%m-%Y")
+    slug = slugify(topic)
+    filename = f"{date_str_filename}-{slug}.md"
+    filepath = output_dir / filename
+
+    # Default concepts to topic if not provided
+    if concepts is None:
+        concepts = topic
+
+    # Get current repo name
+    repo_name = get_repo_name()
+
+    # Create tutorial template with YAML frontmatter and embedded guidance
+    template = f"""---
+concepts: {concepts}
+source_repo: {repo_name}
+description: [TODO: Fill after completing tutorial - one paragraph summary]
+understanding_score: null
+last_quizzed: null
+prerequisites: []
+created: {date_str_frontmatter}
+last_updated: {date_str_frontmatter}
+---
+
+# {topic}
+
+[TODO: Opening paragraph - Start with the WHY. What problem does this concept solve? Why should the learner care about this? Connect it to their goal of becoming a senior engineer.
+
+NOTE: Update the frontmatter 'prerequisites' field with up to 3 relevant past tutorials if this builds on previous concepts (e.g., [coding-tutor-tutorials/2025-11-20-basics.md]). Leave as empty array [] if this is foundational.]
+
+## The Problem
+
+[TODO: Describe a real scenario from this codebase where this concept matters. Make it concrete - not "X is useful for Y" but "look at this code in src/components/User.tsx where we need to do Y - that's the problem this concept solves"]
+
+## Key Concepts
+
+[TODO: Build mental models, not just definitions. Use:
+- Analogies that connect to things they already understand
+- ASCII diagrams if helpful for visualizing relationships
+- ELI5 explanations that get to the essence
+- Break complex concepts into digestible pieces
+- Predict and address likely points of confusion
+
+Remember: Teach the "shape" of the concept, not just the syntax.]
+
+## Examples from Codebase
+
+[TODO: Include 2-4 real examples from this repository. For each example:
+
+### Example 1: [Brief description]
+**Location:** src/components/User.tsx:25-30
+
+```
+# Paste the relevant code snippet here
+```
+
+**What this demonstrates:** [Explain what's happening and why this is a good example of the concept]
+
+Repeat for each example. Use actual file paths and line numbers. The more specific, the stickier the learning.]
+
+## Try It Yourself
+
+[TODO: Suggest a small exercise the learner could try in this codebase to practice the concept. Make it:
+- Achievable in 10-15 minutes
+- Directly related to the codebase they're working in
+- Something that would genuinely improve their understanding
+
+Delete this section if no practical exercise makes sense for this concept.]
+
+## Summary
+
+[TODO: Key takeaways - what should stick in their mind after this tutorial? 3-5 bullet points capturing:
+- The core concept in one sentence
+- When to use it
+- Common pitfalls to avoid
+- How it connects to their broader learning journey]
+
+---
+
+## Q&A
+
+[Questions and answers will be added here as the learner asks them during the tutorial]
+
+## Quiz History
+
+[Quiz sessions will be recorded here after the learner is quizzed on this topic]
+"""
+
+    # Write template to file
+    filepath.write_text(template)
+
+    return filepath
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Create a new coding tutorial template"
+    )
+    parser.add_argument("topic", help="Topic of the tutorial (e.g., 'React Hooks')")
+    parser.add_argument(
+        "--concepts", help="Comma-separated concepts (defaults to topic)", default=None
+    )
+    parser.add_argument(
+        "--output-dir",
+        help="Output directory for tutorial (defaults to ~/coding-tutor-tutorials/)",
+        default=None,
+    )
+
+    args = parser.parse_args()
+
+    check_uncommitted_changes()
+
+    try:
+        filepath = create_tutorial(args.topic, args.concepts, args.output_dir)
+        print(f"Created tutorial template: {filepath}")
+        print("Edit the file to add content and update the frontmatter")
+        return 0
+    except Exception as e:
+        print(f"Error creating tutorial: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/.agent/skills/coding-tutor/skills/coding-tutor/scripts/index_tutorials.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""
+Index all tutorials by extracting their YAML frontmatter.
+
+Usage:
+    python index_tutorials.py
+    python index_tutorials.py --tutorials-dir /path/to/tutorials
+    python index_tutorials.py --format json
+    python index_tutorials.py --format human
+"""
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+
+def get_tutorials_directory():
+    """Get the tutorials directory (~/coding-tutor-tutorials/)."""
+    return Path.home() / "coding-tutor-tutorials"
+
+
+def extract_frontmatter(filepath):
+    """
+    Extract YAML frontmatter from a markdown file.
+
+    Args:
+        filepath: Path to markdown file
+
+    Returns:
+        dict with frontmatter fields or None if no frontmatter found
+    """
+    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)
+    frontmatter = {}
+
+    # 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()
+
+            # Convert understanding_score to int, or None if "null"
+            if key == "understanding_score":
+                if value == "null" or not value:
+                    value = None
+                else:
+                    try:
+                        value = int(value)
+                    except ValueError:
+                        pass
+
+            # Handle null values for last_quizzed
+            if key == "last_quizzed" and value == "null":
+                value = None
+
+            # Handle list/array values for prerequisites
+            if key == "prerequisites" and value.startswith("["):
+                # Simple list parsing - extract items between brackets
+                value = value.strip("[]").strip()
+                if value:
+                    frontmatter[key] = [item.strip() for item in value.split(",")]
+                else:
+                    frontmatter[key] = []
+            else:
+                frontmatter[key] = value
+
+    return frontmatter
+
+
+def index_tutorials(tutorials_dir=None):
+    """
+    Index all tutorials from the tutorials directory.
+
+    Args:
+        tutorials_dir: Path to tutorials directory (defaults to ~/coding-tutor-tutorials/)
+
+    Returns:
+        list of dicts with tutorial metadata
+    """
+    tutorials = []
+
+    if tutorials_dir is not None:
+        tutorials_path = Path(tutorials_dir)
+    else:
+        tutorials_path = get_tutorials_directory()
+
+    if not tutorials_path.exists():
+        return tutorials
+
+    # Find all .md files in tutorials directory
+    for filepath in sorted(tutorials_path.glob("*.md")):
+        frontmatter = extract_frontmatter(filepath)
+
+        if frontmatter:
+            tutorials.append(
+                {
+                    "filename": filepath.name,
+                    "filepath": str(filepath),
+                    "concepts": frontmatter.get("concepts", ""),
+                    "source_repo": frontmatter.get("source_repo", ""),
+                    "description": frontmatter.get("description", ""),
+                    "understanding_score": frontmatter.get("understanding_score"),
+                    "last_quizzed": frontmatter.get("last_quizzed"),
+                    "prerequisites": frontmatter.get("prerequisites", []),
+                    "created": frontmatter.get("created", ""),
+                    "last_updated": frontmatter.get("last_updated", ""),
+                }
+            )
+
+    return tutorials
+
+
+def format_human_readable(tutorials):
+    """Format tutorials as human-readable text."""
+    if not tutorials:
+        return "No tutorials found. Check if ~/coding-tutor-tutorials/learner_profile.md exists - if not, onboard the learner first. If it exists, create their first tutorial using their profile context."
+
+    output = []
+    output.append(f"Found {len(tutorials)} tutorial(s):\n")
+
+    for tutorial in tutorials:
+        output.append(f"  {tutorial['filename']}")
+        output.append(f"   Concepts: {tutorial['concepts']}")
+        if tutorial.get("source_repo"):
+            output.append(f"   Source repo: {tutorial['source_repo']}")
+        if tutorial["description"]:
+            output.append(f"   Description: {tutorial['description']}")
+        score = tutorial["understanding_score"]
+        if score is None:
+            output.append("   Understanding: not quizzed yet")
+        else:
+            output.append(f"   Understanding: {score}/10")
+        if tutorial.get("last_quizzed"):
+            output.append(f"   Last quizzed: {tutorial['last_quizzed']}")
+        if tutorial.get("created"):
+            output.append(f"   Created: {tutorial['created']}")
+        if tutorial.get("prerequisites") and tutorial["prerequisites"]:
+            prereqs = (
+                ", ".join(tutorial["prerequisites"])
+                if isinstance(tutorial["prerequisites"], list)
+                else tutorial["prerequisites"]
+            )
+            output.append(f"   Prerequisites: {prereqs}")
+        output.append("")
+
+    return "\n".join(output)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Index all tutorials by extracting frontmatter"
+    )
+    parser.add_argument(
+        "--tutorials-dir",
+        help="Path to tutorials directory (defaults to ~/coding-tutor-tutorials/)",
+        default=None,
+    )
+    parser.add_argument(
+        "--format",
+        choices=["json", "human"],
+        default="json",
+        help="Output format (default: json)",
+    )
+
+    args = parser.parse_args()
+
+    try:
+        tutorials = index_tutorials(args.tutorials_dir)
+
+        if args.format == "json":
+            if not tutorials:
+                print(
+                    json.dumps(
+                        {
+                            "tutorials": [],
+                            "message": "No tutorials found. Check if ~/coding-tutor-tutorials/learner_profile.md exists - if not, onboard the learner first. If it exists, create their first tutorial using their profile context.",
+                        },
+                        indent=2,
+                    )
+                )
+            else:
+                print(json.dumps({"tutorials": tutorials}, indent=2))
+        else:
+            print(format_human_readable(tutorials))
+
+        return 0
+    except Exception as e:
+        print(f"Error indexing tutorials: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())