virtual-context 0.3.5__tar.gz → 0.3.7__tar.gz

{virtual_context-0.3.5 → virtual_context-0.3.7}/.github/workflows/python-publish.yml

@@ -6,10 +6,14 @@ on:
 
 permissions:
   contents: read
+  id-token: write
 
 jobs:
   publish:
     runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/virtual-context
 
     steps:
       - uses: actions/checkout@v4
@@ -25,5 +29,3 @@ jobs:
 
       - name: Publish to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          password: ${{ secrets.PYPI_API_TOKEN }}

{virtual_context-0.3.5 → virtual_context-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtual-context
-Version: 0.3.5
+Version: 0.3.7
 Summary: OS-style virtual memory for LLM session context management
 Project-URL: Homepage, https://virtual-context.com
 Project-URL: Repository, https://github.com/virtual-context/virtual-context

{virtual_context-0.3.5 → virtual_context-0.3.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "virtual-context"
-version = "0.3.5"
+version = "0.3.7"
 description = "OS-style virtual memory for LLM session context management"
 readme = "README.md"
 license = "AGPL-3.0-or-later"

{virtual_context-0.3.5 → virtual_context-0.3.7}/tests/test_assembler.py

@@ -4,7 +4,7 @@ from datetime import datetime, timezone
 
 import pytest
 
-from virtual_context.core.assembler import ContextAssembler
+from virtual_context.core.assembler import ContextAssembler, format_tag_section
 from virtual_context.types import (
     AssemblerConfig,
     Message,
@@ -77,6 +77,36 @@ def test_assemble_xml_tags(assembler, retrieval_result):
     assert "</virtual-context>" in section
 
 
+def test_format_tag_section_renders_code_refs():
+    now = datetime.now(timezone.utc)
+    section = format_tag_section(
+        "backend",
+        [
+            StoredSummary(
+                ref="ref-1",
+                primary_tag="backend",
+                tags=["backend"],
+                summary="Request cache boundary moved ahead of the mutable reminder.",
+                summary_tokens=18,
+                full_tokens=50,
+                metadata=SegmentMetadata(
+                    code_refs=[
+                        {"file": "virtual_context/proxy/formats.py", "line": 1312, "symbol": "inject_context"},
+                        {"file": "virtual_context/core/provider_adapters.py", "symbol": "AnthropicAdapter"},
+                    ],
+                ),
+                created_at=now,
+                start_timestamp=now,
+                end_timestamp=now,
+            ),
+        ],
+    )
+
+    assert "[refs:" in section
+    assert "virtual_context/proxy/formats.py:1312 inject_context" in section
+    assert "virtual_context/core/provider_adapters.py AnthropicAdapter" in section
+
+
 def test_trim_conversation(assembler):
     messages = [
         Message(role="user", content="x" * 400),

virtual_context-0.3.7/tests/test_beam_judge.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from benchmarks.beam.dataset import BEAMQuestion
+from benchmarks.beam.judge import judge_answer
+from benchmarks.beam.run_beam import _parse_args
+
+
+def _event_ordering_question() -> BEAMQuestion:
+    return BEAMQuestion(
+        question_id="10M_1_event_ordering_0",
+        question="Reconstruct the ordered sequence of milestones.",
+        category="event_ordering",
+        rubric=[
+            "token limits and segmentation",
+            "reranking and feedback parsing",
+            "language detection and vector alignment",
+        ],
+        ideal_response="",
+        difficulty="medium",
+    )
+
+
+def test_fast_event_ordering_judge_matches_paraphrases_without_llm(monkeypatch) -> None:
+    def _should_not_call(*args, **kwargs):
+        raise AssertionError("fast event ordering judge should not call the judge LLM")
+
+    monkeypatch.setattr("benchmarks.beam.judge._call_judge_llm", _should_not_call)
+
+    result = judge_answer(
+        _event_ordering_question(),
+        "\n".join([
+            "segmentation and token limit handling",
+            "feedback parsing plus reranking problems",
+            "vector alignment with language detection",
+        ]),
+        event_ordering_mode="fast",
+    )
+
+    assert result["method"] == "kendall_tau_fast"
+    assert result["score"] == 1.0
+    assert len(result["criteria_met"]) == 3
+
+
+def test_fast_event_ordering_judge_penalizes_wrong_order(monkeypatch) -> None:
+    def _should_not_call(*args, **kwargs):
+        raise AssertionError("fast event ordering judge should not call the judge LLM")
+
+    monkeypatch.setattr("benchmarks.beam.judge._call_judge_llm", _should_not_call)
+
+    result = judge_answer(
+        _event_ordering_question(),
+        "\n".join([
+            "vector alignment with language detection",
+            "feedback parsing plus reranking problems",
+            "segmentation and token limit handling",
+        ]),
+        event_ordering_mode="fast",
+    )
+
+    assert result["method"] == "kendall_tau_fast"
+    assert result["score"] < 1.0
+    assert result["tau_norm"] < 1.0
+
+
+def test_run_beam_parse_args_accepts_fast_event_ordering_mode() -> None:
+    args = _parse_args([
+        "--chat-size", "10M",
+        "--tagger-model", "claude-haiku-4-5-20251001",
+        "--event-ordering-judge-mode", "fast",
+    ])
+    assert args.event_ordering_judge_mode == "fast"
+
+
+def test_fast_event_ordering_judge_returns_zero_not_nan_for_no_matches(monkeypatch) -> None:
+    def _should_not_call(*args, **kwargs):
+        raise AssertionError("fast event ordering judge should not call the judge LLM")
+
+    monkeypatch.setattr("benchmarks.beam.judge._call_judge_llm", _should_not_call)
+
+    result = judge_answer(
+        _event_ordering_question(),
+        "\n".join([
+            "completely unrelated infrastructure planning",
+            "team retro and onboarding notes",
+        ]),
+        event_ordering_mode="fast",
+    )
+
+    assert result["method"] == "kendall_tau_fast"
+    assert isinstance(float(result["score"]), float)
+    assert result["score"] == result["score"]
+    assert result["alignments"] == []

virtual_context-0.3.7/tests/test_conversation_coverage_report.py

@@ -0,0 +1,145 @@
+from datetime import datetime, timezone
+
+from virtual_context.core.coverage_report import build_conversation_coverage_report
+from virtual_context.storage.sqlite import SQLiteStore
+from virtual_context.types import SegmentMetadata, StoredSegment, TagSummary
+
+
+def _make_segment(
+    ref: str,
+    *,
+    conversation_id: str,
+    turn_count: int,
+    start_turn_number: int,
+    end_turn_number: int,
+    generated_by_turn_id: str,
+    created_at: datetime,
+) -> StoredSegment:
+    return StoredSegment(
+        ref=ref,
+        conversation_id=conversation_id,
+        primary_tag="topic",
+        tags=["topic"],
+        summary=f"summary {ref}",
+        summary_tokens=10,
+        full_text=f"full {ref}",
+        full_tokens=20,
+        messages=[{"role": "user", "content": ref}],
+        metadata=SegmentMetadata(
+            turn_count=turn_count,
+            start_turn_number=start_turn_number,
+            end_turn_number=end_turn_number,
+            generated_by_turn_id=generated_by_turn_id,
+        ),
+        created_at=created_at,
+        start_timestamp=created_at,
+        end_timestamp=created_at,
+        compaction_model="test",
+        compression_ratio=0.5,
+    )
+
+
+def test_build_conversation_coverage_report_uses_latest_payload_and_exact_ranges(tmp_path):
+    store = SQLiteStore(tmp_path / "test.db")
+    conversation_id = "conv-1"
+    now = datetime(2026, 4, 10, 12, 0, tzinfo=timezone.utc)
+
+    store.store_segment(
+        _make_segment(
+            "seg-a",
+            conversation_id=conversation_id,
+            turn_count=3,
+            start_turn_number=0,
+            end_turn_number=2,
+            generated_by_turn_id="req-a",
+            created_at=now,
+        )
+    )
+    store.store_segment(
+        _make_segment(
+            "seg-b",
+            conversation_id=conversation_id,
+            turn_count=3,
+            start_turn_number=2,
+            end_turn_number=4,
+            generated_by_turn_id="req-b",
+            created_at=now.replace(hour=13),
+        )
+    )
+    store.store_segment(
+        _make_segment(
+            "seg-c",
+            conversation_id=conversation_id,
+            turn_count=4,
+            start_turn_number=-1,
+            end_turn_number=-1,
+            generated_by_turn_id="",
+            created_at=now.replace(hour=14),
+        )
+    )
+    store.save_tag_summary(
+        TagSummary(
+            tag="topic",
+            summary="rollup",
+            summary_tokens=12,
+            covers_through_turn=8,
+            generated_by_turn_id="req-b",
+            created_at=now.replace(hour=15),
+            updated_at=now.replace(hour=15),
+        ),
+        conversation_id=conversation_id,
+    )
+    store.save_request_capture(
+        {
+            "turn": 9,
+            "turn_id": "req-latest",
+            "ts": "2026-04-10T16:30:00+00:00",
+            "api_format": "anthropic",
+            "model": "test",
+            "stream": False,
+            "message_count": 6,
+            "client_payload_message_count": 6,
+            "client_payload_pair_count": 3,
+            "client_payload_user_prompt_count": 3,
+            "client_payload_timestamped_message_count": 3,
+            "client_payload_earliest_timestamp": "2026-03-15T16:10:00+00:00",
+            "client_payload_latest_timestamp": "2026-04-10T16:29:00+00:00",
+            "conversation_id": conversation_id,
+            "inbound_tags": [],
+            "response_tags": [],
+            "passthrough": False,
+            "inbound_tokens": 0,
+            "outbound_tokens": 0,
+            "inbound_bytes": 0,
+            "outbound_bytes": 0,
+            "context_tokens": 0,
+            "overhead_ms": 0,
+            "turns_dropped": 0,
+            "turns_stubbed": 0,
+            "message_preview": "",
+            "upstream_input_tokens": 0,
+            "upstream_output_tokens": 0,
+            "cache_creation_input_tokens": 0,
+            "cache_read_input_tokens": 0,
+        }
+    )
+
+    report = build_conversation_coverage_report(store, conversation_id)
+
+    assert report.conversation_id == conversation_id
+    assert report.latest_payload.turn == 9
+    assert report.latest_payload.turn_id == "req-latest"
+    assert report.latest_payload.message_count == 6
+    assert report.latest_payload.pair_count == 3
+    assert report.latest_payload.user_prompt_count == 3
+    assert report.latest_payload.timestamped_message_count == 3
+    assert report.latest_payload.earliest_timestamp == "2026-03-15T16:10:00+00:00"
+    assert report.latest_payload.latest_timestamp == "2026-04-10T16:29:00+00:00"
+    assert report.segment_count == 3
+    assert report.summarized_turn_occurrences == 10
+    assert report.exact_range_segment_count == 2
+    assert report.exact_unique_turn_count == 5
+    assert report.exact_start_turn_number == 0
+    assert report.exact_end_turn_number == 4
+    assert report.tag_summary_count == 1
+    assert report.max_tag_summary_turn == 8

{virtual_context-0.3.5 → virtual_context-0.3.7}/tests/test_engine_state.py

@@ -28,6 +28,7 @@ def _make_snapshot(
             tags=[f"tag-{i}", "common"],
             primary_tag=f"tag-{i}",
             timestamp=datetime(2026, 1, 15, 10, i, 0, tzinfo=timezone.utc),
+            code_refs=[{"file": f"src/module_{i}.py", "line": i + 1, "symbol": f"func_{i}"}],
         )
         for i in range(turn_count)
     ]
@@ -75,6 +76,7 @@ class TestEngineStateSQLite:
             assert restored.tags == orig.tags
             assert restored.primary_tag == orig.primary_tag
             assert restored.timestamp == orig.timestamp
+            assert restored.code_refs == orig.code_refs
 
     def test_load_empty_store(self, tmp_path):
         """Loading from an empty store returns None."""
@@ -131,6 +133,7 @@ class TestEngineStateFilesystem:
             assert restored.message_hash == orig.message_hash
             assert restored.tags == orig.tags
             assert restored.primary_tag == orig.primary_tag
+            assert restored.code_refs == orig.code_refs
 
     def test_load_empty_store(self, tmp_path):
         """Loading from an empty store returns None."""

{virtual_context-0.3.5 → virtual_context-0.3.7}/tests/test_engine_sync_turns.py

@@ -67,16 +67,16 @@ def engine(tmp_path):
 
 
 def _search_via_store(engine, query):
-    """Search turn_messages through the CompositeStore delegate (Task 1).
+    """Search canonical full_text through the CompositeStore delegate.
 
-    Validates that the CompositeStore.search_turn_messages delegation works,
+    Validates that the CompositeStore.search_canonical_full_text delegation works,
     not just the raw concrete store method.
     """
     store = engine._store
-    _search = getattr(store, "search_turn_messages", None)
+    _search = getattr(store, "search_canonical_full_text", None)
     assert _search is not None, (
-        "search_turn_messages not reachable through store chain — "
-        "CompositeStore delegation missing (Task 1)")
+        "search_canonical_full_text not reachable through store chain — "
+        "CompositeStore delegation missing")
     return _search(query, conversation_id="test-conv-sync")
 
 

{virtual_context-0.3.5 → virtual_context-0.3.7}/tests/test_fact_redesign.py

@@ -61,17 +61,75 @@ def test_compaction_uses_replace_facts_for_segment():
 
 def test_code_mode_prompt_appended():
     """When code_mode is True, the compactor prompt should include the code mode block."""
-    from virtual_context.core.compactor import CODE_MODE_FACT_PROMPT
-    assert "Do NOT extract intermediary" in CODE_MODE_FACT_PROMPT
-    assert "conclusions, findings, discoveries" in CODE_MODE_FACT_PROMPT
+    from virtual_context.core.compactor import (
+        CODE_FACT_EXTRACTION_PROMPT,
+        CODE_SUMMARY_PROMPT,
+        CODE_TAG_SUMMARY_ROLLUP_PROMPT,
+    )
+    assert "Do NOT extract intermediary" in CODE_FACT_EXTRACTION_PROMPT
+    assert "conclusions, findings, discoveries" in CODE_FACT_EXTRACTION_PROMPT
+    assert "engineering conversation segment" in CODE_SUMMARY_PROMPT
+    assert '"code_refs"' in CODE_SUMMARY_PROMPT
+    assert "rolling up engineering context" in CODE_TAG_SUMMARY_ROLLUP_PROMPT
+
+
+def test_compactor_template_path_appends_code_fact_prompt():
+    from datetime import datetime, timezone
+    from unittest.mock import MagicMock
+
+    from virtual_context.core.compactor import CODE_FACT_EXTRACTION_PROMPT, DomainCompactor
+    from virtual_context.types import Message, TaggedSegment
+
+    captured: dict[str, str] = {}
+
+    llm = MagicMock()
+
+    def _complete(*, system, user, max_tokens):
+        captured["user"] = user
+        return ('{"summary":"ok","entities":[],"key_decisions":[],"action_items":[],"date_references":[],"refined_tags":[],"code_refs":[]}', {})
+
+    llm.complete.side_effect = _complete
+
+    compactor = DomainCompactor(
+        llm_provider=llm,
+        config=CompactorConfig(code_mode=True),
+    )
+
+    seg = TaggedSegment(
+        primary_tag="backend",
+        tags=["backend"],
+        messages=[
+            Message(role="user", content="We changed the request cache boundary in formats.py."),
+            Message(role="assistant", content="It now sits above the mutable VC injection block."),
+        ],
+        token_count=40,
+        start_timestamp=datetime.now(timezone.utc),
+        end_timestamp=datetime.now(timezone.utc),
+        turn_count=1,
+    )
+
+    compactor._compact_one(seg)
+
+    assert CODE_FACT_EXTRACTION_PROMPT.strip() in captured["user"]
 
 
 def test_tag_generator_accepts_code_mode():
-    from virtual_context.core.tag_generator import LLMTagGenerator
+    from virtual_context.core.tag_generator import (
+        CODE_TAG_GENERATOR_PROMPT_COMPACT,
+        CODE_TAG_GENERATOR_PROMPT_DETAILED,
+        CODE_TAG_GENERATOR_PROMPT_SMALL_MODEL,
+        LLMTagGenerator,
+    )
     from virtual_context.types import TagGeneratorConfig
     from unittest.mock import MagicMock
     gen = LLMTagGenerator(llm_provider=MagicMock(), config=TagGeneratorConfig(), code_mode=True)
     assert gen._code_mode is True
+    assert "engineering and code conversations" in CODE_TAG_GENERATOR_PROMPT_DETAILED
+    assert "fact_signals" in CODE_TAG_GENERATOR_PROMPT_DETAILED
+    assert "engineering and code conversations" in CODE_TAG_GENERATOR_PROMPT_COMPACT
+    assert "fact_signals" in CODE_TAG_GENERATOR_PROMPT_COMPACT
+    assert "engineering and code conversations" in CODE_TAG_GENERATOR_PROMPT_SMALL_MODEL
+    assert "fact_signals" in CODE_TAG_GENERATOR_PROMPT_SMALL_MODEL
 
 
 def test_build_tag_generator_passes_code_mode():