anvil-dev-framework 0.1.6 → 0.1.8

package/global/lib/optimization_applier.py

@@ -0,0 +1,582 @@
+"""
+Optimization Applier Service for Anvil Framework.
+
+Provides safe application of token efficiency optimizations with:
+- Automatic backup creation before changes
+- Before/after comparison
+- Commit generation with appropriate messages
+- Tracking of applied optimizations
+- Rollback capability
+
+Usage:
+    from optimization_applier import OptimizationApplier
+
+    applier = OptimizationApplier()
+    result = applier.apply_recommendation(recommendation_id=123)
+"""
+
+import os
+import shutil
+import subprocess
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional, Dict, List, Any
+from enum import Enum
+
+
+class OptimizationType(Enum):
+    """Types of optimizations that can be applied."""
+    REMOVE_UNUSED_PATTERN = "remove_unused_pattern"
+    DEFER_LOADING = "defer_loading"
+    CONSOLIDATE_COMMANDS = "consolidate_commands"
+    REDUCE_CONTEXT = "reduce_context"
+    PRUNE_RARELY_USED = "prune_rarely_used"
+
+
+@dataclass
+class OptimizationResult:
+    """Result of applying an optimization."""
+    success: bool
+    optimization_id: Optional[int] = None
+    recommendation_id: Optional[int] = None
+    optimization_type: Optional[OptimizationType] = None
+    files_modified: List[str] = field(default_factory=list)
+    backup_paths: List[str] = field(default_factory=list)
+    tokens_before: int = 0
+    tokens_after: int = 0
+    savings: int = 0
+    error_message: Optional[str] = None
+    commit_hash: Optional[str] = None
+    applied_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+@dataclass
+class AppliedOptimization:
+    """Record of an applied optimization for tracking."""
+    id: int
+    recommendation_id: int
+    optimization_type: str
+    description: str
+    files_modified: List[str]
+    tokens_saved: int
+    applied_at: datetime
+    commit_hash: Optional[str]
+    backup_paths: List[str] = field(default_factory=list)
+    reverted: bool = False
+    reverted_at: Optional[datetime] = None
+
+
+class OptimizationApplier:
+    """
+    Service for safely applying token efficiency optimizations.
+
+    Features:
+    - Creates backups before modifying files
+    - Tracks all applied optimizations
+    - Supports rollback of problematic optimizations
+    - Generates appropriate commit messages
+    """
+
+    BACKUP_DIR = ".claude/backups/optimizations"
+
+    def __init__(
+        self,
+        project_root: Optional[Path] = None,
+        auto_commit: bool = False
+    ):
+        """
+        Initialize the optimization applier.
+
+        Args:
+            project_root: Root directory of the project
+            auto_commit: Whether to automatically commit changes
+        """
+        self.project_root = project_root or Path.cwd()
+        self.auto_commit = auto_commit
+        self._applied_optimizations: List[AppliedOptimization] = []
+        self._next_id = 1
+
+        # Ensure backup directory exists
+        self.backup_dir = self.project_root / self.BACKUP_DIR
+        self.backup_dir.mkdir(parents=True, exist_ok=True)
+
+        # Try to import token_metrics for integration
+        try:
+            from token_metrics import TokenMetrics
+            self._metrics = TokenMetrics()
+        except ImportError:
+            self._metrics = None
+
+    def apply_recommendation(
+        self,
+        recommendation_id: int,
+        recommendation_type: str,
+        description: str,
+        target_files: List[str],
+        changes: Dict[str, Any],
+        estimated_savings: int
+    ) -> OptimizationResult:
+        """
+        Apply a recommendation from the efficiency analysis.
+
+        Args:
+            recommendation_id: ID of the recommendation to apply
+            recommendation_type: Type of optimization
+            description: Human-readable description
+            target_files: Files to be modified
+            changes: Dict describing the changes to make
+            estimated_savings: Estimated token savings
+
+        Returns:
+            OptimizationResult with details of the application
+        """
+        result = OptimizationResult(
+            success=False,
+            recommendation_id=recommendation_id
+        )
+
+        try:
+            # Parse optimization type
+            opt_type = OptimizationType(recommendation_type)
+            result.optimization_type = opt_type
+        except ValueError:
+            result.error_message = f"Unknown optimization type: {recommendation_type}"
+            return result
+
+        # Step 1: Create backups
+        backup_paths = []
+        for file_path in target_files:
+            full_path = self.project_root / file_path
+            if full_path.exists():
+                backup_path = self._create_backup(full_path)
+                if backup_path:
+                    backup_paths.append(str(backup_path))
+
+        result.backup_paths = backup_paths
+
+        # Step 2: Measure tokens before (if metrics available)
+        if self._metrics:
+            result.tokens_before = self._estimate_file_tokens(target_files)
+
+        # Step 3: Apply the optimization
+        try:
+            modified_files = self._apply_changes(opt_type, target_files, changes)
+            result.files_modified = modified_files
+        except Exception as e:
+            result.error_message = f"Failed to apply changes: {str(e)}"
+            self._restore_backups(backup_paths)
+            return result
+
+        # Step 4: Measure tokens after
+        if self._metrics:
+            result.tokens_after = self._estimate_file_tokens(target_files)
+            result.savings = result.tokens_before - result.tokens_after
+
+        # Step 5: Record the optimization
+        optimization_record = AppliedOptimization(
+            id=self._next_id,
+            recommendation_id=recommendation_id,
+            optimization_type=recommendation_type,
+            description=description,
+            files_modified=modified_files,
+            tokens_saved=result.savings or estimated_savings,
+            applied_at=datetime.now(timezone.utc),
+            commit_hash=None,
+            backup_paths=backup_paths
+        )
+        self._applied_optimizations.append(optimization_record)
+        result.optimization_id = self._next_id
+        self._next_id += 1
+
+        # Step 6: Auto-commit if enabled
+        if self.auto_commit and modified_files:
+            commit_hash = self._create_commit(
+                modified_files,
+                f"refactor: apply token optimization - {description}"
+            )
+            result.commit_hash = commit_hash
+            optimization_record.commit_hash = commit_hash
+
+        result.success = True
+        return result
+
+    def _create_backup(self, file_path: Path) -> Optional[Path]:
+        """
+        Create a backup of a file before modification.
+
+        Args:
+            file_path: Path to the file to backup
+
+        Returns:
+            Path to the backup file, or None if backup failed
+        """
+        if not file_path.exists():
+            return None
+
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_name = f"{file_path.name}.{timestamp}.bak"
+        backup_path = self.backup_dir / backup_name
+
+        try:
+            shutil.copy2(file_path, backup_path)
+            return backup_path
+        except Exception:
+            return None
+
+    def _restore_backups(self, backup_paths: List[str], original_paths: Optional[List[str]] = None) -> bool:
+        """
+        Restore files from backups.
+
+        Args:
+            backup_paths: List of backup file paths
+            original_paths: Optional list of original file paths (parallel to backup_paths)
+
+        Returns:
+            True if all restorations succeeded
+        """
+        success = True
+        for i, backup_path in enumerate(backup_paths):
+            backup = Path(backup_path)
+            if backup.exists():
+                # If we have the original path mapping, use it
+                if original_paths and i < len(original_paths):
+                    try:
+                        shutil.copy2(backup, self.project_root / original_paths[i])
+                        continue
+                    except Exception:
+                        success = False
+                        continue
+
+                # Extract original filename (remove timestamp and .bak)
+                # Format: filename.ext.YYYYMMDD_HHMMSS.bak -> filename.ext
+                parts = backup.name.rsplit(".", 2)  # Split into [name.ext, timestamp, bak]
+                if len(parts) >= 3:
+                    original_name = parts[0]  # This preserves the full filename with extension
+                    # Find the original file location
+                    try:
+                        # For now, assume it's in project root or .claude
+                        for possible_location in [
+                            self.project_root / original_name,
+                            self.project_root / ".claude" / original_name
+                        ]:
+                            if possible_location.exists():
+                                shutil.copy2(backup, possible_location)
+                                break
+                    except Exception:
+                        success = False
+
+        return success
+
+    def _apply_changes(
+        self,
+        opt_type: OptimizationType,
+        target_files: List[str],
+        changes: Dict[str, Any]
+    ) -> List[str]:
+        """
+        Apply changes based on optimization type.
+
+        Args:
+            opt_type: Type of optimization
+            target_files: Files to modify
+            changes: Dict describing the changes
+
+        Returns:
+            List of actually modified files
+        """
+        modified = []
+
+        if opt_type == OptimizationType.REMOVE_UNUSED_PATTERN:
+            modified = self._remove_pattern(target_files, changes)
+        elif opt_type == OptimizationType.DEFER_LOADING:
+            modified = self._defer_loading(target_files, changes)
+        elif opt_type == OptimizationType.REDUCE_CONTEXT:
+            modified = self._reduce_context(target_files, changes)
+        elif opt_type == OptimizationType.PRUNE_RARELY_USED:
+            modified = self._prune_rarely_used(target_files, changes)
+
+        return modified
+
+    def _remove_pattern(
+        self,
+        target_files: List[str],
+        changes: Dict[str, Any]
+    ) -> List[str]:
+        """Remove unused pattern from files."""
+        modified = []
+        pattern_to_remove = changes.get("pattern", "")
+
+        for file_path in target_files:
+            full_path = self.project_root / file_path
+            if not full_path.exists():
+                continue
+
+            content = full_path.read_text()
+            if pattern_to_remove in content:
+                new_content = content.replace(pattern_to_remove, "")
+                full_path.write_text(new_content)
+                modified.append(file_path)
+
+        return modified
+
+    def _defer_loading(
+        self,
+        target_files: List[str],
+        changes: Dict[str, Any]
+    ) -> List[str]:
+        """Convert eager loading to deferred loading."""
+        modified = []
+        section_name = changes.get("section", "")
+        trigger_keywords = changes.get("triggers", [])
+
+        # This would modify CLAUDE.md to use trigger tables
+        # Implementation depends on specific format
+
+        return modified
+
+    def _reduce_context(
+        self,
+        target_files: List[str],
+        changes: Dict[str, Any]
+    ) -> List[str]:
+        """Reduce context size by removing or condensing sections."""
+        modified = []
+        sections_to_remove = changes.get("sections", [])
+
+        for file_path in target_files:
+            full_path = self.project_root / file_path
+            if not full_path.exists():
+                continue
+
+            content = full_path.read_text()
+            original_content = content
+
+            for section in sections_to_remove:
+                # Simple section removal by header
+                if f"## {section}" in content:
+                    # Find section boundaries and remove
+                    lines = content.split("\n")
+                    new_lines = []
+                    skip_until_next_section = False
+
+                    for line in lines:
+                        if line.startswith(f"## {section}"):
+                            skip_until_next_section = True
+                            continue
+                        if skip_until_next_section and line.startswith("## "):
+                            skip_until_next_section = False
+                        if not skip_until_next_section:
+                            new_lines.append(line)
+
+                    content = "\n".join(new_lines)
+
+            if content != original_content:
+                full_path.write_text(content)
+                modified.append(file_path)
+
+        return modified
+
+    def _prune_rarely_used(
+        self,
+        target_files: List[str],
+        changes: Dict[str, Any]
+    ) -> List[str]:
+        """Prune rarely-used components."""
+        modified = []
+        components = changes.get("components", [])
+
+        # Implementation would remove specific component references
+        # from configuration files
+
+        return modified
+
+    def _estimate_file_tokens(self, file_paths: List[str]) -> int:
+        """
+        Estimate tokens in a list of files.
+
+        Args:
+            file_paths: List of file paths
+
+        Returns:
+            Estimated total tokens
+        """
+        total = 0
+        for file_path in file_paths:
+            full_path = self.project_root / file_path
+            if full_path.exists():
+                content = full_path.read_text()
+                # Rough estimate: 4 characters per token
+                total += len(content) // 4
+
+        return total
+
+    def _create_commit(self, files: List[str], message: str) -> Optional[str]:
+        """
+        Create a git commit for the changes.
+
+        Args:
+            files: Files to include in the commit
+            message: Commit message
+
+        Returns:
+            Commit hash if successful, None otherwise
+        """
+        try:
+            # Stage files
+            for f in files:
+                subprocess.run(
+                    ["git", "add", f],
+                    cwd=self.project_root,
+                    check=True,
+                    capture_output=True
+                )
+
+            # Commit
+            result = subprocess.run(
+                ["git", "commit", "-m", message],
+                cwd=self.project_root,
+                check=True,
+                capture_output=True,
+                text=True
+            )
+
+            # Get commit hash
+            hash_result = subprocess.run(
+                ["git", "rev-parse", "HEAD"],
+                cwd=self.project_root,
+                check=True,
+                capture_output=True,
+                text=True
+            )
+
+            return hash_result.stdout.strip()[:8]
+
+        except subprocess.CalledProcessError:
+            return None
+
+    def rollback_optimization(self, optimization_id: int) -> bool:
+        """
+        Rollback a previously applied optimization.
+
+        Args:
+            optimization_id: ID of the optimization to rollback
+
+        Returns:
+            True if rollback was successful
+        """
+        # Find the optimization
+        opt = next(
+            (o for o in self._applied_optimizations if o.id == optimization_id),
+            None
+        )
+
+        if not opt:
+            return False
+
+        if opt.reverted:
+            return False  # Already reverted
+
+        # If there's a commit hash, revert the commit
+        if opt.commit_hash:
+            try:
+                subprocess.run(
+                    ["git", "revert", "--no-commit", opt.commit_hash],
+                    cwd=self.project_root,
+                    check=True,
+                    capture_output=True
+                )
+                subprocess.run(
+                    ["git", "commit", "-m", f"revert: rollback optimization {optimization_id}"],
+                    cwd=self.project_root,
+                    check=True,
+                    capture_output=True
+                )
+            except subprocess.CalledProcessError:
+                return False
+        elif opt.backup_paths:
+            # No commit hash, restore from backups
+            if not self._restore_backups(opt.backup_paths, opt.files_modified):
+                return False
+
+        opt.reverted = True
+        opt.reverted_at = datetime.now(timezone.utc)
+        return True
+
+    def get_applied_optimizations(
+        self,
+        include_reverted: bool = False
+    ) -> List[AppliedOptimization]:
+        """
+        Get list of applied optimizations.
+
+        Args:
+            include_reverted: Whether to include reverted optimizations
+
+        Returns:
+            List of AppliedOptimization records
+        """
+        if include_reverted:
+            return self._applied_optimizations.copy()
+
+        return [o for o in self._applied_optimizations if not o.reverted]
+
+    def get_total_savings(self) -> Dict[str, int]:
+        """
+        Get total token savings from all active optimizations.
+
+        Returns:
+            Dict with total savings and count
+        """
+        active = [o for o in self._applied_optimizations if not o.reverted]
+
+        return {
+            "total_tokens_saved": sum(o.tokens_saved for o in active),
+            "optimizations_count": len(active),
+            "reverted_count": len(self._applied_optimizations) - len(active)
+        }
+
+    def generate_impact_report(self) -> str:
+        """
+        Generate a report of optimization impact.
+
+        Returns:
+            Formatted markdown report
+        """
+        active = [o for o in self._applied_optimizations if not o.reverted]
+        reverted = [o for o in self._applied_optimizations if o.reverted]
+
+        lines = [
+            "## Optimization Impact Report",
+            "",
+            f"**Active Optimizations**: {len(active)}",
+            f"**Reverted Optimizations**: {len(reverted)}",
+            f"**Total Tokens Saved**: {sum(o.tokens_saved for o in active):,}",
+            "",
+            "### Active Optimizations",
+            ""
+        ]
+
+        if active:
+            lines.append("| ID | Type | Description | Tokens Saved | Applied |")
+            lines.append("|-----|------|-------------|--------------|---------|")
+            for opt in active:
+                applied = opt.applied_at.strftime("%Y-%m-%d")
+                lines.append(
+                    f"| {opt.id} | {opt.optimization_type} | "
+                    f"{opt.description[:30]}... | {opt.tokens_saved:,} | {applied} |"
+                )
+        else:
+            lines.append("*No active optimizations*")
+
+        if reverted:
+            lines.extend([
+                "",
+                "### Reverted Optimizations",
+                ""
+            ])
+            for opt in reverted:
+                reverted_date = opt.reverted_at.strftime("%Y-%m-%d") if opt.reverted_at else "?"
+                lines.append(f"- [{opt.id}] {opt.description} (reverted {reverted_date})")
+
+        return "\n".join(lines)

package/global/lib/orient_fast.py

@@ -97,7 +97,12 @@ def check_linear_yaml() -> Optional[Dict[str, str]]:
 
 def check_git_state() -> Dict[str, Any]:
     """Get git status, branch, and recent commits."""
-    result = {"branch": "unknown", "clean": False, "recent_commits": []}
+    result: Dict[str, Any] = {
+        "branch": "unknown",
+        "clean": False,
+        "recent_commits": [],
+        "uncommitted_files": [],
+    }
 
     # Get branch
     branch_out, ok = run_command("git branch --show-current")
@@ -108,12 +113,21 @@ def check_git_state() -> Dict[str, Any]:
     status_out, ok = run_command("git status --porcelain")
     if ok:
         result["clean"] = len(status_out.strip()) == 0
+        if not result["clean"]:
+            # Capture uncommitted file list for warning
+            result["uncommitted_files"] = [
+                line.strip() for line in status_out.split("\n") if line.strip()
+            ][:5]  # Limit to 5 files
 
     # Get recent commits
     log_out, ok = run_command("git log --oneline -5")
     if ok and log_out:
         result["recent_commits"] = log_out.split("\n")[:5]
 
+    # Add compaction warning if uncommitted changes detected
+    if not result["clean"]:
+        result["warning"] = "Uncommitted changes detected - verify before proceeding"
+
     return result
 
 
@@ -398,6 +412,15 @@ def format_output(result: OrientResult, as_json: bool = False) -> str:
     clean_str = "clean" if git.get("clean") else "uncommitted changes"
     lines.append(f"**Git**: {git.get('branch', '?')} ({clean_str})")
 
+    # Post-compaction verification warning
+    if not git.get("clean"):
+        lines.append("\n**⚠️ Uncommitted Changes Detected**")
+        lines.append("Verify these are expected before proceeding with new work:")
+        for f in git.get("uncommitted_files", [])[:5]:
+            lines.append(f"  - {f}")
+        if git.get("warning"):
+            lines.append(f"_Note: {git.get('warning')}_\n")
+
     # Active agents
     if result.active_agents:
         lines.append(f"**Active Agents**: {len(result.active_agents)}")