misterdev 0.2.0__py3-none-any.whl

misterdev/core/context/change_tracker.py

@@ -0,0 +1,218 @@
+"""Diff-based change tracking across tasks.
+
+Records what each completed task changed (files, additions, deletions).
+Before a downstream task executes, injects relevant recent changes so
+the LLM knows the current state of files it depends on.
+
+Addresses ~20% of later-task failures where the LLM operates on stale
+assumptions about code that was modified by earlier tasks.
+"""
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Dict, List
+
+from misterdev.logging_setup import setup_logger
+from misterdev.utils.file_utils import (
+    atomic_write,
+    orchestrator_state_file,
+)
+
+logger = setup_logger(__name__)
+
+
+class TaskChange:
+    def __init__(
+        self,
+        task_id: str,
+        files: List[str],
+        diff_summary: str,
+        additions: int,
+        deletions: int,
+    ):
+        self.task_id = task_id
+        self.files = files
+        self.diff_summary = diff_summary
+        self.additions = additions
+        self.deletions = deletions
+
+    def to_dict(self) -> dict:
+        return {
+            "task_id": self.task_id,
+            "files": self.files,
+            "diff_summary": self.diff_summary,
+            "additions": self.additions,
+            "deletions": self.deletions,
+        }
+
+    @staticmethod
+    def from_dict(data: dict) -> "TaskChange":
+        return TaskChange(
+            task_id=data["task_id"],
+            files=data.get("files", []),
+            diff_summary=data.get("diff_summary", ""),
+            additions=data.get("additions", 0),
+            deletions=data.get("deletions", 0),
+        )
+
+
+class ChangeTracker:
+    """Tracks what each task changed for downstream context injection."""
+
+    def __init__(self, project_path: Path):
+        self.project_path = project_path
+        self._file = orchestrator_state_file(project_path, "changes.json")
+        self.changes: Dict[str, TaskChange] = {}
+        self._load()
+
+    def _load(self):
+        if self._file.exists():
+            try:
+                data = json.loads(self._file.read_text(encoding="utf-8"))
+                for task_id, entry in data.items():
+                    self.changes[task_id] = TaskChange.from_dict(entry)
+            except (json.JSONDecodeError, OSError, KeyError):
+                self.changes = {}
+
+    def _save(self):
+        data = {tid: tc.to_dict() for tid, tc in self.changes.items()}
+        atomic_write(self._file, json.dumps(data, indent=2))
+
+    def record_task_changes(
+        self, task_id: str, modified_files: List[str]
+    ) -> TaskChange:
+        """Record what a completed task changed. Call after task commit."""
+        diff_summary = self._get_task_diff(task_id, modified_files)
+        additions, deletions = self._count_diff_stats(diff_summary)
+
+        change = TaskChange(
+            task_id=task_id,
+            files=modified_files,
+            diff_summary=diff_summary[:2000],  # cap stored diff
+            additions=additions,
+            deletions=deletions,
+        )
+        self.changes[task_id] = change
+        self._save()
+        logger.info(
+            f"Tracked changes for {task_id}: {len(modified_files)} files, +{additions}/-{deletions}"
+        )
+        return change
+
+    def get_recent_changes_for_files(
+        self, target_files: List[str], max_entries: int = 5
+    ) -> str:
+        """Get recent changes that touched any of the target files."""
+        relevant = []
+        for change in reversed(list(self.changes.values())):
+            overlap = set(change.files) & set(target_files)
+            if overlap:
+                relevant.append((change, overlap))
+            if len(relevant) >= max_entries:
+                break
+
+        if not relevant:
+            return ""
+
+        lines = ["## Recent Changes to Related Files"]
+        for change, overlap_files in relevant:
+            lines.append(f"\n### {change.task_id} (touched {', '.join(overlap_files)})")
+            lines.append(f"+{change.additions}/-{change.deletions} lines")
+            if change.diff_summary:
+                # Show only the parts relevant to overlapping files
+                filtered = self._filter_diff_for_files(
+                    change.diff_summary, overlap_files
+                )
+                if filtered:
+                    lines.append(f"```diff\n{filtered}\n```")
+
+        return "\n".join(lines)
+
+    def _get_task_diff(self, task_id: str, files: List[str]) -> str:
+        """Return the diff produced by a single task.
+
+        Each task commits with a message ``task(<id>): ...``. Looking the
+        commit up by ID means every task is attributed its own diff regardless
+        of how many other tasks committed before this is recorded (a plain
+        ``HEAD~1 HEAD`` would give every task in a batch the same final diff).
+        Falls back to a file-scoped working-tree diff when the commit can't be
+        found (e.g. file-snapshot mode in a non-git repo).
+        """
+        sha = self._find_task_commit(task_id)
+        if sha:
+            diff = self._run_git(["diff", f"{sha}~1", sha, "--unified=3", "--", *files])
+            if diff:
+                return diff
+        # Fallback for tasks not committed under the task(<id>): convention:
+        # the most recent commit, scoped to the task's files when known.
+        scope = ["--", *files] if files else []
+        diff = self._run_git(["diff", "HEAD~1", "HEAD", "--unified=3", *scope])
+        if diff:
+            return diff
+        # Last resort: uncommitted working-tree changes for the task's files.
+        if files:
+            return self._run_git(["diff", "HEAD", "--unified=3", "--", *files])
+        return ""
+
+    def _find_task_commit(self, task_id: str) -> str:
+        """Find the SHA of the commit recording this task, if any."""
+        out = self._run_git(
+            [
+                "log",
+                "--all",
+                "-n",
+                "1",
+                "--format=%H",
+                "--fixed-strings",
+                f"--grep=task({task_id}):",
+            ]
+        )
+        lines = out.splitlines()
+        return lines[0].strip() if lines else ""
+
+    def _run_git(self, args: List[str]) -> str:
+        """Run a git command (list form, no shell) and return stdout, or ''."""
+        try:
+            proc = subprocess.run(
+                ["git", *args],
+                cwd=self.project_path,
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            return proc.stdout.strip() if proc.returncode == 0 else ""
+        except Exception as e:
+            logger.debug(f"Could not run git {args[0] if args else ''}: {e}")
+            return ""
+
+    def _count_diff_stats(self, diff: str) -> tuple:
+        additions = 0
+        deletions = 0
+        for line in diff.splitlines():
+            if line.startswith("+") and not line.startswith("+++"):
+                additions += 1
+            elif line.startswith("-") and not line.startswith("---"):
+                deletions += 1
+        return additions, deletions
+
+    def _filter_diff_for_files(
+        self, diff: str, target_files: set, max_lines: int = 30
+    ) -> str:
+        """Extract diff hunks for specific files only."""
+        lines = diff.splitlines()
+        output = []
+        in_relevant_file = False
+        line_count = 0
+
+        for line in lines:
+            if line.startswith("diff --git"):
+                in_relevant_file = any(f in line for f in target_files)
+            if in_relevant_file:
+                output.append(line)
+                line_count += 1
+                if line_count >= max_lines:
+                    output.append("... (truncated)")
+                    break
+
+        return "\n".join(output)

misterdev/core/context/contracts/__init__.py

@@ -0,0 +1,63 @@
+"""Cross-task interface contract registry.
+
+After each task completes, extracts the public API it created or modified.
+Before executing downstream tasks, injects those contracts into prompts
+so the LLM knows the exact signatures it must honor.
+
+This addresses ~30% of multi-task build failures where one task assumes
+a different interface than what the previous task actually created.
+"""
+
+from ._log import logger
+from ._text import _extract_name
+from .extraction import _extract_public_symbols
+from .python_generic import _extract_generic_symbols, _extract_python_symbols
+from .registry import Contract, ContractRegistry
+from .rust_line import (
+    _collect_enum_variants,
+    _collect_signature,
+    _collect_struct_fields,
+    _collect_trait_methods,
+    _extract_generics,
+    _extract_impl_methods,
+    _extract_impl_name,
+    _extract_rust_symbols,
+    _strip_visibility,
+)
+from .rust_tree_sitter import (
+    _extract_rust_symbols_ts,
+    _ts_decl,
+    _ts_field_text,
+    _ts_is_pub,
+    _ts_pub_members,
+    _ts_trait_methods,
+    _ts_variant_names,
+    _walk_rust_ts,
+)
+
+__all__ = [
+    "logger",
+    "Contract",
+    "ContractRegistry",
+    "_extract_public_symbols",
+    "_extract_name",
+    "_extract_generic_symbols",
+    "_extract_python_symbols",
+    "_extract_rust_symbols",
+    "_extract_rust_symbols_ts",
+    "_strip_visibility",
+    "_extract_generics",
+    "_extract_impl_name",
+    "_extract_impl_methods",
+    "_collect_enum_variants",
+    "_collect_trait_methods",
+    "_collect_signature",
+    "_collect_struct_fields",
+    "_ts_is_pub",
+    "_ts_field_text",
+    "_ts_decl",
+    "_walk_rust_ts",
+    "_ts_pub_members",
+    "_ts_variant_names",
+    "_ts_trait_methods",
+]

misterdev/core/context/contracts/_log.py

@@ -0,0 +1,9 @@
+"""Shared logger for the contracts package.
+
+Uses the original module path as the logger name so log output is
+identical to the pre-split single-file module.
+"""
+
+from misterdev.logging_setup import setup_logger
+
+logger = setup_logger("misterdev.core.context.contracts")

misterdev/core/context/contracts/_text.py

@@ -0,0 +1,12 @@
+"""Shared text helpers used by the language-specific extractors."""
+
+
+def _extract_name(text: str) -> str:
+    """Extract identifier name from text (stops at non-alphanumeric)."""
+    name = []
+    for ch in text.strip():
+        if ch.isalnum() or ch == "_":
+            name.append(ch)
+        else:
+            break
+    return "".join(name)

misterdev/core/context/contracts/extraction.py

@@ -0,0 +1,30 @@
+"""Language dispatch for public-symbol extraction."""
+
+from typing import Dict, List
+
+from .python_generic import _extract_generic_symbols, _extract_python_symbols
+from .rust_line import _extract_rust_symbols
+from .rust_tree_sitter import _extract_rust_symbols_ts
+
+
+def _extract_public_symbols(content: str, language: str) -> List[Dict[str, str]]:
+    """Extract public API symbols from source code.
+
+    Uses line-by-line heuristic parsing (no regex). Works for Rust, Python,
+    TypeScript, Go. Not perfect, but catches the signatures that matter for
+    cross-task contracts.
+    """
+    lines = content.splitlines()
+
+    if language in ("rust", "rs"):
+        # Prefer tree-sitter (handles multi-line signatures, generics, where
+        # clauses); fall back to the line parser when the grammar is absent.
+        symbols = _extract_rust_symbols_ts(content)
+        if not symbols:
+            symbols = _extract_rust_symbols(lines)
+    elif language in ("python", "py"):
+        symbols = _extract_python_symbols(lines)
+    else:
+        symbols = _extract_generic_symbols(lines)
+
+    return symbols

misterdev/core/context/contracts/python_generic.py

@@ -0,0 +1,42 @@
+"""Public-symbol extraction for Python and generic C-like languages."""
+
+from typing import Dict, List
+
+from ._text import _extract_name
+
+
+def _extract_python_symbols(lines: List[str]) -> List[Dict[str, str]]:
+    """Extract top-level def and class from Python (non-underscore)."""
+    symbols = []
+    for line in lines:
+        stripped = line.strip()
+        if stripped.startswith("def ") and not stripped.startswith("def _"):
+            name = _extract_name(stripped[4:])
+            sig = stripped.rstrip(":")
+            symbols.append({"kind": "def", "name": name, "signature": sig})
+        elif stripped.startswith("class ") and not stripped.startswith("class _"):
+            name = _extract_name(stripped[6:])
+            symbols.append(
+                {"kind": "class", "name": name, "signature": stripped.rstrip(":")}
+            )
+    return symbols
+
+
+def _extract_generic_symbols(lines: List[str]) -> List[Dict[str, str]]:
+    """Fallback: extract function/type declarations from any C-like language."""
+    symbols = []
+    for line in lines:
+        stripped = line.strip()
+        if stripped.startswith("export ") or stripped.startswith("public "):
+            symbols.append(
+                {"kind": "export", "name": stripped[:60], "signature": stripped[:80]}
+            )
+        elif stripped.startswith("func "):
+            symbols.append(
+                {
+                    "kind": "func",
+                    "name": _extract_name(stripped[5:]),
+                    "signature": stripped[:80],
+                }
+            )
+    return symbols

misterdev/core/context/contracts/registry.py

@@ -0,0 +1,127 @@
+"""Contract data type and the cross-task contract registry."""
+
+import json
+import threading
+from pathlib import Path
+from typing import Dict, List
+
+from misterdev.utils.file_utils import (
+    atomic_write,
+    orchestrator_state_file,
+)
+
+from ._log import logger
+from .extraction import _extract_public_symbols
+
+
+class Contract:
+    """A public API contract extracted from a completed task."""
+
+    def __init__(self, task_id: str, file_path: str, symbols: List[Dict[str, str]]):
+        self.task_id = task_id
+        self.file_path = file_path
+        self.symbols = symbols  # [{name, kind, signature}]
+
+    def format_for_prompt(self) -> str:
+        lines = [f"### {self.file_path} (from {self.task_id})"]
+        for sym in self.symbols:
+            kind = sym.get("kind", "symbol")
+            name = sym.get("name", "?")
+            sig = sym.get("signature", "")
+            lines.append(f"- {kind}: `{sig or name}`")
+        return "\n".join(lines)
+
+
+class ContractRegistry:
+    """Manages interface contracts across tasks.
+
+    After a task completes, call `extract_contracts()` to record what it exported.
+    Before a task executes, call `get_contracts_for_task()` to get the interfaces
+    it depends on.
+    """
+
+    def __init__(self, project_path: Path):
+        self.contracts: Dict[str, List[Contract]] = {}  # task_id -> contracts
+        self._file = orchestrator_state_file(project_path, "contracts.json")
+        self._lock = threading.Lock()
+        self._load()
+
+    def _load(self):
+        if self._file.exists():
+            try:
+                data = json.loads(self._file.read_text(encoding="utf-8"))
+                for task_id, entries in data.items():
+                    self.contracts[task_id] = [
+                        Contract(task_id, e["file_path"], e["symbols"]) for e in entries
+                    ]
+            except (json.JSONDecodeError, OSError, KeyError):
+                self.contracts = {}
+
+    def _save(self):
+        data = {}
+        for task_id, contracts in self.contracts.items():
+            data[task_id] = [
+                {"file_path": c.file_path, "symbols": c.symbols} for c in contracts
+            ]
+        atomic_write(self._file, json.dumps(data, indent=2))
+
+    def extract_contracts(
+        self,
+        task_id: str,
+        modified_files: List[str],
+        project_path: Path,
+        llm_client,
+        language: str = "rust",
+    ) -> List[Contract]:
+        """Extract public API from files modified by a completed task."""
+        contracts = []
+        for file_path in modified_files:
+            full_path = project_path / file_path
+            if not full_path.exists():
+                continue
+            try:
+                content = full_path.read_text(encoding="utf-8")
+            except (UnicodeDecodeError, OSError):
+                continue
+
+            if len(content.strip()) == 0:
+                continue
+
+            symbols = _extract_public_symbols(content, language)
+            if symbols:
+                contracts.append(Contract(task_id, file_path, symbols))
+
+        with self._lock:
+            self.contracts[task_id] = contracts
+            self._save()
+        logger.info(
+            f"Extracted {sum(len(c.symbols) for c in contracts)} contracts from {task_id}"
+        )
+        return contracts
+
+    def get_contracts_for_task(self, dependency_ids: List[str]) -> str:
+        """Format contracts from dependency tasks as prompt context."""
+        if not dependency_ids:
+            return ""
+
+        relevant = []
+        with self._lock:
+            for dep_id in dependency_ids:
+                if dep_id in self.contracts:
+                    relevant.extend(self.contracts[dep_id])
+
+        if not relevant:
+            return ""
+
+        lines = [
+            "## Interface Contracts (from completed dependency tasks)",
+            "Your code MUST use these exact signatures. Do not guess or assume different names.\n",
+        ]
+        for contract in relevant:
+            lines.append(contract.format_for_prompt())
+        return "\n".join(lines)
+
+    def get_all_contracts_summary(self) -> str:
+        """Summary for reporting."""
+        total = sum(len(cs) for cs in self.contracts.values())
+        return f"{len(self.contracts)} tasks, {total} total contracts"