attocode-code-intel 0.1.26__tar.gz → 0.1.27__tar.gz

{attocode_code_intel-0.1.26 → attocode_code_intel-0.1.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: attocode-code-intel
-Version: 0.1.26
+Version: 0.1.27
 Summary: Local code search and navigation for coding agents and people
 Project-URL: Homepage, https://github.com/eren23/attocode
 Project-URL: Repository, https://github.com/eren23/attocode
@@ -156,6 +156,8 @@ To use the latest source, install from a clone of this repository: `uv tool inst
 
 ## What your agent gets
 
+Version 0.1.27 fixes a dictionary-size error during symbol inspection when AST hydration changes the cache concurrently. Namespace resolution snapshots cached file membership; later changes appear in the next build. See the [release notes](https://github.com/eren23/attocode/blob/main/docs/intelligence-0.1.27.md).
+
 Version 0.1.26 gives Rust precision lookups a shared five-second budget and fixes cancelled startup cleanup when a child retains inherited pipes. Other languages keep two seconds; longer reloads still return partial evidence.
 
 Version 0.1.25 uses OpenAI embeddings only when you set `ATTOCODE_EMBEDDING_MODEL=openai`. Before, an `OPENAI_API_KEY` in the environment was enough to send code chunks to OpenAI at index time. Rust references are also more reliable while rust-analyzer loads.

{attocode_code_intel-0.1.26 → attocode_code_intel-0.1.27}/README.md

@@ -43,6 +43,8 @@ To use the latest source, install from a clone of this repository: `uv tool inst
 
 ## What your agent gets
 
+Version 0.1.27 fixes a dictionary-size error during symbol inspection when AST hydration changes the cache concurrently. Namespace resolution snapshots cached file membership; later changes appear in the next build. See the [release notes](https://github.com/eren23/attocode/blob/main/docs/intelligence-0.1.27.md).
+
 Version 0.1.26 gives Rust precision lookups a shared five-second budget and fixes cancelled startup cleanup when a child retains inherited pipes. Other languages keep two seconds; longer reloads still return partial evidence.
 
 Version 0.1.25 uses OpenAI embeddings only when you set `ATTOCODE_EMBEDDING_MODEL=openai`. Before, an `OPENAI_API_KEY` in the environment was enough to send code chunks to OpenAI at index time. Rust references are also more reliable while rust-analyzer loads.

{attocode_code_intel-0.1.26 → attocode_code_intel-0.1.27}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "attocode-code-intel"
-version = "0.1.26"
+version = "0.1.27"
 description = "Local code search and navigation for coding agents and people"
 readme = "README.md"
 requires-python = ">=3.12"

{attocode_code_intel-0.1.26 → attocode_code_intel-0.1.27}/src/attocode_intel/__init__.py

@@ -49,4 +49,4 @@ def __getattr__(name: str) -> Any:
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 # The other copy is packages/code-intel/pyproject.toml. A test checks that both match.
-__version__ = "0.1.26"
+__version__ = "0.1.27"

{attocode_code_intel-0.1.26 → attocode_code_intel-0.1.27}/src/attocode_intel/_internal/integrations/context/module_resolution.py

@@ -165,7 +165,8 @@ class FileIndex(dict):
 
     def configure_namespaces(self, asts):
         self.namespace_files = defaultdict(lambda: defaultdict(dict))
-        for path, ast in asts.items():
+        # Hydration can change cache membership while namespace members are read.
+        for path, ast in asts.copy().items():
             names = {c.name for c in ast.classes} | {f.name for f in ast.functions}
             for namespace in ast.namespaces + ([c.name for c in ast.classes] if ast.language == "elixir" else []):
                 self.namespace_files[ast.language][namespace.replace('\\', '.')][path] = names

attocode_code_intel-0.1.27/tests/test_namespace_snapshot.py

@@ -0,0 +1,60 @@
+"""Namespace reads keep stable membership while AST hydration publishes files."""
+from concurrent.futures import ThreadPoolExecutor
+from threading import Event
+from types import SimpleNamespace
+
+import pytest
+from attocode_intel._internal.integrations.context.module_resolution import FileIndex
+
+
+@pytest.mark.parametrize('mutation', ['grow', 'shrink'])
+def test_namespace_lookup_snapshots_cache_during_hydration(mutation):
+    reading, changed = Event(), Event()
+
+    def ast(name):
+        return SimpleNamespace(language='php', namespaces=[r'Acme\Core'],
+                               classes=[SimpleNamespace(name=name)],
+                               functions=[SimpleNamespace(name=name.lower())])
+
+    class FirstAST:
+        language = 'php'
+        namespaces = [r'Acme\Core']
+        functions = [SimpleNamespace(name='first')]
+
+        @property
+        def classes(self):
+            if not reading.is_set():
+                reading.set()
+                assert changed.wait(5), 'hydration did not publish its cache update'
+            return [SimpleNamespace(name='First')]
+
+    cache = {'first.php': FirstAST(), 'second.php': ast('Second')}
+    index = FileIndex({name: name for name in ('first.php', 'second.php', 'late.php')})
+
+    def hydrate():
+        try:
+            assert reading.wait(5), 'namespace traversal did not start'
+            if mutation == 'grow':
+                cache['late.php'] = ast('Late')
+            else:
+                del cache['second.php']
+        finally:
+            changed.set()
+
+    with ThreadPoolExecutor(max_workers=1) as pool:
+        publication = pool.submit(hydrate)
+        try:
+            index.configure_namespaces(cache)
+        finally:
+            reading.set()
+            publication.result(timeout=5)
+
+    assert index.namespace_candidates('php', r'Acme\Core\First') == ['first.php']
+    assert index.namespace_candidates('php', r'Acme\Core\first') == ['first.php']
+    assert index.namespace_candidates('php', r'Acme\Core\Second') == ['second.php']
+    assert index.namespace_candidates('php', r'Acme\Core\Late') == []
+
+    # The next build sees the new membership; the snapshot is local to one read.
+    index.configure_namespaces(cache)
+    assert index.namespace_candidates('php', r'Acme\Core\Late') == (['late.php'] if mutation == 'grow' else [])
+    assert index.namespace_candidates('php', r'Acme\Core\Second') == (['second.php'] if mutation == 'grow' else [])

{attocode_code_intel-0.1.26 → attocode_code_intel-0.1.27}/tests/test_quality_evidence.py

@@ -208,6 +208,59 @@ def test_interrupted_pack_preserves_completed_checks_and_stops_its_worker(tmp_pa
     assert result['status'] == 'incomplete'
     assert result['checks'][0]['name'] == 'source'
     assert child.poll() is not None
+    assert result['worker_limit_seconds'] == .5
+    assert result['worker_seconds'] >= result['worker_wait_seconds'] >= .5
+
+
+@pytest.mark.parametrize('exit_code,checkpointed', [(0, True), (7, True), (0, False)])
+def test_pack_reports_parent_worker_lifetime_and_separate_wait_budget(tmp_path, monkeypatch, exit_code, checkpointed):
+    import subprocess
+    import time
+
+    from eval.quality import corpus
+
+    original_launch, original_stop = subprocess.Popen, corpus.stop_group
+    boundaries = {}
+    children = []
+    checkpoint = {'checks': [{'name': 'source', 'outcome': 'passed'}], 'retrieval': [],
+                  'worker_seconds': 999, 'worker_wait_seconds': 999, 'worker_limit_seconds': 999}
+
+    def launch(command, **kwargs):
+        boundaries['launch'] = time.monotonic()
+        time.sleep(.05)
+        program = (
+            'import json,pathlib,sys,time; '
+            'pathlib.Path(sys.argv[1]).write_text(sys.argv[2]) if sys.argv[3] == "yes" else None; '
+            'time.sleep(.05); sys.exit(int(sys.argv[4]))'
+        )
+        child = original_launch([sys.executable, '-c', program, str(tmp_path / 'worker.json'),
+                                 json.dumps(checkpoint), 'yes' if checkpointed else 'no', str(exit_code)], **kwargs)
+        children.append(child)
+        return child
+
+    def stop(child):
+        original_stop(child)
+        time.sleep(.05)
+        boundaries['cleanup'] = time.monotonic()
+
+    monkeypatch.setattr(corpus.subprocess, 'Popen', launch)
+    monkeypatch.setattr(corpus, 'stop_group', stop)
+    monkeypatch.setattr(corpus, 'PACK_SECONDS', 10)
+    started = time.monotonic()
+    result = corpus.evaluate_isolated(tmp_path, {'id': 'fixture'}, tmp_path)
+    elapsed = time.monotonic() - started
+
+    assert boundaries['cleanup'] - boundaries['launch'] <= result['worker_seconds'] <= elapsed
+    assert 0 < result['worker_wait_seconds'] <= result['worker_seconds'] - .1
+    assert result['worker_limit_seconds'] == 10
+    assert children[0].poll() is not None
+    assert result['checks'] == (checkpoint['checks'] if checkpointed else [])
+    assert result['retrieval'] == []
+    if exit_code or not checkpointed:
+        assert result['status'] == 'incomplete'
+        assert 'Workflow worker failed' in result['error']
+    else:
+        assert 'error' not in result and result.get('status') != 'incomplete'
 
 
 def test_resume_refuses_changed_inputs_and_missing_question_observations():