virtual-context 0.2.7__tar.gz → 0.2.9__tar.gz

{virtual_context-0.2.7 → virtual_context-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtual-context
-Version: 0.2.7
+Version: 0.2.9
 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
@@ -180,10 +180,16 @@ proxy:
 **Daemon mode:** run as a background service:
 
 ```bash
-virtual-context onboard --install-daemon --upstream https://api.anthropic.com
+# Creates config if needed, installs + starts daemon
+virtual-context daemon install --upstream https://api.anthropic.com
+
+# Or: guided interactive setup with daemon
+virtual-context onboard --wizard --install-daemon
 ```
 
-Daemon setup docs (macOS `launchd`, Linux `systemd --user`, Windows Task Scheduler): [`docs/install.md`](docs/install.md)
+Daemon lifecycle: `daemon status | start | stop | restart | uninstall`
+
+Full setup docs (macOS `launchd`, Linux `systemd --user`, Windows Task Scheduler): [`docs/install.md`](docs/install.md)
 
 ### Python SDK
 
@@ -639,10 +645,14 @@ virtual-context transform -m "What about auth?"# tag + retrieve + assemble
 virtual-context aliases list                   # show all tag aliases
 virtual-context aliases suggest                # auto-detect potential aliases
 virtual-context aliases add db database        # register alias manually
+virtual-context init coding                    # create config from preset
+virtual-context onboard                        # guided setup (create/validate config)
+virtual-context onboard --wizard               # interactive multi-instance setup
 virtual-context proxy -u https://api.anthropic.com  # single-instance proxy
 virtual-context proxy                               # multi-instance (from config)
 virtual-context presets list                   # list available config presets
 virtual-context presets show coding            # dump preset config as YAML
+virtual-context daemon install                 # install daemon/service
 virtual-context daemon status                  # service status (platform-specific)
 virtual-context daemon start                   # start/enable daemon
 virtual-context daemon stop                    # stop daemon

{virtual_context-0.2.7 → virtual_context-0.2.9}/README.md

@@ -133,10 +133,16 @@ proxy:
 **Daemon mode:** run as a background service:
 
 ```bash
-virtual-context onboard --install-daemon --upstream https://api.anthropic.com
+# Creates config if needed, installs + starts daemon
+virtual-context daemon install --upstream https://api.anthropic.com
+
+# Or: guided interactive setup with daemon
+virtual-context onboard --wizard --install-daemon
 ```
 
-Daemon setup docs (macOS `launchd`, Linux `systemd --user`, Windows Task Scheduler): [`docs/install.md`](docs/install.md)
+Daemon lifecycle: `daemon status | start | stop | restart | uninstall`
+
+Full setup docs (macOS `launchd`, Linux `systemd --user`, Windows Task Scheduler): [`docs/install.md`](docs/install.md)
 
 ### Python SDK
 
@@ -592,10 +598,14 @@ virtual-context transform -m "What about auth?"# tag + retrieve + assemble
 virtual-context aliases list                   # show all tag aliases
 virtual-context aliases suggest                # auto-detect potential aliases
 virtual-context aliases add db database        # register alias manually
+virtual-context init coding                    # create config from preset
+virtual-context onboard                        # guided setup (create/validate config)
+virtual-context onboard --wizard               # interactive multi-instance setup
 virtual-context proxy -u https://api.anthropic.com  # single-instance proxy
 virtual-context proxy                               # multi-instance (from config)
 virtual-context presets list                   # list available config presets
 virtual-context presets show coding            # dump preset config as YAML
+virtual-context daemon install                 # install daemon/service
 virtual-context daemon status                  # service status (platform-specific)
 virtual-context daemon start                   # start/enable daemon
 virtual-context daemon stop                    # stop daemon

{virtual_context-0.2.7 → virtual_context-0.2.9}/pyproject.toml

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

{virtual_context-0.2.7 → virtual_context-0.2.9}/tests/test_cli_init.py

@@ -97,6 +97,46 @@ def test_daemon_restart_in_help(tmp_cwd):
     assert "restart" in result.stdout
 
 
+def test_daemon_not_installed_guard(tmp_cwd):
+    """daemon commands should fail with a helpful message when no daemon is installed."""
+    env = {**__import__("os").environ, "HOME": str(tmp_cwd)}
+    for action in ("status", "start", "stop", "restart"):
+        result = subprocess.run(
+            [sys.executable, "-m", "virtual_context.cli.main", "daemon", action],
+            capture_output=True,
+            text=True,
+            env=env,
+        )
+        assert result.returncode != 0, f"daemon {action} should fail when not installed"
+        assert "not installed" in result.stdout.lower(), (
+            f"daemon {action} should mention 'not installed'"
+        )
+        assert "daemon install" in result.stdout, (
+            f"daemon {action} should suggest 'daemon install'"
+        )
+
+
+def test_daemon_install_creates_config(tmp_cwd):
+    """daemon install should auto-create config from agentic preset if none exists."""
+    config_path = tmp_cwd / "virtual-context.yaml"
+    assert not config_path.exists()
+    # daemon install will fail on launchctl/systemctl, but should create config first
+    result = _run_cli("daemon", "install")
+    assert config_path.exists(), "daemon install should create config"
+    assert "Created config" in result.stdout
+    content = config_path.read_text()
+    assert "tag_generator" in content
+
+
+def test_daemon_install_preserves_existing_config(tmp_cwd):
+    """daemon install should not overwrite an existing config."""
+    config_path = tmp_cwd / "virtual-context.yaml"
+    config_path.write_text("custom: true\n")
+    result = _run_cli("daemon", "install")
+    assert config_path.read_text() == "custom: true\n"
+    assert "Created config" not in result.stdout
+
+
 def test_presets_list(tmp_cwd):
     result = _run_cli("presets", "list")
     assert result.returncode == 0

virtual_context-0.2.9/tests/test_fact_redesign.py

@@ -0,0 +1,95 @@
+"""Tests for fact extraction redesign."""
+from virtual_context.types import CompactorConfig
+
+
+def test_compactor_config_has_code_mode():
+    cc = CompactorConfig()
+    assert hasattr(cc, "code_mode")
+    assert cc.code_mode is True
+
+
+def test_config_loader_reads_code_mode():
+    from virtual_context.config import load_config
+    import tempfile, os, yaml
+    cfg = {"compaction": {"code_mode": False}, "context_window": 100000}
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
+        yaml.dump(cfg, f)
+        tmp_path = f.name
+    try:
+        config = load_config(tmp_path)
+        assert config.compactor.code_mode is False
+    finally:
+        os.unlink(tmp_path)
+
+
+def test_replace_facts_for_segment_default():
+    from virtual_context.core.store import ContextStore
+
+    class MinimalStore(ContextStore):
+        """Minimal concrete subclass that only implements abstract methods as no-ops."""
+        def store_segment(self, segment): return ""
+        def get_segment(self, ref, *, conversation_id=None): return None
+        def get_summary(self, ref, *, conversation_id=None): return None
+        def get_summaries_by_tags(self, tags, min_overlap=1, limit=10, before=None, after=None, conversation_id=None): return []
+        def search(self, query, tags=None, limit=5, conversation_id=None): return []
+        def get_all_tags(self, conversation_id=None): return []
+        def get_conversation_stats(self): return []
+        def get_tag_aliases(self, conversation_id=None): return {}
+        def set_tag_alias(self, alias, canonical, conversation_id=""): pass
+        def delete_segment(self, ref): return False
+        def cleanup(self, max_age=None, max_total_tokens=None): return 0
+        def save_tag_summary(self, tag_summary, conversation_id=""): pass
+        def get_tag_summary(self, tag, conversation_id=""): return None
+        def get_all_tag_summaries(self, *, conversation_id=None): return []
+        def search_full_text(self, query, limit=5, conversation_id=None): return []
+        def get_segments_by_tags(self, tags, min_overlap=1, limit=20, conversation_id=None): return []
+
+    store = MinimalStore()
+    deleted, inserted = store.replace_facts_for_segment("conv1", "seg1", [])
+    assert deleted == 0
+    assert inserted == 0
+
+
+def test_compaction_uses_replace_facts_for_segment():
+    """Verify the compaction pipeline calls replace_facts_for_segment."""
+    import inspect
+    from virtual_context.core import compaction_pipeline
+    source = inspect.getsource(compaction_pipeline)
+    assert "replace_facts_for_segment" in source, \
+        "compaction_pipeline must call 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
+
+
+def test_tag_generator_accepts_code_mode():
+    from virtual_context.core.tag_generator import 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
+
+
+def test_build_tag_generator_passes_code_mode():
+    from virtual_context.core.tag_generator import build_tag_generator, LLMTagGenerator
+    from virtual_context.types import TagGeneratorConfig
+    from unittest.mock import MagicMock
+    config = TagGeneratorConfig(type="llm", provider="openrouter", model="test")
+    gen = build_tag_generator(config, MagicMock(), code_mode=True)
+    assert isinstance(gen, LLMTagGenerator)
+    assert gen._code_mode is True
+    gen2 = build_tag_generator(config, MagicMock())
+    assert gen2._code_mode is False
+
+
+def test_engine_passes_code_mode_to_tag_generator():
+    import inspect
+    from virtual_context import engine
+    source = inspect.getsource(engine)
+    assert "code_mode" in source, "engine.py must reference code_mode"
+    assert "compactor.code_mode" in source or "config.compactor.code_mode" in source, \
+        "engine.py must read code_mode from compactor config"

virtual_context-0.2.9/tests/test_fill_pass.py

@@ -0,0 +1,274 @@
+"""Tests for the fill pass pipeline stage."""
+
+import copy
+import json
+import re
+from unittest.mock import MagicMock
+from datetime import datetime, timezone
+
+from virtual_context.proxy.formats import detect_format
+from virtual_context.types import (
+    RetrievalResult, StoredSummary, AssembledContext, TagSummary, SegmentMetadata,
+)
+
+
+def test_retrieval_result_has_overflow_field():
+    rr = RetrievalResult()
+    assert hasattr(rr, "overflow_summaries")
+    assert rr.overflow_summaries == []
+
+
+def test_retrieval_result_overflow_accepts_summaries():
+    s = StoredSummary(ref="seg_001", primary_tag="cooking", summary="test", summary_tokens=50)
+    rr = RetrievalResult(overflow_summaries=[s])
+    assert len(rr.overflow_summaries) == 1
+    assert rr.overflow_summaries[0].ref == "seg_001"
+
+
+def test_assembled_context_has_retrieval_result():
+    ac = AssembledContext()
+    assert ac.retrieval_result is None
+
+
+def test_assembled_context_has_presented_tags():
+    ac = AssembledContext()
+    assert isinstance(ac.presented_tags, set)
+    assert len(ac.presented_tags) == 0
+
+
+def test_assembled_context_presented_tags_populated():
+    ac = AssembledContext(presented_tags={"cooking", "baking", "recipes"})
+    assert "cooking" in ac.presented_tags
+    assert len(ac.presented_tags) == 3
+
+
+def test_format_tag_section_standalone():
+    """Standalone format_tag_section produces the same XML format as the assembler."""
+    from virtual_context.core.assembler import format_tag_section
+    from virtual_context.types import StoredSummary, SegmentMetadata
+    from datetime import datetime, timezone
+
+    s1 = StoredSummary(
+        ref="s1", primary_tag="cooking", summary="Italian cooking techniques",
+        summary_tokens=100, tags=["cooking", "italian"],
+        metadata=SegmentMetadata(),
+        start_timestamp=datetime.now(timezone.utc),
+    )
+
+    result = format_tag_section("cooking", [s1])
+    assert '<virtual-context tags="cooking, italian"' in result
+    assert "[1/1]" in result
+    assert "Italian cooking techniques" in result
+    assert "</virtual-context>" in result
+
+
+def _make_summary(ref: str, tag: str, tokens: int) -> StoredSummary:
+    return StoredSummary(
+        ref=ref, primary_tag=tag, tags=[tag],
+        summary=f"Summary for {tag}", summary_tokens=tokens,
+        metadata=SegmentMetadata(),
+        start_timestamp=datetime.now(timezone.utc),
+    )
+
+
+def _make_anthropic_body(user_texts: list[str]) -> dict:
+    messages = []
+    for text in user_texts:
+        messages.append({"role": "user", "content": text})
+        messages.append({"role": "assistant", "content": [{"type": "text", "text": f"Reply to: {text}"}]})
+    messages.append({"role": "user", "content": "current question"})
+    return {"system": "You are helpful.", "messages": messages, "model": "claude-opus-4-6"}
+
+
+def test_fill_pass_no_op_when_at_target():
+    from virtual_context.proxy.message_filter import fill_pass
+    body = _make_anthropic_body(["hello", "world"])
+    fmt = detect_format(body)
+    result, summaries, turns = fill_pass(
+        body=body, fmt=fmt, outbound_tokens=90000, target_tokens=90000,
+        assembled=None, pre_filter_body=body,
+        store=MagicMock(), conversation_id="test",
+    )
+    assert summaries == 0
+    assert turns == 0
+
+
+def test_fill_pass_no_op_when_over_target():
+    from virtual_context.proxy.message_filter import fill_pass
+    body = _make_anthropic_body(["hello"])
+    fmt = detect_format(body)
+    result, summaries, turns = fill_pass(
+        body=body, fmt=fmt, outbound_tokens=100000, target_tokens=90000,
+        assembled=None, pre_filter_body=body,
+        store=MagicMock(), conversation_id="test",
+    )
+    assert summaries == 0
+    assert turns == 0
+
+
+def test_fill_pass_adds_breadth_summaries():
+    from virtual_context.proxy.message_filter import fill_pass
+
+    body = _make_anthropic_body(["hello"])
+    fmt = detect_format(body)
+
+    ts1 = TagSummary(tag="cooking", summary="Italian cooking", summary_tokens=50,
+                     source_segment_refs=["seg_a"], updated_at=datetime.now(timezone.utc))
+    ts2 = TagSummary(tag="baking", summary="Bread baking", summary_tokens=50,
+                     source_segment_refs=["seg_b"], updated_at=datetime.now(timezone.utc))
+    mock_store = MagicMock()
+    mock_store.get_all_tag_summaries.return_value = [ts1, ts2]
+
+    assembled = AssembledContext(
+        presented_segment_refs=set(),
+        presented_tags=set(),
+        tag_sections={},
+        retrieval_result=RetrievalResult(),
+    )
+
+    result, summaries_added, turns_added = fill_pass(
+        body=body, fmt=fmt, outbound_tokens=70000, target_tokens=90000,
+        assembled=assembled, pre_filter_body=copy.deepcopy(body),
+        store=mock_store, conversation_id="test",
+        summary_ratio=1.0,
+    )
+    assert summaries_added >= 1
+    mock_store.get_all_tag_summaries.assert_called_once_with(conversation_id="test")
+
+
+def test_presented_tags_from_segments_and_full_sections():
+    """presented_tags must include secondary tags from SEGMENTS/FULL sections."""
+    tag_sections = {
+        "cooking": (
+            '<virtual-context tags="cooking, italian" segments="2">\n'
+            "[1/2]\nPasta techniques\n\n---\n\n[2/2]\nRisotto methods\n"
+            "</virtual-context>"
+        ),
+        "baking": (
+            '<virtual-context tags="baking, bread, sourdough" segments="1">\n'
+            "[1/1]\nSourdough starter maintenance\n"
+            "</virtual-context>"
+        ),
+    }
+
+    _vc_tags_re = re.compile(r'<virtual-context\s+tags="([^"]*)"')
+    presented_tags: set[str] = set()
+    for section_text in tag_sections.values():
+        for m in _vc_tags_re.finditer(section_text):
+            for t in m.group(1).split(", "):
+                t = t.strip()
+                if t:
+                    presented_tags.add(t)
+    # Also include section keys
+    presented_tags.update(tag_sections.keys())
+
+    assert "cooking" in presented_tags
+    assert "baking" in presented_tags
+    assert "italian" in presented_tags
+    assert "bread" in presented_tags
+    assert "sourdough" in presented_tags
+    assert "grilling" not in presented_tags
+
+
+def test_presented_tags_fallback_to_section_key():
+    """When tags attr is empty, section key should still be covered."""
+    tag_sections = {
+        "misc": '<virtual-context tags="" segments="1">\n[1/1]\nRandom\n</virtual-context>',
+    }
+
+    _vc_tags_re = re.compile(r'<virtual-context\s+tags="([^"]*)"')
+    presented_tags: set[str] = set()
+    for section_text in tag_sections.values():
+        for m in _vc_tags_re.finditer(section_text):
+            for t in m.group(1).split(", "):
+                t = t.strip()
+                if t:
+                    presented_tags.add(t)
+    presented_tags.update(tag_sections.keys())
+
+    # "misc" comes from keys(), not from regex (empty attr)
+    assert "misc" in presented_tags
+
+
+def test_fill_pass_accounting_summary_and_turns():
+    """After fill pass, counts must match actual content added."""
+    from virtual_context.proxy.message_filter import fill_pass
+
+    body = _make_anthropic_body(["hello", "world"])
+    pre_filter = copy.deepcopy(body)
+    extra_msgs = [
+        {"role": "user", "content": "older message 1"},
+        {"role": "assistant", "content": [{"type": "text", "text": "older reply 1"}]},
+        {"role": "user", "content": "older message 2"},
+        {"role": "assistant", "content": [{"type": "text", "text": "older reply 2"}]},
+    ]
+    pre_filter["messages"] = extra_msgs + pre_filter["messages"]
+
+    fmt = detect_format(body)
+
+    ts1 = TagSummary(tag="history", summary="Historical events discussed",
+                     summary_tokens=30, source_segment_refs=["seg_h1"],
+                     updated_at=datetime.now(timezone.utc))
+    mock_store = MagicMock()
+    mock_store.get_all_tag_summaries.return_value = [ts1]
+
+    assembled = AssembledContext(
+        presented_segment_refs=set(),
+        presented_tags=set(),
+        tag_sections={},
+        retrieval_result=RetrievalResult(),
+    )
+
+    result_body, summaries_added, turns_added = fill_pass(
+        body=body, fmt=fmt,
+        outbound_tokens=70000, target_tokens=90000,
+        assembled=assembled, pre_filter_body=pre_filter,
+        store=mock_store, conversation_id="test-conv",
+        summary_ratio=0.5,
+    )
+
+    assert summaries_added >= 1
+    result_json = json.dumps(result_body)
+    assert "Historical events discussed" in result_json
+
+
+def test_fill_pass_sanitizes_restored_turns():
+    """Restored turns must have thinking blocks stripped and media replaced."""
+    from virtual_context.proxy.message_filter import _sanitize_restored_turn
+
+    messages = [
+        {"role": "user", "content": [
+            {"type": "text", "text": "show me the image"},
+            {"type": "image", "source": {"type": "base64", "data": "abc123"}},
+        ]},
+        {"role": "assistant", "content": [
+            {"type": "thinking", "thinking": "let me think..."},
+            {"type": "text", "text": "here is my answer"},
+        ]},
+    ]
+
+    sanitized = _sanitize_restored_turn(messages)
+
+    user_content = sanitized[0]["content"]
+    assert any(b.get("text") == "[image removed from restored turn]" for b in user_content)
+    assert not any(b.get("type") == "image" for b in user_content)
+
+    asst_content = sanitized[1]["content"]
+    assert not any(b.get("type") == "thinking" for b in asst_content)
+    assert any(b.get("text") == "here is my answer" for b in asst_content)
+
+
+def test_fill_pass_no_restore_tool_references():
+    """Media placeholders must NOT reference vc_restore_tool."""
+    from virtual_context.proxy.message_filter import _sanitize_restored_turn
+
+    messages = [
+        {"role": "user", "content": [
+            {"type": "input_image", "image_url": "data:image/png;base64,abc123"},
+        ]},
+    ]
+
+    sanitized = _sanitize_restored_turn(messages)
+    result_json = json.dumps(sanitized)
+    assert "vc_restore_tool" not in result_json
+    assert "image removed from restored turn" in result_json

{virtual_context-0.2.7 → virtual_context-0.2.9}/tests/test_format_agnostic.py

@@ -450,7 +450,7 @@ class TestCollapseChainsCrossFormat:
         fmt = detect_format(body)
         tti = TurnTagIndex()
         original_count = len(body["messages"])
-        result, collapsed, refs = collapse_turn_chains(
+        result, collapsed, refs, _ = collapse_turn_chains(
             body, fmt, protected_recent_turns=3, turn_tag_index=tti,
             store=None, conversation_id="test",
         )
@@ -480,7 +480,7 @@ class TestCollapseChainsCrossFormat:
         fmt = detect_format(body)
         tti = TurnTagIndex()
         original_count = len(body["input"])
-        result, collapsed, refs = collapse_turn_chains(
+        result, collapsed, refs, _ = collapse_turn_chains(
             body, fmt, protected_recent_turns=3, turn_tag_index=tti,
             store=None, conversation_id="test",
         )
@@ -507,7 +507,7 @@ class TestCollapseChainsCrossFormat:
         fmt = detect_format(body)
         tti = TurnTagIndex()
         original_count = len(body["messages"])
-        result, collapsed, refs = collapse_turn_chains(
+        result, collapsed, refs, _ = collapse_turn_chains(
             body, fmt, protected_recent_turns=3, turn_tag_index=tti,
             store=None, conversation_id="test",
         )