anvil-dev-framework 0.1.6

package/global/lib/verify_iteration.py

@@ -0,0 +1,490 @@
+#!/usr/bin/env python3
+"""
+verify_iteration.py - Verification iteration logic for /verify command (ANV-150)
+
+Handles the iteration loop for fixing verification failures:
+- Tracks iteration count and state
+- Generates fix context with failing file contents
+- Determines when to escalate after max attempts
+- Re-runs verification after each fix attempt
+
+Usage:
+    from verify_iteration import VerificationIterator
+
+    iterator = VerificationIterator(max_iterations=3)
+
+    while not iterator.is_complete():
+        result = iterator.run_verification()
+        if result.passed:
+            break
+
+        # Get context for fixing
+        fix_context = iterator.get_fix_context(result)
+        # ... apply fixes ...
+
+        iterator.record_attempt(result)
+"""
+
+import json
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional
+
+from verification_runner import (
+    VerificationConfig,
+    VerificationError,
+    VerificationResult,
+    VerificationRunner,
+)
+
+
+# =============================================================================
+# Data Models
+# =============================================================================
+
+@dataclass
+class FixContext:
+    """Context for fixing a verification error."""
+    error: VerificationError
+    file_content: str
+    file_path: str
+    relevant_lines: List[str]
+    line_start: int
+    line_end: int
+    suggestion: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "file": self.file_path,
+            "error": self.error.to_dict(),
+            "line_start": self.line_start,
+            "line_end": self.line_end,
+            "relevant_lines": self.relevant_lines,
+            "suggestion": self.suggestion,
+        }
+
+
+@dataclass
+class IterationState:
+    """State tracking for verification iterations."""
+    current_iteration: int = 0
+    max_iterations: int = 3
+    started_at: Optional[str] = None
+    attempts: List[Dict[str, Any]] = field(default_factory=list)
+    status: Literal["pending", "running", "passed", "failed", "escalated"] = "pending"
+    last_result: Optional[VerificationResult] = None
+    fixed_errors: List[str] = field(default_factory=list)  # file paths
+    remaining_errors: List[VerificationError] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "current_iteration": self.current_iteration,
+            "max_iterations": self.max_iterations,
+            "started_at": self.started_at,
+            "status": self.status,
+            "attempts_count": len(self.attempts),
+            "fixed_count": len(self.fixed_errors),
+            "remaining_count": len(self.remaining_errors),
+        }
+
+
+# =============================================================================
+# Fix Context Generation
+# =============================================================================
+
+class FixContextGenerator:
+    """Generate context for fixing verification errors."""
+
+    CONTEXT_LINES = 10  # Lines before/after error to include
+
+    @classmethod
+    def read_file_with_context(
+        cls,
+        file_path: str,
+        error_line: Optional[int],
+        project_root: Path,
+    ) -> FixContext:
+        """Read file and extract relevant context around error."""
+        full_path = project_root / file_path
+
+        try:
+            with open(full_path, 'r') as f:
+                content = f.read()
+                lines = content.splitlines()
+        except Exception as e:
+            return FixContext(
+                error=VerificationError(file=file_path, message=f"Could not read: {e}"),
+                file_content="",
+                file_path=file_path,
+                relevant_lines=[],
+                line_start=0,
+                line_end=0,
+            )
+
+        if error_line is None:
+            # No specific line, return first 50 lines
+            relevant = lines[:50]
+            return FixContext(
+                error=VerificationError(file=file_path),
+                file_content=content,
+                file_path=file_path,
+                relevant_lines=relevant,
+                line_start=1,
+                line_end=min(50, len(lines)),
+            )
+
+        # Extract context around error line
+        start = max(0, error_line - cls.CONTEXT_LINES - 1)
+        end = min(len(lines), error_line + cls.CONTEXT_LINES)
+        relevant = lines[start:end]
+
+        return FixContext(
+            error=VerificationError(file=file_path, line=error_line),
+            file_content=content,
+            file_path=file_path,
+            relevant_lines=relevant,
+            line_start=start + 1,
+            line_end=end,
+        )
+
+    @classmethod
+    def generate_fix_suggestion(cls, error: VerificationError) -> str:
+        """Generate a fix suggestion based on error type."""
+        message = error.message.lower()
+
+        # Common error patterns and suggestions
+        suggestions = {
+            "undefined": "Check for typos in variable/function names or missing imports",
+            "not defined": "Add missing import or variable declaration",
+            "cannot find": "Verify the import path or check if the module exists",
+            "type error": "Check type annotations and ensure compatible types",
+            "expected": "Review the expected vs actual values in the assertion",
+            "timeout": "Consider increasing timeout or mocking slow operations",
+            "mock": "Verify mock setup and return values match expected behavior",
+            "import": "Check import statements and module paths",
+            "syntax": "Review syntax near the error location",
+            "indent": "Fix indentation (spaces vs tabs, consistent levels)",
+        }
+
+        for pattern, suggestion in suggestions.items():
+            if pattern in message:
+                return suggestion
+
+        return "Review the error message and related code carefully"
+
+
+# =============================================================================
+# Iteration Manager
+# =============================================================================
+
+class VerificationIterator:
+    """Manage verification iteration loop."""
+
+    STATE_FILE = ".claude/verify-iteration-state.json"
+
+    def __init__(
+        self,
+        project_root: Optional[Path] = None,
+        max_iterations: int = 3,
+        config: Optional[VerificationConfig] = None,
+    ):
+        self.project_root = project_root or Path.cwd()
+        self.max_iterations = max_iterations
+        self.runner = VerificationRunner(
+            project_root=self.project_root,
+            config=config,
+        )
+        self.state = self._load_state() or IterationState(
+            max_iterations=max_iterations,
+            started_at=datetime.now().isoformat(),
+        )
+        self.context_generator = FixContextGenerator()
+
+    def _state_path(self) -> Path:
+        return self.project_root / self.STATE_FILE
+
+    def _load_state(self) -> Optional[IterationState]:
+        """Load iteration state from file."""
+        path = self._state_path()
+        if not path.exists():
+            return None
+
+        try:
+            with open(path) as f:
+                data = json.load(f)
+            return IterationState(
+                current_iteration=data.get("current_iteration", 0),
+                max_iterations=data.get("max_iterations", self.max_iterations),
+                started_at=data.get("started_at"),
+                attempts=data.get("attempts", []),
+                status=data.get("status", "pending"),
+                fixed_errors=data.get("fixed_errors", []),
+            )
+        except Exception:
+            return None
+
+    def _save_state(self) -> None:
+        """Save iteration state to file."""
+        path = self._state_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        data = {
+            "current_iteration": self.state.current_iteration,
+            "max_iterations": self.state.max_iterations,
+            "started_at": self.state.started_at,
+            "status": self.state.status,
+            "attempts": self.state.attempts,
+            "fixed_errors": self.state.fixed_errors,
+            "remaining_errors": [e.to_dict() for e in self.state.remaining_errors],
+        }
+
+        with open(path, "w") as f:
+            json.dump(data, f, indent=2)
+
+    def reset(self) -> None:
+        """Reset iteration state for a fresh run."""
+        self.state = IterationState(
+            max_iterations=self.max_iterations,
+            started_at=datetime.now().isoformat(),
+        )
+        self._save_state()
+
+    def is_complete(self) -> bool:
+        """Check if iteration is complete (passed or max reached)."""
+        return self.state.status in ("passed", "escalated")
+
+    def can_iterate(self) -> bool:
+        """Check if more iterations are allowed."""
+        return self.state.current_iteration < self.state.max_iterations
+
+    def run_verification(
+        self,
+        skip_tests: bool = False,
+        skip_lint: bool = False,
+        skip_types: bool = False,
+    ) -> VerificationResult:
+        """Run verification and update state."""
+        self.state.status = "running"
+
+        result = self.runner.run_all(
+            skip_tests=skip_tests,
+            skip_lint=skip_lint,
+            skip_types=skip_types,
+        )
+
+        self.state.last_result = result
+
+        if result.passed:
+            self.state.status = "passed"
+        else:
+            self.state.remaining_errors = result.errors
+
+        self._save_state()
+        return result
+
+    def get_fix_context(
+        self,
+        result: Optional[VerificationResult] = None,
+    ) -> List[FixContext]:
+        """Generate fix context for all errors."""
+        if result is None:
+            result = self.state.last_result
+
+        if result is None or result.passed:
+            return []
+
+        contexts = []
+        seen_files = set()
+
+        for error in result.errors:
+            if error.file in seen_files:
+                continue
+            seen_files.add(error.file)
+
+            context = self.context_generator.read_file_with_context(
+                file_path=error.file,
+                error_line=error.line,
+                project_root=self.project_root,
+            )
+            context.error = error
+            context.suggestion = self.context_generator.generate_fix_suggestion(error)
+            contexts.append(context)
+
+        return contexts
+
+    def record_attempt(
+        self,
+        result: VerificationResult,
+        fixes_applied: Optional[List[str]] = None,
+    ) -> None:
+        """Record an iteration attempt."""
+        self.state.current_iteration += 1
+
+        attempt = {
+            "iteration": self.state.current_iteration,
+            "timestamp": datetime.now().isoformat(),
+            "passed": result.passed,
+            "error_count": len(result.errors),
+            "fixes_applied": fixes_applied or [],
+        }
+        self.state.attempts.append(attempt)
+
+        if fixes_applied:
+            self.state.fixed_errors.extend(fixes_applied)
+
+        if result.passed:
+            self.state.status = "passed"
+        elif not self.can_iterate():
+            self.state.status = "escalated"
+        else:
+            self.state.status = "failed"
+
+        self._save_state()
+
+    def get_escalation_report(self) -> Dict[str, Any]:
+        """Generate report when max iterations reached."""
+        return {
+            "status": "escalated",
+            "message": f"Could not fix after {self.state.current_iteration} attempts",
+            "iterations": self.state.current_iteration,
+            "remaining_errors": [e.to_dict() for e in self.state.remaining_errors],
+            "fixed_errors": self.state.fixed_errors,
+            "suggestions": [
+                "Review the remaining errors manually",
+                "Check if external dependencies are needed",
+                "Consider if the test requires environment setup",
+                "Look for patterns in the failed fixes",
+            ],
+        }
+
+    def get_progress_summary(self) -> str:
+        """Get human-readable progress summary."""
+        if self.state.status == "passed":
+            if self.state.current_iteration == 0:
+                return "✅ Verification passed on first run"
+            return f"✅ Verification passed after {self.state.current_iteration} iteration(s)"
+
+        if self.state.status == "escalated":
+            return f"⚠️ Verification failed after {self.state.max_iterations} attempts. Manual intervention required."
+
+        if self.state.status == "running":
+            return f"🔄 Running verification (iteration {self.state.current_iteration + 1}/{self.state.max_iterations})"
+
+        remaining = len(self.state.remaining_errors)
+        return f"❌ {remaining} error(s) remaining (iteration {self.state.current_iteration}/{self.state.max_iterations})"
+
+    def cleanup(self) -> None:
+        """Clean up state file after completion."""
+        path = self._state_path()
+        if path.exists():
+            path.unlink()
+
+
+# =============================================================================
+# Prompt Generation for Claude
+# =============================================================================
+
+class FixPromptGenerator:
+    """Generate prompts for Claude to fix verification errors."""
+
+    @classmethod
+    def generate_fix_prompt(
+        cls,
+        contexts: List[FixContext],
+        iteration: int,
+        max_iterations: int,
+    ) -> str:
+        """Generate a prompt for Claude to fix errors."""
+        lines = [
+            f"## Verification Fix Request (Iteration {iteration}/{max_iterations})",
+            "",
+            "The following verification errors need to be fixed:",
+            "",
+        ]
+
+        for i, ctx in enumerate(contexts, 1):
+            error = ctx.error
+            loc = f"{error.file}:{error.line}" if error.line else error.file
+
+            lines.extend([
+                f"### Error {i}: {loc}",
+                f"**Source**: {error.source}",
+                f"**Message**: {error.message}",
+                f"**Suggestion**: {ctx.suggestion}",
+                "",
+                "**Relevant code:**",
+                "```",
+            ])
+
+            for j, line in enumerate(ctx.relevant_lines):
+                line_num = ctx.line_start + j
+                marker = ">>> " if line_num == error.line else "    "
+                lines.append(f"{marker}{line_num}: {line}")
+
+            lines.extend([
+                "```",
+                "",
+            ])
+
+        lines.extend([
+            "## Instructions",
+            "",
+            "1. Read each error and its context carefully",
+            "2. Make minimal, targeted fixes to address each error",
+            "3. Do not change unrelated code",
+            "4. After fixing, verification will re-run automatically",
+            "",
+        ])
+
+        return "\n".join(lines)
+
+
+# =============================================================================
+# CLI Interface
+# =============================================================================
+
+def main():
+    """CLI entry point for verification iteration."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Verification iteration manager")
+    parser.add_argument("command", choices=["run", "status", "reset", "cleanup"])
+    parser.add_argument("--max", type=int, default=3, help="Max iterations")
+    parser.add_argument("--project", type=str, help="Project root path")
+
+    args = parser.parse_args()
+
+    project_root = Path(args.project) if args.project else Path.cwd()
+    iterator = VerificationIterator(
+        project_root=project_root,
+        max_iterations=args.max,
+    )
+
+    if args.command == "run":
+        result = iterator.run_verification()
+        print(iterator.get_progress_summary())
+        if not result.passed:
+            contexts = iterator.get_fix_context(result)
+            prompt = FixPromptGenerator.generate_fix_prompt(
+                contexts,
+                iterator.state.current_iteration + 1,
+                iterator.state.max_iterations,
+            )
+            print("\n" + prompt)
+
+    elif args.command == "status":
+        print(iterator.get_progress_summary())
+        print(json.dumps(iterator.state.to_dict(), indent=2))
+
+    elif args.command == "reset":
+        iterator.reset()
+        print("Iteration state reset")
+
+    elif args.command == "cleanup":
+        iterator.cleanup()
+        print("Iteration state cleaned up")
+
+
+if __name__ == "__main__":
+    main()