@opslane/claude-code-game 0.1.0

package/levels/11-worktrees/exercise/database.py

@@ -0,0 +1,171 @@
+"""SQLite database operations for expense storage."""
+
+import sqlite3
+import os
+from pathlib import Path
+from datetime import datetime
+from typing import Optional, TYPE_CHECKING
+from contextlib import contextmanager
+
+if TYPE_CHECKING:
+    from models import Expense
+
+# Database path - use environment variable for testing, otherwise default location
+DB_PATH = Path(os.environ.get(
+    "EXPENSE_DB_PATH",
+    Path(__file__).parent / "data" / "expenses.db"
+))
+
+
+@contextmanager
+def get_connection():
+    """Get a database connection with proper cleanup.
+
+    Yields:
+        sqlite3.Connection with Row factory enabled
+
+    Example:
+        with get_connection() as conn:
+            conn.execute("SELECT * FROM expenses")
+    """
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    try:
+        yield conn
+        conn.commit()
+    finally:
+        conn.close()
+
+
+def init_db() -> None:
+    """Initialize the database schema.
+
+    Creates the expenses table if it doesn't exist.
+    Also creates the data directory if needed.
+    """
+    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+    with get_connection() as conn:
+        conn.execute('''
+            CREATE TABLE IF NOT EXISTS expenses (
+                id TEXT PRIMARY KEY,
+                amount REAL NOT NULL,
+                category TEXT NOT NULL,
+                description TEXT,
+                date TEXT NOT NULL,
+                recurring INTEGER DEFAULT 0,
+                recurring_frequency TEXT
+            )
+        ''')
+
+
+def save_expense(expense: "Expense") -> None:
+    """Save an expense to the database.
+
+    Args:
+        expense: The Expense object to save
+    """
+    with get_connection() as conn:
+        conn.execute('''
+            INSERT INTO expenses (id, amount, category, description, date, recurring, recurring_frequency)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        ''', (
+            expense.id,
+            expense.amount,
+            expense.category,
+            expense.description,
+            expense.date.isoformat(),
+            1 if expense.recurring else 0,
+            expense.recurring_frequency
+        ))
+
+
+def load_expenses() -> list["Expense"]:
+    """Load all expenses from the database.
+
+    Returns:
+        List of all Expense objects, ordered by date descending
+    """
+    from models import Expense  # Import here to avoid circular import
+
+    with get_connection() as conn:
+        rows = conn.execute('SELECT * FROM expenses ORDER BY date DESC').fetchall()
+
+    expenses = []
+    for row in rows:
+        expenses.append(Expense(
+            id=row['id'],
+            amount=row['amount'],
+            category=row['category'],
+            description=row['description'],
+            date=datetime.fromisoformat(row['date']),
+            recurring=bool(row['recurring']),
+            recurring_frequency=row['recurring_frequency']
+        ))
+
+    return expenses
+
+
+def get_expense_by_id(expense_id: str) -> Optional["Expense"]:
+    """Get a single expense by ID.
+
+    Args:
+        expense_id: The unique expense ID
+
+    Returns:
+        The Expense if found, None otherwise
+    """
+    from models import Expense  # Import here to avoid circular import
+
+    with get_connection() as conn:
+        row = conn.execute(
+            'SELECT * FROM expenses WHERE id = ?',
+            (expense_id,)
+        ).fetchone()
+
+    if not row:
+        return None
+
+    return Expense(
+        id=row['id'],
+        amount=row['amount'],
+        category=row['category'],
+        description=row['description'],
+        date=datetime.fromisoformat(row['date']),
+        recurring=bool(row['recurring']),
+        recurring_frequency=row['recurring_frequency']
+    )
+
+
+def remove_expense(expense_id: str) -> bool:
+    """Remove an expense from the database.
+
+    Args:
+        expense_id: The unique expense ID
+
+    Returns:
+        True if an expense was deleted, False if not found
+    """
+    with get_connection() as conn:
+        cursor = conn.execute('DELETE FROM expenses WHERE id = ?', (expense_id,))
+        return cursor.rowcount > 0
+
+
+def clear_all_expenses() -> None:
+    """Clear all expenses from the database.
+
+    WARNING: This deletes all data! Use only for testing.
+    """
+    with get_connection() as conn:
+        conn.execute('DELETE FROM expenses')
+
+
+def get_expense_count() -> int:
+    """Get the total number of expenses.
+
+    Returns:
+        Count of expenses in database
+    """
+    with get_connection() as conn:
+        row = conn.execute('SELECT COUNT(*) as count FROM expenses').fetchone()
+        return row['count']

package/levels/11-worktrees/exercise/main.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""Expense Tracker CLI - Track your daily expenses."""
+
+import argparse
+from datetime import datetime
+from models import add_expense, list_expenses, delete_expense, get_expense
+from utils import format_currency, parse_date
+from database import init_db
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Track your expenses")
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+
+    # Add expense
+    add_parser = subparsers.add_parser("add", help="Add a new expense")
+    add_parser.add_argument("amount", type=float, help="Amount spent")
+    add_parser.add_argument("category", help="Category (Food, Transport, etc.)")
+    add_parser.add_argument("description", help="What was the expense for?")
+    add_parser.add_argument("--date", help="Date (YYYY-MM-DD), defaults to today")
+
+    # List expenses
+    list_parser = subparsers.add_parser("list", help="List expenses")
+    list_parser.add_argument("--category", help="Filter by category")
+    list_parser.add_argument("--month", help="Filter by month (YYYY-MM)")
+    list_parser.add_argument("--limit", type=int, default=10, help="Max results")
+
+    # Delete expense
+    delete_parser = subparsers.add_parser("delete", help="Delete an expense")
+    delete_parser.add_argument("id", help="Expense ID to delete")
+
+    # Show single expense
+    show_parser = subparsers.add_parser("show", help="Show expense details")
+    show_parser.add_argument("id", help="Expense ID")
+
+    # Summary
+    subparsers.add_parser("summary", help="Show spending summary")
+
+    args = parser.parse_args()
+
+    # Initialize database
+    init_db()
+
+    if args.command == "add":
+        date = parse_date(args.date) if args.date else datetime.now()
+        expense = add_expense(args.amount, args.category, args.description, date)
+        print(f"Added expense: {expense.id} - {format_currency(expense.amount)}")
+
+    elif args.command == "list":
+        expenses = list_expenses(
+            category=args.category,
+            month=args.month,
+            limit=args.limit
+        )
+        if not expenses:
+            print("No expenses found.")
+        for exp in expenses:
+            print(f"{exp.id} | {exp.date.strftime('%Y-%m-%d')} | "
+                  f"{exp.category:12} | {format_currency(exp.amount):>10} | {exp.description}")
+
+    elif args.command == "delete":
+        if delete_expense(args.id):
+            print(f"Deleted expense {args.id}")
+        else:
+            print(f"Expense {args.id} not found")
+
+    elif args.command == "show":
+        expense = get_expense(args.id)
+        if expense:
+            print(f"ID:          {expense.id}")
+            print(f"Amount:      {format_currency(expense.amount)}")
+            print(f"Category:    {expense.category}")
+            print(f"Description: {expense.description}")
+            print(f"Date:        {expense.date.strftime('%Y-%m-%d %H:%M')}")
+        else:
+            print(f"Expense {args.id} not found")
+
+    elif args.command == "summary":
+        expenses = list_expenses()
+        total = sum(e.amount for e in expenses)
+        print(f"Total expenses: {format_currency(total)}")
+
+        # Group by category
+        categories: dict[str, float] = {}
+        for exp in expenses:
+            categories[exp.category] = categories.get(exp.category, 0) + exp.amount
+
+        print("\nBy category:")
+        for cat, amount in sorted(categories.items(), key=lambda x: x[1], reverse=True):
+            print(f"  {cat:15} {format_currency(amount):>10}")
+
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

package/levels/11-worktrees/exercise/models.py

@@ -0,0 +1,116 @@
+"""Expense data models and core operations."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+import uuid
+from database import save_expense, load_expenses, remove_expense, get_expense_by_id
+
+
+@dataclass
+class Expense:
+    """Represents a single expense entry."""
+    id: str
+    amount: float
+    category: str
+    description: str
+    date: datetime
+    recurring: bool = False
+    recurring_frequency: Optional[str] = None  # 'daily', 'weekly', 'monthly'
+
+
+def generate_id() -> str:
+    """Generate a unique expense ID."""
+    return str(uuid.uuid4())[:8]
+
+
+def add_expense(
+    amount: float,
+    category: str,
+    description: str,
+    date: Optional[datetime] = None
+) -> Expense:
+    """Add a new expense with validation."""
+    if amount <= 0:
+        raise ValueError("Amount must be greater than 0")
+
+    if not category or not category.strip():
+        raise ValueError("Category cannot be empty")
+
+    expense = Expense(
+        id=generate_id(),
+        amount=amount,
+        category=category.strip(),
+        description=description,
+        date=date or datetime.now()
+    )
+    save_expense(expense)
+    return expense
+
+
+def list_expenses(
+    category: Optional[str] = None,
+    month: Optional[str] = None,
+    limit: int = 100
+) -> list[Expense]:
+    """List expenses with optional filters."""
+    expenses = load_expenses()
+
+    if category:
+        category_lower = category.lower()
+        expenses = [e for e in expenses if e.category.lower() == category_lower]
+
+    if month:
+        expenses = [e for e in expenses if e.date.strftime('%Y-%m') == month]
+
+    expenses.sort(key=lambda x: x.date, reverse=True)
+    return expenses[:limit]
+
+
+def get_expense(expense_id: str) -> Optional[Expense]:
+    """Get a single expense by ID.
+
+    Args:
+        expense_id: The unique expense ID
+
+    Returns:
+        The Expense if found, None otherwise
+    """
+    return get_expense_by_id(expense_id)
+
+
+def delete_expense(expense_id: str) -> bool:
+    """Delete an expense by ID.
+
+    Args:
+        expense_id: The unique expense ID
+
+    Returns:
+        True if deleted, False if not found
+    """
+    return remove_expense(expense_id)
+
+
+def get_total_by_category(category: str) -> float:
+    """Get total spent in a category.
+
+    Args:
+        category: The category name
+
+    Returns:
+        Total amount spent in that category
+
+    Note: Also case-sensitive - shares bug with list_expenses.
+    """
+    expenses = list_expenses(category=category)
+    return sum(e.amount for e in expenses)
+
+
+def get_categories() -> list[str]:
+    """Get all unique categories from expenses.
+
+    Returns:
+        List of category names
+    """
+    expenses = load_expenses()
+    return list(set(e.category for e in expenses))

package/levels/11-worktrees/exercise/pyproject.toml

@@ -0,0 +1,52 @@
+[project]
+name = "expense-tracker"
+version = "0.1.0"
+description = "A simple CLI expense tracker for the Claude Code course"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+
+# No runtime dependencies - uses only stdlib
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "ruff>=0.1.0",
+]
+
+[project.scripts]
+expense = "main:main"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+addopts = "-v --tb=short"
+filterwarnings = [
+    "ignore::DeprecationWarning",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = [
+    "E",      # pycodestyle errors
+    "F",      # pyflakes
+    "I",      # isort
+    "N",      # pep8-naming
+    "W",      # pycodestyle warnings
+    "UP",     # pyupgrade
+]
+ignore = [
+    "E501",   # Line too long (handled by formatter)
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["models", "database", "utils", "reports"]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"

package/levels/11-worktrees/exercise/reports.py

@@ -0,0 +1,63 @@
+"""Report generation for expense tracker."""
+
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from models import Expense
+
+
+def generate_monthly_report(month: Optional[str] = None) -> str:
+    """Generate a monthly expense report."""
+    from models import list_expenses
+    from utils import format_currency
+
+    if month is None:
+        month = datetime.now().strftime("%Y-%m")
+
+    expenses = list_expenses(month=month)
+
+    if not expenses:
+        return f"# Expense Report: {month}\n\nNo expenses found."
+
+    total = sum(e.amount for e in expenses)
+    breakdown = get_category_breakdown(expenses)
+    top = get_top_expenses(expenses, 5)
+
+    report = f"# Expense Report: {month}\n\n"
+    report += f"## Summary\n"
+    report += f"- **Total Spent:** {format_currency(total)}\n"
+    report += f"- **Number of Expenses:** {len(expenses)}\n\n"
+
+    report += "## By Category\n"
+    for cat, amount in sorted(breakdown.items(), key=lambda x: x[1], reverse=True):
+        pct = (amount / total) * 100
+        report += f"- {cat}: {format_currency(amount)} ({pct:.1f}%)\n"
+
+    report += "\n## Top 5 Expenses\n"
+    for i, exp in enumerate(top, 1):
+        report += f"{i}. {format_currency(exp.amount)} - {exp.description} ({exp.category})\n"
+
+    return report
+
+
+def get_category_breakdown(expenses: list["Expense"]) -> dict[str, float]:
+    """Get spending breakdown by category."""
+    breakdown: dict[str, float] = {}
+    for exp in expenses:
+        breakdown[exp.category] = breakdown.get(exp.category, 0) + exp.amount
+    return breakdown
+
+
+def get_top_expenses(expenses: list["Expense"], n: int = 5) -> list["Expense"]:
+    """Get the top N expenses by amount."""
+    return sorted(expenses, key=lambda x: x.amount, reverse=True)[:n]
+
+
+def save_report(report: str, filename: str) -> Path:
+    """Save report to a file."""
+    path = Path("reports") / filename
+    path.parent.mkdir(exist_ok=True)
+    path.write_text(report)
+    return path

package/levels/11-worktrees/exercise/seed_data.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""Seed the database with sample expenses for learning.
+
+Run this script to populate the database with example data:
+    python seed_data.py
+
+This creates a realistic set of expenses for students to work with.
+"""
+
+from datetime import datetime
+from database import init_db, clear_all_expenses
+from models import add_expense
+
+# Sample expenses for the course
+# Note: One entry has lowercase "food" to trigger the case-sensitivity bug
+SAMPLE_EXPENSES = [
+    # January 2026 - Primary month for exercises
+    (45.50, "Food", "Grocery shopping at Whole Foods", "2026-01-15"),
+    (12.00, "Transport", "Uber to airport", "2026-01-14"),
+    (89.99, "Shopping", "Running shoes from Nike", "2026-01-10"),
+    (150.00, "Bills", "Electric bill", "2026-01-01"),
+    (8.50, "food", "Coffee at Starbucks", "2026-01-20"),  # lowercase - triggers bug!
+    (35.00, "Entertainment", "Movie tickets for two", "2026-01-18"),
+    (22.00, "Food", "Lunch with team", "2026-01-19"),
+    (65.00, "Health", "Gym membership monthly", "2026-01-01"),
+    (15.75, "Food", "Thai takeout dinner", "2026-01-17"),
+    (42.00, "Transport", "Weekly metro pass", "2026-01-13"),
+    (28.99, "Entertainment", "Netflix + Spotify", "2026-01-05"),
+    (120.00, "Shopping", "Winter jacket on sale", "2026-01-08"),
+
+    # December 2025 - For month filtering tests
+    (200.00, "Shopping", "Holiday gifts for family", "2025-12-20"),
+    (55.00, "Food", "Holiday dinner groceries", "2025-12-25"),
+    (75.00, "Entertainment", "Concert tickets", "2025-12-15"),
+    (30.00, "Transport", "Airport parking", "2025-12-23"),
+
+    # November 2025 - Additional historical data
+    (95.00, "Bills", "Internet bill", "2025-11-15"),
+    (180.00, "Health", "Doctor visit copay", "2025-11-10"),
+    (45.00, "Food", "Birthday dinner", "2025-11-22"),
+]
+
+
+def seed_database(verbose: bool = True) -> int:
+    """Initialize and seed the database with sample data.
+
+    Args:
+        verbose: Whether to print progress messages
+
+    Returns:
+        Number of expenses added
+    """
+    if verbose:
+        print("Initializing database...")
+    init_db()
+
+    if verbose:
+        print("Clearing existing data...")
+    clear_all_expenses()
+
+    if verbose:
+        print("Adding sample expenses...")
+
+    count = 0
+    for amount, category, desc, date_str in SAMPLE_EXPENSES:
+        date = datetime.strptime(date_str, "%Y-%m-%d")
+        expense = add_expense(amount, category, desc, date)
+        count += 1
+        if verbose:
+            print(f"  Added: {expense.id} - ${amount:.2f} - {desc[:40]}")
+
+    if verbose:
+        print(f"\n{'='*50}")
+        print(f"Seeded {count} expenses successfully!")
+        print(f"{'='*50}")
+        print("\nTry these commands:")
+        print("  python main.py list")
+        print("  python main.py list --category Food")
+        print("  python main.py summary")
+        print("  pytest -v")
+
+    return count
+
+
+def main():
+    """Entry point for seeding script."""
+    seed_database()
+
+
+if __name__ == "__main__":
+    main()

package/levels/11-worktrees/exercise/tests/__init__.py

@@ -0,0 +1 @@
+"""Test package for expense tracker."""

package/levels/11-worktrees/exercise/tests/conftest.py

@@ -0,0 +1,69 @@
+"""Pytest configuration and shared fixtures."""
+
+import os
+import sys
+import pytest
+from pathlib import Path
+
+# Add parent directory to path so we can import our modules
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+# Use a separate test database
+TEST_DB_PATH = Path(__file__).parent / "test_expenses.db"
+os.environ["EXPENSE_DB_PATH"] = str(TEST_DB_PATH)
+
+
+@pytest.fixture(autouse=True)
+def clean_test_db():
+    """Ensure clean database for each test.
+
+    This fixture runs automatically before and after each test.
+    It initializes the database and cleans up after.
+    """
+    from database import init_db, clear_all_expenses
+
+    # Setup: initialize fresh database
+    init_db()
+    clear_all_expenses()
+
+    yield  # Run the test
+
+    # Teardown: clean up
+    clear_all_expenses()
+
+
+@pytest.fixture
+def sample_expenses():
+    """Create a set of sample expenses for testing.
+
+    Returns:
+        List of created Expense objects
+    """
+    from datetime import datetime
+    from models import add_expense
+
+    expenses = [
+        add_expense(50.00, "Food", "Groceries", datetime(2026, 1, 15)),
+        add_expense(30.00, "Transport", "Uber ride", datetime(2026, 1, 14)),
+        add_expense(25.00, "Food", "Lunch", datetime(2026, 1, 16)),
+        add_expense(100.00, "Shopping", "Clothes", datetime(2026, 1, 10)),
+        add_expense(15.00, "Entertainment", "Movie", datetime(2026, 1, 12)),
+    ]
+    return expenses
+
+
+@pytest.fixture
+def mixed_case_expenses():
+    """Create expenses with mixed case categories for bug testing.
+
+    This fixture specifically tests the case-sensitivity bug.
+    """
+    from datetime import datetime
+    from models import add_expense
+
+    expenses = [
+        add_expense(50.00, "Food", "Groceries", datetime(2026, 1, 15)),
+        add_expense(25.00, "food", "Coffee", datetime(2026, 1, 16)),  # lowercase
+        add_expense(30.00, "FOOD", "Dinner", datetime(2026, 1, 17)),  # uppercase
+    ]
+    return expenses