attune-ai 2.0.0__py3-none-any.whl

attune_llm/pattern_resolver.py

@@ -0,0 +1,272 @@
+"""Pattern Resolution Module
+
+Provides CLI workflow for resolving investigating bug patterns
+by adding root cause, fix, and resolution time.
+
+Usage:
+    from attune_llm.pattern_resolver import PatternResolver
+
+    resolver = PatternResolver("./patterns")
+    resolver.resolve_bug(
+        bug_id="bug_20251212_3c5b9951",
+        root_cause="Missing null check on API response",
+        fix_applied="Added optional chaining operator",
+        fix_code="data?.items ?? []",
+        resolution_time_minutes=15,
+        resolved_by="@developer"
+    )
+
+CLI:
+    empathy patterns resolve bug_20251212_3c5b9951 \\
+        --root-cause "Missing null check" \\
+        --fix "Added optional chaining" \\
+        --fix-code "data?.items ?? []" \\
+        --time 15 \\
+        --resolved-by "@developer"
+
+Author: Empathy Framework Team
+Version: 2.1.3
+License: Fair Source 0.9
+"""
+
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class PatternResolver:
+    """Resolves investigating bug patterns with root cause and fix information.
+
+    Searches through pattern directories to find matching bug IDs
+    and updates them with resolution details.
+    """
+
+    def __init__(self, patterns_dir: str = "./patterns"):
+        self.patterns_dir = Path(patterns_dir)
+        self._debugging_dirs = ["debugging", "debugging_demo", "repo_test/debugging"]
+
+    def find_bug(self, bug_id: str) -> tuple[Path | None, dict[str, Any] | None]:
+        """Find a bug pattern by ID.
+
+        Args:
+            bug_id: The bug ID to find (e.g., "bug_20251212_3c5b9951")
+
+        Returns:
+            Tuple of (file_path, pattern_data) or (None, None) if not found
+
+        """
+        for debug_dir in self._debugging_dirs:
+            dir_path = self.patterns_dir / debug_dir
+            if not dir_path.exists():
+                continue
+
+            # Check for exact filename match
+            pattern_file = dir_path / f"{bug_id}.json"
+            if pattern_file.exists():
+                try:
+                    with open(pattern_file, encoding="utf-8") as f:
+                        return pattern_file, json.load(f)
+                except (json.JSONDecodeError, OSError) as e:
+                    logger.warning("Failed to load %s: %s", pattern_file, e)
+
+            # Search all bug files for matching bug_id field
+            for json_file in dir_path.glob("bug_*.json"):
+                try:
+                    with open(json_file, encoding="utf-8") as f:
+                        data = json.load(f)
+                        if data.get("bug_id") == bug_id:
+                            return json_file, data
+                except (json.JSONDecodeError, OSError):
+                    continue
+
+        return None, None
+
+    def list_investigating(self) -> list[dict[str, Any]]:
+        """List all bugs with status 'investigating'.
+
+        Returns:
+            List of bug patterns that need resolution
+
+        """
+        investigating = []
+
+        for debug_dir in self._debugging_dirs:
+            dir_path = self.patterns_dir / debug_dir
+            if not dir_path.exists():
+                continue
+
+            for json_file in dir_path.glob("bug_*.json"):
+                try:
+                    with open(json_file, encoding="utf-8") as f:
+                        data = json.load(f)
+                        if data.get("status") == "investigating":
+                            data["_file_path"] = str(json_file)
+                            investigating.append(data)
+                except (json.JSONDecodeError, OSError):
+                    continue
+
+        return investigating
+
+    def resolve_bug(
+        self,
+        bug_id: str,
+        root_cause: str,
+        fix_applied: str,
+        fix_code: str | None = None,
+        resolution_time_minutes: int = 0,
+        resolved_by: str = "@developer",
+    ) -> bool:
+        """Resolve a bug pattern by updating its fields.
+
+        Args:
+            bug_id: The bug ID to resolve
+            root_cause: Description of the root cause
+            fix_applied: Description of the fix applied
+            fix_code: Optional code snippet of the fix
+            resolution_time_minutes: Time taken to resolve
+            resolved_by: Who resolved the bug
+
+        Returns:
+            True if successfully resolved, False otherwise
+
+        """
+        file_path, pattern = self.find_bug(bug_id)
+
+        if not file_path or not pattern:
+            logger.error("Bug not found: %s", bug_id)
+            return False
+
+        # Update pattern with resolution details
+        pattern["root_cause"] = root_cause
+        pattern["fix_applied"] = fix_applied
+        pattern["status"] = "resolved"
+        pattern["resolved_by"] = resolved_by
+        pattern["resolution_time_minutes"] = resolution_time_minutes
+        pattern["resolved_at"] = datetime.now().isoformat()
+
+        if fix_code:
+            pattern["fix_code"] = fix_code
+
+        # Write updated pattern back to file
+        try:
+            with open(file_path, "w", encoding="utf-8") as f:
+                json.dump(pattern, f, indent=2, default=str)
+
+            logger.info("Resolved bug %s in %s", bug_id, file_path)
+            return True
+        except OSError as e:
+            logger.error("Failed to write %s: %s", file_path, e)
+            return False
+
+    def regenerate_summary(self) -> bool:
+        """Regenerate the patterns_summary.md file.
+
+        Returns:
+            True if successful, False otherwise
+
+        """
+        try:
+            from attune_llm.pattern_summary import PatternSummaryGenerator
+
+            generator = PatternSummaryGenerator(str(self.patterns_dir))
+            generator.load_all_patterns()
+            generator.write_to_file("./.claude/patterns_summary.md")
+            logger.info("Regenerated patterns_summary.md")
+            return True
+        except Exception as e:
+            logger.error("Failed to regenerate summary: %s", e)
+            return False
+
+
+def cmd_patterns_resolve(args):
+    """CLI handler for patterns resolve command."""
+    resolver = PatternResolver(args.patterns_dir)
+
+    # If no bug_id, list investigating bugs
+    if not args.bug_id:
+        investigating = resolver.list_investigating()
+        if not investigating:
+            print("No bugs with 'investigating' status found.")
+            return
+
+        print(f"\nBugs needing resolution ({len(investigating)}):\n")
+        for bug in investigating:
+            print(f"  {bug.get('bug_id', 'unknown')}")
+            print(f"    Type: {bug.get('error_type', 'unknown')}")
+            print(f"    File: {bug.get('file_path', 'unknown')}")
+            print(f"    Message: {bug.get('error_message', 'N/A')[:60]}...")
+            print()
+        return
+
+    # Resolve the specified bug
+    success = resolver.resolve_bug(
+        bug_id=args.bug_id,
+        root_cause=args.root_cause,
+        fix_applied=args.fix,
+        fix_code=args.fix_code,
+        resolution_time_minutes=args.time or 0,
+        resolved_by=args.resolved_by or "@developer",
+    )
+
+    if success:
+        print(f"✓ Resolved: {args.bug_id}")
+
+        # Regenerate summary if requested
+        if not args.no_regenerate:
+            if resolver.regenerate_summary():
+                print("✓ Regenerated patterns_summary.md")
+            else:
+                print("⚠ Failed to regenerate summary")
+    else:
+        print(f"✗ Failed to resolve: {args.bug_id}")
+        print("  Use 'empathy patterns resolve' (no args) to list investigating bugs")
+
+
+def main():
+    """CLI entry point for pattern resolution."""
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Resolve investigating bug patterns",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # List all investigating bugs
+  python -m attune_llm.pattern_resolver
+
+  # Resolve a specific bug
+  python -m attune_llm.pattern_resolver bug_20251212_3c5b9951 \\
+      --root-cause "Missing null check" \\
+      --fix "Added optional chaining" \\
+      --fix-code "data?.items ?? []" \\
+      --time 15
+        """,
+    )
+
+    parser.add_argument("bug_id", nargs="?", help="Bug ID to resolve (omit to list investigating)")
+    parser.add_argument("--root-cause", help="Description of the root cause")
+    parser.add_argument("--fix", help="Description of the fix applied")
+    parser.add_argument("--fix-code", help="Code snippet of the fix")
+    parser.add_argument("--time", type=int, help="Resolution time in minutes")
+    parser.add_argument("--resolved-by", default="@developer", help="Who resolved it")
+    parser.add_argument("--patterns-dir", default="./patterns", help="Path to patterns directory")
+    parser.add_argument("--no-regenerate", action="store_true", help="Skip regenerating summary")
+
+    args = parser.parse_args()
+
+    # Configure logging
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+
+    # Validate required args if resolving
+    if args.bug_id and not (args.root_cause and args.fix):
+        parser.error("--root-cause and --fix are required when resolving a bug")
+
+    cmd_patterns_resolve(args)
+
+
+if __name__ == "__main__":
+    main()

attune_llm/pattern_summary.py

@@ -0,0 +1,350 @@
+"""Pattern Summary Generator
+
+Generates a markdown summary of stored patterns for inclusion in CLAUDE.md.
+This enables Claude Code sessions to have context about historical patterns.
+
+Usage:
+    from attune_llm.pattern_summary import PatternSummaryGenerator
+
+    generator = PatternSummaryGenerator("./patterns")
+    summary = generator.generate_markdown()
+    generator.write_to_file("./.claude/patterns_summary.md")
+
+CLI:
+    python -m attune_llm.pattern_summary --patterns-dir ./patterns --output patterns.md
+
+Author: Empathy Framework Team
+Version: 2.1.2
+License: Fair Source 0.9
+"""
+
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class PatternSummaryGenerator:
+    """Generates markdown summaries of stored patterns.
+
+    Scans the patterns directory and produces a concise summary
+    suitable for inclusion in CLAUDE.md via @import.
+    """
+
+    def __init__(self, patterns_dir: str = "./patterns"):
+        self.patterns_dir = Path(patterns_dir)
+        self._bug_patterns: list[dict[str, Any]] = []
+        self._security_decisions: list[dict[str, Any]] = []
+        self._tech_debt_history: list[dict[str, Any]] = []
+
+    def load_all_patterns(self) -> None:
+        """Load all patterns from storage."""
+        self._bug_patterns = self._load_bug_patterns()
+        self._security_decisions = self._load_security_decisions()
+        self._tech_debt_history = self._load_tech_debt_history()
+
+        logger.info(
+            "Patterns loaded: %d bugs, %d security decisions, %d debt snapshots",
+            len(self._bug_patterns),
+            len(self._security_decisions),
+            len(self._tech_debt_history),
+        )
+
+    def _load_bug_patterns(self) -> list[dict[str, Any]]:
+        """Load bug patterns from debugging directories."""
+        patterns = []
+
+        # Check all debugging directories
+        for debug_dir in ["debugging", "debugging_demo", "repo_test/debugging"]:
+            dir_path = self.patterns_dir / debug_dir
+            if not dir_path.exists():
+                continue
+
+            for json_file in dir_path.glob("bug_*.json"):
+                try:
+                    with open(json_file, encoding="utf-8") as f:
+                        pattern = json.load(f)
+                        pattern["_source_dir"] = debug_dir
+                        patterns.append(pattern)
+                except (json.JSONDecodeError, OSError) as e:
+                    logger.warning("Bug pattern load failed: %s - %s", json_file, e)
+
+        return patterns
+
+    def _load_security_decisions(self) -> list[dict[str, Any]]:
+        """Load security team decisions."""
+        decisions = []
+
+        # Check all security directories
+        for sec_dir in ["security", "security_demo", "repo_test/security"]:
+            decisions_file = self.patterns_dir / sec_dir / "team_decisions.json"
+            if not decisions_file.exists():
+                continue
+
+            try:
+                with open(decisions_file, encoding="utf-8") as f:
+                    data = json.load(f)
+                    for decision in data.get("decisions", []):
+                        decision["_source_dir"] = sec_dir
+                        decisions.append(decision)
+            except (json.JSONDecodeError, OSError) as e:
+                logger.warning("Security decisions load failed: %s - %s", decisions_file, e)
+
+        return decisions
+
+    def _load_tech_debt_history(self) -> list[dict[str, Any]]:
+        """Load tech debt history snapshots."""
+        snapshots = []
+
+        # Check all tech_debt directories
+        for debt_dir in ["tech_debt", "tech_debt_demo", "repo_test/tech_debt"]:
+            history_file = self.patterns_dir / debt_dir / "debt_history.json"
+            if not history_file.exists():
+                continue
+
+            try:
+                with open(history_file, encoding="utf-8") as f:
+                    data = json.load(f)
+                    for snapshot in data.get("snapshots", []):
+                        snapshot["_source_dir"] = debt_dir
+                        snapshots.append(snapshot)
+            except (json.JSONDecodeError, OSError) as e:
+                logger.warning("Debt history load failed: %s - %s", history_file, e)
+
+        return snapshots
+
+    def generate_markdown(self) -> str:
+        """Generate a markdown summary of all patterns.
+
+        Returns:
+            Markdown string suitable for CLAUDE.md inclusion
+
+        """
+        if not any([self._bug_patterns, self._security_decisions, self._tech_debt_history]):
+            self.load_all_patterns()
+
+        lines = [
+            "# Pattern Library Summary",
+            f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}",
+            "",
+            "This summary is auto-generated from stored patterns.",
+            "Use these patterns to inform debugging, security, and code quality decisions.",
+            "",
+        ]
+
+        # Bug Patterns Section
+        lines.extend(self._generate_bug_section())
+
+        # Security Decisions Section
+        lines.extend(self._generate_security_section())
+
+        # Tech Debt Section
+        lines.extend(self._generate_debt_section())
+
+        # Usage hints
+        lines.extend(
+            [
+                "---",
+                "",
+                "## How to Use These Patterns",
+                "",
+                "- **Debugging**: Check if similar bugs have been resolved",
+                "- **Security**: Check team decisions for false positives",
+                "- **Tech Debt**: Consider debt trajectory when planning refactoring work",
+                "",
+            ],
+        )
+
+        return "\n".join(lines)
+
+    def _generate_bug_section(self) -> list[str]:
+        """Generate bug patterns section."""
+        lines = [
+            f"## Bug Patterns ({len(self._bug_patterns)} stored)",
+            "",
+        ]
+
+        if not self._bug_patterns:
+            lines.append("*No bug patterns stored yet.*")
+            lines.append("")
+            return lines
+
+        # Group by error type
+        by_type: dict[str, list[dict]] = {}
+        for bug in self._bug_patterns:
+            error_type = bug.get("error_type", "unknown")
+            by_type.setdefault(error_type, []).append(bug)
+
+        for error_type, bugs in sorted(by_type.items()):
+            lines.append(f"### {error_type} ({len(bugs)} occurrences)")
+            lines.append("")
+
+            # Show most recent or notable
+            for bug in bugs[:3]:  # Limit to 3 per type
+                root_cause = bug.get("root_cause", "Unknown")
+                fix = bug.get("fix_applied", "N/A")
+                time_mins = bug.get("resolution_time_minutes", 0)
+                status = bug.get("status", "unknown")
+
+                lines.append(f"- **{bug.get('bug_id', 'unknown')}** ({status})")
+                lines.append(f"  - Root cause: {root_cause}")
+                lines.append(f"  - Fix: {fix}")
+                if time_mins:
+                    lines.append(f"  - Resolution time: {time_mins} min")
+                lines.append("")
+
+        return lines
+
+    def _generate_security_section(self) -> list[str]:
+        """Generate security decisions section."""
+        lines = [
+            f"## Security Decisions ({len(self._security_decisions)} stored)",
+            "",
+        ]
+
+        if not self._security_decisions:
+            lines.append("*No security decisions stored yet.*")
+            lines.append("")
+            return lines
+
+        # Group by decision type
+        by_decision: dict[str, list[dict]] = {}
+        for decision in self._security_decisions:
+            decision_type = decision.get("decision", "unknown")
+            by_decision.setdefault(decision_type, []).append(decision)
+
+        for decision_type, decisions in sorted(by_decision.items()):
+            lines.append(f"### {decision_type.upper()} ({len(decisions)})")
+            lines.append("")
+
+            for d in decisions:
+                finding = d.get("finding_hash", "unknown")
+                reason = d.get("reason", "N/A")
+                decided_by = d.get("decided_by", "unknown")
+
+                lines.append(f"- **{finding}**: {reason}")
+                lines.append(f"  - Decided by: {decided_by}")
+                lines.append("")
+
+        return lines
+
+    def _generate_debt_section(self) -> list[str]:
+        """Generate tech debt section with trajectory analysis."""
+        lines = [
+            f"## Tech Debt Trajectory ({len(self._tech_debt_history)} snapshots)",
+            "",
+        ]
+
+        if not self._tech_debt_history:
+            lines.append("*No tech debt history stored yet.*")
+            lines.append("")
+            return lines
+
+        # Sort by date
+        sorted_snapshots = sorted(
+            self._tech_debt_history,
+            key=lambda s: s.get("date", ""),
+            reverse=True,
+        )
+
+        # Current state (most recent)
+        current = sorted_snapshots[0]
+        lines.append(f"### Current State ({current.get('date', 'unknown')[:10]})")
+        lines.append("")
+        lines.append(f"- Total items: {current.get('total_items', 0)}")
+
+        if by_type := current.get("by_type"):
+            type_summary = ", ".join(f"{k}: {v}" for k, v in sorted(by_type.items()))
+            lines.append(f"- By type: {type_summary}")
+
+        if by_severity := current.get("by_severity"):
+            sev_summary = ", ".join(f"{k}: {v}" for k, v in sorted(by_severity.items()))
+            lines.append(f"- By severity: {sev_summary}")
+
+        if hotspots := current.get("hotspots"):
+            lines.append(f"- Hotspots: {', '.join(hotspots[:3])}")
+
+        lines.append("")
+
+        # Trajectory analysis
+        if len(sorted_snapshots) >= 2:
+            oldest = sorted_snapshots[-1]
+            current_total = current.get("total_items", 0)
+            oldest_total = oldest.get("total_items", 0)
+
+            if current_total < oldest_total:
+                trend = "DECREASING"
+                change = oldest_total - current_total
+            elif current_total > oldest_total:
+                trend = "INCREASING"
+                change = current_total - oldest_total
+            else:
+                trend = "STABLE"
+                change = 0
+
+            lines.append(f"### Trajectory: {trend}")
+            lines.append("")
+            lines.append(f"- Change: {change} items over {len(sorted_snapshots)} snapshots")
+            lines.append(f"- Oldest snapshot: {oldest_total} items ({oldest.get('date', '')[:10]})")
+            lines.append(f"- Current: {current_total} items")
+            lines.append("")
+
+        return lines
+
+    def write_to_file(self, output_path: str) -> None:
+        """Write the markdown summary to a file.
+
+        Args:
+            output_path: Path to write the summary
+
+        """
+        output = Path(output_path)
+        output.parent.mkdir(parents=True, exist_ok=True)
+
+        content = self.generate_markdown()
+        output.write_text(content, encoding="utf-8")
+
+        logger.info("Pattern summary written to %s (%d bytes)", output, len(content))
+
+
+def main():
+    """CLI entry point for pattern summary generation."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Generate pattern summary for CLAUDE.md")
+    parser.add_argument(
+        "--patterns-dir",
+        default="./patterns",
+        help="Path to patterns directory (default: ./patterns)",
+    )
+    parser.add_argument(
+        "--output",
+        default="./.claude/patterns_summary.md",
+        help="Output file path (default: ./.claude/patterns_summary.md)",
+    )
+    parser.add_argument(
+        "--print",
+        action="store_true",
+        help="Print to stdout instead of writing to file",
+    )
+
+    args = parser.parse_args()
+
+    # Configure logging
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+
+    generator = PatternSummaryGenerator(args.patterns_dir)
+    generator.load_all_patterns()
+
+    if args.print:
+        print(generator.generate_markdown())
+    else:
+        generator.write_to_file(args.output)
+        print(f"Pattern summary written to: {args.output}")
+
+
+if __name__ == "__main__":
+    main()