gdmcode 0.1.0__py3-none-any.whl

src/agent/task_tracker.py

@@ -0,0 +1,320 @@
+"""TaskTracker -- manages task decomposition and live progress tracking.
+
+Tasks are stored in the ``tasks`` SQLite table (gdm.db) and survive process
+restarts.  The ``/tasks`` slash command reads from this tracker.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import sqlite3
+import uuid
+from dataclasses import dataclass, field
+from typing import Final
+
+from rich.console import Console
+
+from src.exceptions import DatabaseError
+from src.memory.db import GdmDatabase
+
+__all__ = ["Subtask", "Task", "TaskTracker"]
+
+log = logging.getLogger(__name__)
+console = Console()
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+_STATUS_PENDING: Final[str] = "pending"
+_STATUS_IN_PROGRESS: Final[str] = "in_progress"
+_STATUS_DONE: Final[str] = "done"
+_STATUS_BLOCKED: Final[str] = "blocked"
+_STATUS_FAILED: Final[str] = "failed"
+
+_VALID_SUBTASK_STATUSES: Final[frozenset[str]] = frozenset(
+    {_STATUS_PENDING, _STATUS_IN_PROGRESS, _STATUS_DONE, _STATUS_BLOCKED, _STATUS_FAILED}
+)
+
+_ICON_DONE: Final[str] = "\u2713"        # checkmark
+_ICON_IN_PROGRESS: Final[str] = "\u27f3" # clockwise circle arrow
+_ICON_FAILED: Final[str] = "\u2717"      # ballot x  (also for blocked)
+_ICON_PENDING: Final[str] = "\u25cb"     # white circle
+
+_RESUME_PREFIX: Final[str] = "Resume previous task:"
+_BLOCKED_TAG: Final[str] = "BLOCKED"
+
+_SELECT_COLS: Final[str] = "task_id, session_id, title, status, subtasks"
+
+
+# ---------------------------------------------------------------------------
+# Dataclasses
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class Subtask:
+    """A subtask within a Task.
+
+    Statuses: ``pending`` | ``in_progress`` | ``done`` | ``blocked`` | ``failed``
+    """
+
+    id: str
+    title: str
+    status: str = _STATUS_PENDING
+    depends_on: list[str] = field(default_factory=list)
+
+
+@dataclass
+class Task:
+    """A top-level task managed by :class:`TaskTracker`.
+
+    Statuses: ``pending`` | ``in_progress`` | ``done`` | ``blocked``
+    """
+
+    task_id: str
+    session_id: str
+    title: str
+    status: str
+    subtasks: list[Subtask]
+
+    def progress_str(self) -> str:
+        """Return ``[done/total]`` progress string, e.g. ``[2/6]``."""
+        done = sum(1 for s in self.subtasks if s.status == _STATUS_DONE)
+        return f"[{done}/{len(self.subtasks)}]"
+
+    def to_rich_panel(self) -> str:
+        """Return Rich markup string showing task and subtask statuses.
+
+        Example::
+
+            [bold]Add OAuth2 to auth module[/bold] [2/6]
+            checkmark Read current auth.ts structure
+            arrow Implementing OAuth2 callback handler...
+            circle Write unit tests
+        """
+        progress = self.progress_str() if self.subtasks else ""
+        header = f"[bold]{self.title}[/bold]"
+        if progress:
+            header = f"{header} {progress}"
+        lines = [header]
+        for sub in self.subtasks:
+            lines.append(f"{_subtask_icon(sub.status)} {sub.title}")
+        return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Module-level helpers
+# ---------------------------------------------------------------------------
+
+
+def _subtask_icon(status: str) -> str:
+    """Map subtask status to its single-character display icon."""
+    if status == _STATUS_DONE:
+        return _ICON_DONE
+    if status == _STATUS_IN_PROGRESS:
+        return _ICON_IN_PROGRESS
+    if status in (_STATUS_FAILED, _STATUS_BLOCKED):
+        return _ICON_FAILED
+    return _ICON_PENDING
+
+
+def _row_to_task(row: sqlite3.Row) -> Task:
+    """Convert a :class:`sqlite3.Row` from the tasks table to a :class:`Task`."""
+    raw: list[dict[str, str]] = json.loads(row["subtasks"] or "[]")
+    subtasks = [
+        Subtask(
+            id=s["id"],
+            title=s["title"],
+            status=s.get("status", _STATUS_PENDING),
+            depends_on=s.get("depends_on", []),
+        )
+        for s in raw
+    ]
+    return Task(
+        task_id=row["task_id"],
+        session_id=row["session_id"],
+        title=row["title"],
+        status=row["status"],
+        subtasks=subtasks,
+    )
+
+
+def _subtasks_to_json(subtasks: list[Subtask]) -> str:
+    """Serialize a list of :class:`Subtask` objects to a JSON string."""
+    return json.dumps(
+        [{"id": s.id, "title": s.title, "status": s.status} for s in subtasks]
+    )
+
+
+# ---------------------------------------------------------------------------
+# TaskTracker
+# ---------------------------------------------------------------------------
+
+
+class TaskTracker:
+    """Manages task decomposition and live progress for the current session.
+
+    All state is persisted to gdm.db tasks table -- tasks survive restarts.
+
+    Usage::
+
+        tracker = TaskTracker(db, session_id)
+        task_id = tracker.create_task("Add OAuth2 to auth module")
+        subtask_id = tracker.add_subtask(task_id, "Read current auth.ts structure")
+        tracker.update_subtask(task_id, subtask_id, "in_progress")
+        tracker.update_subtask(task_id, subtask_id, "done")
+        active = tracker.get_active()  # list of in_progress + pending tasks
+    """
+
+    def __init__(self, db: GdmDatabase, session_id: str) -> None:
+        self._db = db
+        self._session_id = session_id
+
+    # ------------------------------------------------------------------
+    # Task lifecycle
+    # ------------------------------------------------------------------
+
+    def create_task(self, title: str) -> str:
+        """Create a new task.  Returns task_id (UUID).  Status starts as ``pending``."""
+        task_id = str(uuid.uuid4())
+        self._db.execute(
+            f"INSERT INTO tasks ({_SELECT_COLS}) VALUES (?, ?, ?, ?, ?)",
+            (task_id, self._session_id, title, _STATUS_PENDING, "[]"),
+        )
+        log.debug("Created task %s: %s", task_id, title)
+        return task_id
+
+    def start_task(self, task_id: str) -> None:
+        """Mark task as ``in_progress``."""
+        self._set_status(task_id, _STATUS_IN_PROGRESS)
+
+    def complete_task(self, task_id: str) -> None:
+        """Mark task as ``done``."""
+        self._set_status(task_id, _STATUS_DONE)
+
+    def block_task(self, task_id: str, reason: str) -> None:
+        """Mark task as ``blocked``.  Appends *reason* to the task title."""
+        task = self._require_task(task_id)
+        new_title = f"{task.title} [{_BLOCKED_TAG}: {reason}]"
+        self._db.execute(
+            "UPDATE tasks SET status = ?, title = ? WHERE task_id = ?",
+            (_STATUS_BLOCKED, new_title, task_id),
+        )
+        log.debug("Blocked task %s: %s", task_id, reason)
+
+    # ------------------------------------------------------------------
+    # Subtask operations
+    # ------------------------------------------------------------------
+
+    def add_subtask(self, task_id: str, title: str) -> str:
+        """Add a subtask to an existing task.  Returns the new subtask_id."""
+        task = self._require_task(task_id)
+        subtask_id = str(uuid.uuid4())
+        task.subtasks.append(Subtask(id=subtask_id, title=title))
+        self._db.execute(
+            "UPDATE tasks SET subtasks = ? WHERE task_id = ?",
+            (_subtasks_to_json(task.subtasks), task_id),
+        )
+        log.debug("Added subtask %s to task %s: %s", subtask_id, task_id, title)
+        return subtask_id
+
+    def update_subtask(self, task_id: str, subtask_id: str, status: str) -> None:
+        """Update a subtask status.  Auto-completes parent when all subtasks done."""
+        if status not in _VALID_SUBTASK_STATUSES:
+            raise DatabaseError(
+                f"Invalid subtask status {status!r}. "
+                f"Must be one of: {sorted(_VALID_SUBTASK_STATUSES)}"
+            )
+        task = self._require_task(task_id)
+        found = False
+        for sub in task.subtasks:
+            if sub.id == subtask_id:
+                sub.status = status
+                found = True
+                break
+        if not found:
+            raise DatabaseError(
+                f"Subtask {subtask_id!r} not found in task {task_id!r}"
+            )
+        self._db.execute(
+            "UPDATE tasks SET subtasks = ? WHERE task_id = ?",
+            (_subtasks_to_json(task.subtasks), task_id),
+        )
+        self._auto_complete_parent(task_id, task.subtasks)
+
+    # ------------------------------------------------------------------
+    # Query methods
+    # ------------------------------------------------------------------
+
+    def get_active(self) -> list[Task]:
+        """Return ``in_progress`` and ``pending`` tasks for this session."""
+        rows = self._db.execute_all(
+            f"SELECT {_SELECT_COLS} FROM tasks "
+            "WHERE session_id = ? AND status IN (?, ?) ORDER BY rowid",
+            (self._session_id, _STATUS_IN_PROGRESS, _STATUS_PENDING),
+        )
+        return [_row_to_task(r) for r in rows]
+
+    def get_all(self) -> list[Task]:
+        """Return all tasks for this session, regardless of status."""
+        rows = self._db.execute_all(
+            f"SELECT {_SELECT_COLS} FROM tasks WHERE session_id = ? ORDER BY rowid",
+            (self._session_id,),
+        )
+        return [_row_to_task(r) for r in rows]
+
+    def get_task(self, task_id: str) -> Task | None:
+        """Get a specific task by ID.  Returns ``None`` if not found."""
+        row = self._db.execute_one(
+            f"SELECT {_SELECT_COLS} FROM tasks WHERE task_id = ?",
+            (task_id,),
+        )
+        return _row_to_task(row) if row is not None else None
+
+    def resume_prompt(self) -> str | None:
+        """Return a resume prompt string if incomplete tasks exist, else ``None``.
+
+        Returns a string like::
+
+            'Resume previous task: [2/6] Add OAuth2...'
+        """
+        active = self.get_active()
+        if not active:
+            return None
+        in_progress = [t for t in active if t.status == _STATUS_IN_PROGRESS]
+        task = in_progress[0] if in_progress else active[0]
+        parts: list[str] = [_RESUME_PREFIX]
+        if task.subtasks:
+            parts.append(task.progress_str())
+        parts.append(task.title)
+        return " ".join(parts)
+
+    # ------------------------------------------------------------------
+    # Private helpers
+    # ------------------------------------------------------------------
+
+    def _set_status(self, task_id: str, status: str) -> None:
+        """Execute a status UPDATE for a task row."""
+        self._db.execute(
+            "UPDATE tasks SET status = ? WHERE task_id = ? AND session_id = ?",
+            (status, task_id, self._session_id),
+        )
+        log.debug("Task %s -> %s", task_id, status)
+
+    def _require_task(self, task_id: str) -> Task:
+        """Return the task or raise :class:`DatabaseError` if not found."""
+        task = self.get_task(task_id)
+        if task is None:
+            raise DatabaseError(
+                f"Task {task_id!r} not found in session {self._session_id!r}"
+            )
+        return task
+
+    def _auto_complete_parent(self, task_id: str, subtasks: list[Subtask]) -> None:
+        """Mark parent task ``done`` when every subtask is ``done``."""
+        if not subtasks:
+            return
+        if all(s.status == _STATUS_DONE for s in subtasks):
+            self._set_status(task_id, _STATUS_DONE)
+            log.debug("Auto-completed task %s (all subtasks done)", task_id)

src/agent/test_validator.py

@@ -0,0 +1,210 @@
+"""Test validator — checks quality of LLM-generated tests before committing.
+
+Validates:
+  1. Coverage threshold — new tests add net-positive coverage
+  2. Assertion density  — tests must have ≥1 assertion per test function
+  3. No tautological asserts — e.g., assert True, assert x == x
+  4. Mock hygiene — mocks must target real paths (no mock of non-existent)
+  5. Test isolation — no global state mutation between tests
+"""
+from __future__ import annotations
+
+import ast
+import logging
+import re
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+__all__ = ["TestValidator", "TestValidationResult"]
+
+log = logging.getLogger(__name__)
+
+_MIN_ASSERTIONS_PER_TEST: int = 1
+_COVERAGE_THRESHOLD_PCT: float = 0.0  # net-positive (≥0 change)
+
+_TAUTOLOGICAL_PATTERNS: list[re.Pattern[str]] = [
+    re.compile(r"assert\s+True\s*$", re.MULTILINE),
+    re.compile(r"assert\s+1\s*==\s*1", re.MULTILINE),
+]
+
+
+# ---------------------------------------------------------------------------
+# Result dataclass
+# ---------------------------------------------------------------------------
+
+@dataclass
+class TestValidationResult:
+    """Result of validating a test file."""
+
+    file: str
+    passed: bool = True
+    issues: list[str] = field(default_factory=list)
+    test_count: int = 0
+    assertion_count: int = 0
+    tautological_count: int = 0
+
+    def add_issue(self, msg: str) -> None:
+        self.issues.append(msg)
+        self.passed = False
+
+    def summary(self) -> str:
+        status = "PASS" if self.passed else "FAIL"
+        parts = [f"[{status}] {self.file} — {self.test_count} tests, {self.assertion_count} assertions"]
+        if self.issues:
+            parts += [f"  • {i}" for i in self.issues]
+        return "\n".join(parts)
+
+
+# ---------------------------------------------------------------------------
+# AST visitor
+# ---------------------------------------------------------------------------
+
+class _TestVisitor(ast.NodeVisitor):
+    """Collect test function metadata via AST walk."""
+
+    def __init__(self) -> None:
+        self.test_functions: list[ast.FunctionDef] = []
+        self.assertions: int = 0
+        self.tautological: int = 0
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:  # noqa: N802
+        if node.name.startswith("test_"):
+            self.test_functions.append(node)
+            self._count_assertions(node)
+        self.generic_visit(node)
+
+    visit_AsyncFunctionDef = visit_FunctionDef  # noqa: N815
+
+    def _count_assertions(self, node: ast.FunctionDef) -> None:
+        for child in ast.walk(node):
+            if isinstance(child, ast.Assert):
+                self.assertions += 1
+                if self._is_tautological(child):
+                    self.tautological += 1
+
+    @staticmethod
+    def _is_tautological(node: ast.Assert) -> bool:
+        test = node.test
+        # assert True
+        if isinstance(test, ast.Constant) and test.value is True:
+            return True
+        # assert x == x  (Compare where left == right)
+        if isinstance(test, ast.Compare) and len(test.comparators) == 1:
+            if isinstance(test.ops[0], ast.Eq):
+                if ast.dump(test.left) == ast.dump(test.comparators[0]):
+                    return True
+        return False
+
+
+# ---------------------------------------------------------------------------
+# TestValidator
+# ---------------------------------------------------------------------------
+
+class TestValidator:
+    """Validate quality of test files before they are committed.
+
+    Usage::
+
+        validator = TestValidator()
+        result = validator.validate(Path("tests/test_auth.py"))
+        if not result.passed:
+            print(result.summary())
+    """
+
+    def validate(self, test_path: Path) -> TestValidationResult:
+        """Run all checks on *test_path*. Returns a TestValidationResult."""
+        result = TestValidationResult(file=str(test_path))
+
+        if not test_path.exists():
+            result.add_issue(f"File not found: {test_path}")
+            return result
+
+        try:
+            source = test_path.read_text(encoding="utf-8")
+        except OSError as exc:
+            result.add_issue(f"Cannot read file: {exc}")
+            return result
+
+        try:
+            tree = ast.parse(source, filename=str(test_path))
+        except SyntaxError as exc:
+            result.add_issue(f"Syntax error: {exc}")
+            return result
+
+        visitor = _TestVisitor()
+        visitor.visit(tree)
+
+        result.test_count = len(visitor.test_functions)
+        result.assertion_count = visitor.assertions
+        result.tautological_count = visitor.tautological
+
+        self._check_test_count(result)
+        self._check_assertions(result, visitor)
+        self._check_tautological(result, source)
+        self._check_mock_hygiene(result, tree, test_path)
+
+        return result
+
+    def validate_many(self, test_dir: Path) -> list[TestValidationResult]:
+        """Validate all test_*.py files in *test_dir*."""
+        results: list[TestValidationResult] = []
+        for path in sorted(test_dir.rglob("test_*.py")):
+            results.append(self.validate(path))
+        return results
+
+    # ------------------------------------------------------------------
+    # Checks
+    # ------------------------------------------------------------------
+
+    def _check_test_count(self, result: TestValidationResult) -> None:
+        if result.test_count == 0:
+            result.add_issue("No test functions found (must start with test_)")
+
+    def _check_assertions(
+        self, result: TestValidationResult, visitor: _TestVisitor
+    ) -> None:
+        """Each test function must have ≥1 assertion."""
+        for fn in visitor.test_functions:
+            fn_assertions = sum(
+                1 for node in ast.walk(fn) if isinstance(node, ast.Assert)
+            )
+            if fn_assertions < _MIN_ASSERTIONS_PER_TEST:
+                result.add_issue(
+                    f"test '{fn.name}' has 0 assertions (line {fn.lineno})"
+                )
+
+    def _check_tautological(self, result: TestValidationResult, source: str) -> None:
+        for pat in _TAUTOLOGICAL_PATTERNS:
+            if pat.search(source):
+                result.tautological_count += 1
+                result.add_issue(f"Tautological assert detected: {pat.pattern!r}")
+
+    def _check_mock_hygiene(
+        self, result: TestValidationResult, tree: ast.AST, test_path: Path
+    ) -> None:
+        """Warn if mock.patch targets a path that does not exist in sys.modules context."""
+        for node in ast.walk(tree):
+            if not isinstance(node, (ast.Call,)):
+                continue
+            func = node.func
+            # look for @patch("some.path") or mocker.patch("some.path")
+            if not isinstance(func, ast.Attribute) or func.attr != "patch":
+                continue
+            for arg in node.args:
+                if isinstance(arg, ast.Constant) and isinstance(arg.value, str):
+                    target = arg.value
+                    if not self._mock_target_plausible(target):
+                        result.add_issue(
+                            f"Mock target may not exist: {target!r} (line {node.lineno})"
+                        )
+
+    @staticmethod
+    def _mock_target_plausible(target: str) -> bool:
+        """Return True if mock target looks like a valid dotted path."""
+        parts = target.split(".")
+        if len(parts) < 2:  # noqa: PLR2004
+            return False
+        # basic sanity: all parts must be valid identifiers
+        return all(p.isidentifier() for p in parts)