anvil-dev-framework 0.1.7 → 0.1.9

package/global/tests/test_command_tracker.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""
+Unit tests for command_tracker.py (ANV-293)
+
+Run with: python3 -m pytest global/tests/test_command_tracker.py -v
+"""
+
+import sys
+import os
+import tempfile
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent / "lib"))
+
+from token_metrics import TokenMetrics
+from command_tracker import (
+    track_command_load,
+    get_command_token_estimate,
+    _find_command_content,
+)
+
+
+class TestCommandTracker:
+    """Tests for command tracking functionality."""
+
+    def setup_method(self):
+        """Create a fresh metrics instance with temp database."""
+        self.temp_dir = tempfile.mkdtemp()
+        self.db_path = Path(self.temp_dir) / "test_metrics.db"
+
+        # Create a temp command file
+        self.cmd_dir = Path(self.temp_dir) / ".claude" / "commands"
+        self.cmd_dir.mkdir(parents=True)
+        self.test_command = self.cmd_dir / "test-cmd.md"
+        self.test_command.write_text("# Test Command\n\nThis is a test command for tracking.")
+
+        # Change to temp dir so command finding works
+        self.original_cwd = os.getcwd()
+        os.chdir(self.temp_dir)
+
+        # Initialize metrics with temp database
+        self.metrics = TokenMetrics(db_path=self.db_path)
+        self.metrics.start_session()
+
+        # Patch get_metrics to return our test instance
+        import command_tracker
+        self._original_get_metrics = command_tracker.get_metrics
+        command_tracker.get_metrics = lambda: self.metrics
+
+    def teardown_method(self):
+        """Clean up temp files and restore state."""
+        self.metrics.end_session()
+        os.chdir(self.original_cwd)
+
+        # Restore get_metrics
+        import command_tracker
+        command_tracker.get_metrics = self._original_get_metrics
+
+        # Clean up temp files
+        if self.db_path.exists():
+            self.db_path.unlink()
+        if self.test_command.exists():
+            self.test_command.unlink()
+        self.cmd_dir.rmdir()
+        (Path(self.temp_dir) / ".claude").rmdir()
+        os.rmdir(self.temp_dir)
+
+    def test_track_command_load_with_source_path(self):
+        """Should track command load when source path is provided."""
+        tokens = track_command_load("test-cmd", source_path=str(self.test_command))
+
+        assert tokens is not None
+        assert tokens > 0
+
+        # Verify it was recorded in the database
+        summary = self.metrics.get_session_summary()
+        assert summary.total_tokens >= tokens
+        assert "command" in summary.component_breakdown
+
+    def test_track_command_load_with_content(self):
+        """Should track command load when content is provided directly."""
+        content = "# Direct Content\n\nThis is test content."
+        tokens = track_command_load("direct-cmd", content=content)
+
+        assert tokens is not None
+        assert tokens > 0
+
+        summary = self.metrics.get_session_summary()
+        assert summary.total_tokens >= tokens
+
+    def test_track_command_load_finds_file_automatically(self):
+        """Should find command file in known locations."""
+        tokens = track_command_load("test-cmd")
+
+        assert tokens is not None
+        assert tokens > 0
+
+    def test_track_command_load_nonexistent_command(self):
+        """Should handle nonexistent commands gracefully."""
+        tokens = track_command_load("nonexistent-cmd")
+
+        # Should return 0 or None when content can't be found
+        assert tokens is None or tokens == 0
+
+    def test_find_command_content(self):
+        """Should find command content from known locations."""
+        content = _find_command_content("test-cmd")
+        assert content is not None
+        assert "Test Command" in content
+
+    def test_find_command_content_not_found(self):
+        """Should return None for commands that don't exist."""
+        content = _find_command_content("nonexistent-cmd")
+        assert content is None
+
+    def test_get_command_token_estimate(self):
+        """Should estimate tokens without recording."""
+        estimate = get_command_token_estimate("test-cmd")
+
+        assert estimate is not None
+        assert estimate > 0
+
+        # Verify nothing was recorded (no change to session)
+        summary = self.metrics.get_session_summary()
+        assert summary.total_tokens == 0
+
+    def test_track_command_multiple_loads(self):
+        """Should track multiple command loads."""
+        tokens1 = track_command_load("test-cmd")
+        tokens2 = track_command_load("test-cmd")
+
+        assert tokens1 is not None
+        assert tokens2 is not None
+
+        summary = self.metrics.get_session_summary()
+        assert summary.total_tokens >= tokens1 + tokens2
+
+
+class TestCommandTrackerNoSession:
+    """Tests for command tracking without active session."""
+
+    def setup_method(self):
+        """Create metrics instance without starting session."""
+        self.temp_dir = tempfile.mkdtemp()
+        self.db_path = Path(self.temp_dir) / "test_metrics.db"
+
+        self.metrics = TokenMetrics(db_path=self.db_path)
+        # Note: NOT starting session
+
+        import command_tracker
+        self._original_get_metrics = command_tracker.get_metrics
+        command_tracker.get_metrics = lambda: self.metrics
+
+    def teardown_method(self):
+        """Clean up."""
+        import command_tracker
+        command_tracker.get_metrics = self._original_get_metrics
+
+        if self.db_path.exists():
+            self.db_path.unlink()
+        os.rmdir(self.temp_dir)
+
+    def test_track_without_session_returns_none(self):
+        """Should return None when no session is active."""
+        tokens = track_command_load("test-cmd", content="Test content")
+        assert tokens is None
+
+
+if __name__ == "__main__":
+    import pytest
+    pytest.main([__file__, "-v"])

package/global/tests/test_context_optimizer.py

@@ -0,0 +1,321 @@
+"""
+Tests for Context Optimizer Service (Phase 5).
+
+Tests the trigger keyword detection and context loading optimization.
+"""
+
+import pytest
+from datetime import datetime, timezone
+
+# Import the module under test
+import sys
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent / "lib"))
+
+from context_optimizer import (
+    ContextOptimizer,
+    TriggerRule,
+    LoadSuggestion,
+    DEFAULT_TRIGGER_RULES,
+    get_optimizer,
+    detect_triggers,
+    format_trigger_table,
+)
+
+
+class TestTriggerRule:
+    """Tests for TriggerRule dataclass."""
+
+    def test_trigger_rule_creation(self):
+        """Test creating a trigger rule."""
+        rule = TriggerRule(
+            command="/test",
+            keywords=["test", "testing"],
+            description="Test command",
+            estimated_tokens=100,
+            priority=1
+        )
+        assert rule.command == "/test"
+        assert rule.keywords == ["test", "testing"]
+        assert rule.estimated_tokens == 100
+        assert rule.priority == 1
+
+    def test_trigger_rule_default_priority(self):
+        """Test default priority is 2."""
+        rule = TriggerRule(
+            command="/cmd",
+            keywords=["kw"],
+            description="desc",
+            estimated_tokens=50
+        )
+        assert rule.priority == 2
+
+
+class TestLoadSuggestion:
+    """Tests for LoadSuggestion dataclass."""
+
+    def test_load_suggestion_creation(self):
+        """Test creating a load suggestion."""
+        suggestion = LoadSuggestion(
+            command="/patterns",
+            reason="Anti-patterns and code patterns",
+            estimated_tokens=1500,
+            priority=1,
+            keywords_matched=["anti-pattern", "avoid"]
+        )
+        assert suggestion.command == "/patterns"
+        assert len(suggestion.keywords_matched) == 2
+
+
+class TestContextOptimizer:
+    """Tests for ContextOptimizer class."""
+
+    def test_init_with_default_rules(self):
+        """Test initialization with default rules."""
+        optimizer = ContextOptimizer()
+        assert len(optimizer.rules) == len(DEFAULT_TRIGGER_RULES)
+
+    def test_init_with_custom_rules(self):
+        """Test initialization with custom rules."""
+        custom_rules = [
+            TriggerRule(
+                command="/custom",
+                keywords=["custom"],
+                description="Custom command",
+                estimated_tokens=100
+            )
+        ]
+        optimizer = ContextOptimizer(custom_rules=custom_rules)
+        assert len(optimizer.rules) == 1
+
+    def test_detect_triggers_finds_patterns(self):
+        """Test detecting triggers for patterns command."""
+        optimizer = ContextOptimizer()
+        suggestions = optimizer.detect_triggers("I need help avoiding anti-patterns")
+
+        # Should find /patterns command
+        commands = [s.command for s in suggestions]
+        assert "/patterns" in commands
+
+    def test_detect_triggers_finds_checklist(self):
+        """Test detecting triggers for checklist command."""
+        optimizer = ContextOptimizer()
+        suggestions = optimizer.detect_triggers("I need the quality checklist before PR")
+
+        commands = [s.command for s in suggestions]
+        assert "/checklist" in commands
+
+    def test_detect_triggers_finds_audit(self):
+        """Test detecting triggers for audit command."""
+        optimizer = ContextOptimizer()
+        suggestions = optimizer.detect_triggers("Show me my token usage")
+
+        commands = [s.command for s in suggestions]
+        assert "/audit" in commands
+
+    def test_detect_triggers_case_insensitive(self):
+        """Test that trigger detection is case insensitive."""
+        optimizer = ContextOptimizer()
+
+        lower_result = optimizer.detect_triggers("avoid bad practice")
+        upper_result = optimizer.detect_triggers("AVOID BAD PRACTICE")
+
+        assert len(lower_result) == len(upper_result)
+
+    def test_detect_triggers_excludes_loaded(self):
+        """Test that already-loaded commands are excluded by default."""
+        optimizer = ContextOptimizer()
+        optimizer.mark_loaded("/patterns")
+
+        suggestions = optimizer.detect_triggers("help with anti-patterns")
+        commands = [s.command for s in suggestions]
+
+        assert "/patterns" not in commands
+
+    def test_detect_triggers_includes_loaded_when_requested(self):
+        """Test including loaded commands when explicitly requested."""
+        optimizer = ContextOptimizer()
+        optimizer.mark_loaded("/patterns")
+
+        suggestions = optimizer.detect_triggers(
+            "help with anti-patterns",
+            include_loaded=True
+        )
+        commands = [s.command for s in suggestions]
+
+        assert "/patterns" in commands
+
+    def test_mark_loaded_normalizes_command(self):
+        """Test that mark_loaded normalizes command names."""
+        optimizer = ContextOptimizer()
+
+        optimizer.mark_loaded("patterns")  # Without /
+        assert optimizer.is_loaded("/patterns")
+
+        optimizer.mark_loaded("/checklist")  # With /
+        assert optimizer.is_loaded("checklist")
+
+    def test_get_loaded_commands(self):
+        """Test getting list of loaded commands."""
+        optimizer = ContextOptimizer()
+        optimizer.mark_loaded("/patterns")
+        optimizer.mark_loaded("/checklist")
+
+        loaded = optimizer.get_loaded_commands()
+        assert len(loaded) == 2
+        assert "/patterns" in loaded
+        assert "/checklist" in loaded
+
+    def test_get_estimated_savings(self):
+        """Test calculating estimated token savings."""
+        optimizer = ContextOptimizer()
+
+        # Initially, nothing is loaded
+        savings = optimizer.get_estimated_savings()
+        assert savings["commands_loaded"] == 0
+        assert savings["deferred_tokens"] > 0
+        assert savings["savings_percent"] == 100.0
+
+        # Load one command
+        optimizer.mark_loaded("/patterns")
+        savings = optimizer.get_estimated_savings()
+        assert savings["commands_loaded"] == 1
+        assert savings["loaded_tokens"] > 0
+
+    def test_format_suggestions_empty(self):
+        """Test formatting empty suggestions returns empty string."""
+        optimizer = ContextOptimizer()
+        result = optimizer.format_suggestions([])
+        assert result == ""
+
+    def test_format_suggestions_with_items(self):
+        """Test formatting suggestions produces markdown."""
+        optimizer = ContextOptimizer()
+        suggestions = [
+            LoadSuggestion(
+                command="/test",
+                reason="Test reason",
+                estimated_tokens=100,
+                priority=1,
+                keywords_matched=["test"]
+            )
+        ]
+        result = optimizer.format_suggestions(suggestions)
+
+        assert "/test" in result
+        assert "Test reason" in result
+        assert "100 tokens" in result
+
+    def test_format_suggestions_respects_max(self):
+        """Test that format_suggestions respects max_suggestions."""
+        optimizer = ContextOptimizer()
+        suggestions = optimizer.detect_triggers(
+            "anti-pattern avoid mistake checklist quality validate token budget"
+        )
+
+        # Format with max of 2
+        result = optimizer.format_suggestions(suggestions, max_suggestions=2)
+
+        # Should mention "and X more" if there are more
+        if len(suggestions) > 2:
+            assert "more" in result
+
+    def test_add_rule(self):
+        """Test adding a custom rule."""
+        optimizer = ContextOptimizer()
+        initial_count = len(optimizer.rules)
+
+        new_rule = TriggerRule(
+            command="/newcmd",
+            keywords=["newkeyword"],
+            description="New command",
+            estimated_tokens=200
+        )
+        optimizer.add_rule(new_rule)
+
+        assert len(optimizer.rules) == initial_count + 1
+
+    def test_reset_session(self):
+        """Test resetting session state."""
+        optimizer = ContextOptimizer()
+        optimizer.mark_loaded("/patterns")
+        optimizer.mark_loaded("/checklist")
+
+        assert len(optimizer.get_loaded_commands()) == 2
+
+        optimizer.reset_session()
+
+        assert len(optimizer.get_loaded_commands()) == 0
+
+    def test_suggestions_sorted_by_priority(self):
+        """Test that suggestions are sorted by priority."""
+        optimizer = ContextOptimizer()
+        suggestions = optimizer.detect_triggers(
+            "ralph autonomous migration anti-pattern avoid"
+        )
+
+        # Should be sorted by priority (1, 2, 3)
+        priorities = [s.priority for s in suggestions]
+        assert priorities == sorted(priorities)
+
+
+class TestGlobalFunctions:
+    """Tests for module-level convenience functions."""
+
+    def test_get_optimizer_returns_singleton(self):
+        """Test that get_optimizer returns a singleton."""
+        opt1 = get_optimizer()
+        opt2 = get_optimizer()
+        assert opt1 is opt2
+
+    def test_detect_triggers_convenience(self):
+        """Test the convenience detect_triggers function."""
+        suggestions = detect_triggers("help with anti-patterns")
+        assert len(suggestions) > 0
+
+    def test_format_trigger_table(self):
+        """Test formatting trigger table for CLAUDE.md."""
+        table = format_trigger_table()
+
+        assert "| Trigger | Command | Description |" in table
+        assert "/patterns" in table
+        assert "/checklist" in table
+
+
+class TestDefaultTriggerRules:
+    """Tests for the default trigger rules configuration."""
+
+    def test_default_rules_exist(self):
+        """Test that default rules are defined."""
+        assert len(DEFAULT_TRIGGER_RULES) > 0
+
+    def test_patterns_rule_exists(self):
+        """Test that /patterns rule exists with correct keywords."""
+        patterns_rule = next(
+            (r for r in DEFAULT_TRIGGER_RULES if r.command == "/patterns"),
+            None
+        )
+        assert patterns_rule is not None
+        assert "anti-pattern" in patterns_rule.keywords
+        assert patterns_rule.priority == 1
+
+    def test_checklist_rule_exists(self):
+        """Test that /checklist rule exists with correct keywords."""
+        checklist_rule = next(
+            (r for r in DEFAULT_TRIGGER_RULES if r.command == "/checklist"),
+            None
+        )
+        assert checklist_rule is not None
+        assert "checklist" in checklist_rule.keywords
+        assert "quality" in checklist_rule.keywords
+
+    def test_all_rules_have_required_fields(self):
+        """Test that all default rules have required fields."""
+        for rule in DEFAULT_TRIGGER_RULES:
+            assert rule.command.startswith("/")
+            assert len(rule.keywords) > 0
+            assert rule.description
+            assert rule.estimated_tokens > 0
+            assert rule.priority in [1, 2, 3]