feat: Add CLAUDE.md freshness tracking and update reminders

- Add SQLite table and CRUD methods for tracking update history
- Create freshness calculation service based on git file changes
- Add API endpoints for freshness data, marking updates, and history
- Display freshness badges in file tree (green/yellow/red indicators)
- Show freshness gauge and details in metadata panel
- Auto-mark files as updated after CLI sync
- Add English and Chinese i18n translations

Freshness algorithm: 100 - min((changedFilesCount / 20) * 100, 100)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

codex-lens/tests/test_cli_search.py

@@ -0,0 +1,122 @@
+"""Tests for CLI search command with --enrich flag."""
+
+import json
+import pytest
+from typer.testing import CliRunner
+from codexlens.cli.commands import app
+
+
+class TestCLISearchEnrich:
+    """Test CLI search command with --enrich flag integration."""
+
+    @pytest.fixture
+    def runner(self):
+        """Create CLI test runner."""
+        return CliRunner()
+
+    def test_search_with_enrich_flag_help(self, runner):
+        """Test --enrich flag is documented in help."""
+        result = runner.invoke(app, ["search", "--help"])
+        assert result.exit_code == 0
+        assert "--enrich" in result.output
+        assert "relationships" in result.output.lower() or "graph" in result.output.lower()
+
+    def test_search_with_enrich_flag_accepted(self, runner):
+        """Test --enrich flag is accepted by the CLI."""
+        result = runner.invoke(app, ["search", "test", "--enrich"])
+        # Should not show 'unknown option' error
+        assert "No such option" not in result.output
+        assert "error: unrecognized" not in result.output.lower()
+
+    def test_search_without_enrich_flag(self, runner):
+        """Test search without --enrich flag has no relationships."""
+        result = runner.invoke(app, ["search", "test", "--json"])
+        # Even without an index, JSON should be attempted
+        if result.exit_code == 0:
+            try:
+                data = json.loads(result.output)
+                # If we get results, they should not have enriched=true
+                if data.get("success") and "result" in data:
+                    assert data["result"].get("enriched", False) is False
+            except json.JSONDecodeError:
+                pass  # Not JSON output, that's fine for error cases
+
+    def test_search_enrich_json_output_structure(self, runner):
+        """Test JSON output structure includes enriched flag."""
+        result = runner.invoke(app, ["search", "test", "--json", "--enrich"])
+        # If we get valid JSON output, check structure
+        if result.exit_code == 0:
+            try:
+                data = json.loads(result.output)
+                if data.get("success") and "result" in data:
+                    # enriched field should exist
+                    assert "enriched" in data["result"]
+            except json.JSONDecodeError:
+                pass  # Not JSON output
+
+    def test_search_enrich_with_mode(self, runner):
+        """Test --enrich works with different search modes."""
+        modes = ["exact", "fuzzy", "hybrid"]
+        for mode in modes:
+            result = runner.invoke(
+                app, ["search", "test", "--mode", mode, "--enrich"]
+            )
+            # Should not show validation errors
+            assert "Invalid" not in result.output
+
+
+class TestEnrichFlagBehavior:
+    """Test behavioral aspects of --enrich flag."""
+
+    @pytest.fixture
+    def runner(self):
+        """Create CLI test runner."""
+        return CliRunner()
+
+    def test_enrich_failure_does_not_break_search(self, runner):
+        """Test that enrichment failure doesn't prevent search from returning results."""
+        # Even without proper index, search should not crash due to enrich
+        result = runner.invoke(app, ["search", "test", "--enrich", "--verbose"])
+        # Should not have unhandled exception
+        assert "Traceback" not in result.output
+
+    def test_enrich_flag_with_files_only(self, runner):
+        """Test --enrich is accepted with --files-only mode."""
+        result = runner.invoke(app, ["search", "test", "--enrich", "--files-only"])
+        # Should not show option conflict error
+        assert "conflict" not in result.output.lower()
+
+    def test_enrich_flag_with_limit(self, runner):
+        """Test --enrich works with --limit parameter."""
+        result = runner.invoke(app, ["search", "test", "--enrich", "--limit", "5"])
+        # Should not show validation error
+        assert "Invalid" not in result.output
+
+
+class TestEnrichOutputFormat:
+    """Test output format with --enrich flag."""
+
+    @pytest.fixture
+    def runner(self):
+        """Create CLI test runner."""
+        return CliRunner()
+
+    def test_enrich_verbose_shows_status(self, runner):
+        """Test verbose mode shows enrichment status."""
+        result = runner.invoke(app, ["search", "test", "--enrich", "--verbose"])
+        # Verbose mode may show enrichment info or warnings
+        # Just ensure it doesn't crash
+        assert result.exit_code in [0, 1]  # 0 = success, 1 = no index
+
+    def test_json_output_has_enriched_field(self, runner):
+        """Test JSON output always has enriched field when --enrich used."""
+        result = runner.invoke(app, ["search", "test", "--json", "--enrich"])
+        if result.exit_code == 0:
+            try:
+                data = json.loads(result.output)
+                if data.get("success"):
+                    result_data = data.get("result", {})
+                    assert "enriched" in result_data
+                    assert isinstance(result_data["enriched"], bool)
+            except json.JSONDecodeError:
+                pass