attocode-code-intel 0.1.18__tar.gz → 0.1.20__tar.gz

{attocode_code_intel-0.1.18 → attocode_code_intel-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: attocode-code-intel
-Version: 0.1.18
+Version: 0.1.20
 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
@@ -139,6 +139,15 @@ To use the latest source, install from a clone of this repository: `uv tool inst
 
 ## What your agent gets
 
+Version 0.1.20 improves native OCaml/Perl call candidates and conservative workspace
+import candidates for OCaml, Perl and Crystal. Physical paths and ambiguity remain
+guarded; native limits, ranking and dependencies are unchanged. Optional grammars
+must be explicitly available before analysis; navigation never downloads them.
+
+Version 0.1.19 restores source text into spare space after fitting a complete
+compact search page. Existing hits, visible text, source lines and continuations
+remain protected within the same response budget; ranking and retrieval are unchanged.
+
 Version 0.1.7 also provides `changes` and `trace` commands: investigate a diff,
 follow source-backed caller paths, export JSON/Markdown, and check or refresh saved
 evidence. MCP equivalents `change_context` and `trace_flow` are local full-profile

{attocode_code_intel-0.1.18 → attocode_code_intel-0.1.20}/README.md

@@ -26,6 +26,15 @@ To use the latest source, install from a clone of this repository: `uv tool inst
 
 ## What your agent gets
 
+Version 0.1.20 improves native OCaml/Perl call candidates and conservative workspace
+import candidates for OCaml, Perl and Crystal. Physical paths and ambiguity remain
+guarded; native limits, ranking and dependencies are unchanged. Optional grammars
+must be explicitly available before analysis; navigation never downloads them.
+
+Version 0.1.19 restores source text into spare space after fitting a complete
+compact search page. Existing hits, visible text, source lines and continuations
+remain protected within the same response budget; ranking and retrieval are unchanged.
+
 Version 0.1.7 also provides `changes` and `trace` commands: investigate a diff,
 follow source-backed caller paths, export JSON/Markdown, and check or refresh saved
 evidence. MCP equivalents `change_context` and `trace_flow` are local full-profile

{attocode_code_intel-0.1.18 → attocode_code_intel-0.1.20}/pyproject.toml

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

{attocode_code_intel-0.1.18 → attocode_code_intel-0.1.20}/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.18"
+__version__ = "0.1.20"

{attocode_code_intel-0.1.18 → attocode_code_intel-0.1.20}/src/attocode_intel/_internal/integrations/context/codebase_context.py

@@ -11,6 +11,7 @@ Provides intelligent code understanding through:
 from __future__ import annotations
 
 import os
+import posixpath
 import time
 from dataclasses import dataclass, field
 from functools import partial
@@ -523,6 +524,8 @@ def resolve_import_targets(language, module, source_file, file_index, *, include
         return file_index.namespace_candidates(language, module)
     if language == "go" and hasattr(file_index, "go_candidates"):
         return file_index.go_candidates(module, source_file)
+    if language in {"ocaml", "perl", "crystal"}:
+        return _optional_import_targets(language, module, source_file, file_index)
     resolver = IMPORT_RESOLVERS.get(language)
     target = resolver(module, source_file, file_index) if resolver else None
     return [target] if target else []
@@ -664,7 +667,55 @@ def _resolve_namespace_import(language, module, source_file, file_index):
     return candidates[0] if len(candidates) == 1 else None
 
 
+def _optional_import_targets(language, module, source_file, file_index):
+    """Conservative static workspace candidates, never compiler/load-path proof."""
+    if not isinstance(module, str) or not module or any(c in module for c in "\x00\r\n\\"):
+        return []
+    source = source_file.replace("\\", "/")
+    if source.startswith("/") or posixpath.normpath(source).startswith("../"):
+        return []
+    directory = posixpath.dirname(source)
+    groups = []
+    if language == "ocaml":
+        parts = module.split(".")
+        if not all(p.isidentifier() and p[0].isupper() for p in parts):
+            return []
+        name = parts[0]
+        stems = {name, name[0].lower() + name[1:]}
+        for root in {"", directory}:
+            for stem in stems:
+                groups.append({posixpath.join(root, stem + suffix) for suffix in (".ml", ".mli")})
+    elif language == "perl":
+        parts = module.split("::")
+        if not all(p.isidentifier() for p in parts):
+            return []
+        name = "/".join(parts) + ".pm"
+        groups = [{name}, {"lib/" + name}]
+    elif language == "crystal":
+        if not module.startswith(("./", "../")) or any(c in module for c in '*?[]#"\'`') or module.endswith('/'):
+            return []
+        name = posixpath.normpath(posixpath.join(directory, module))
+        if name in {".", ".."} or name.startswith(("/", "../")):
+            return []
+        groups = [{name if name.endswith(".cr") else name + ".cr"}]
+    # A module can have an implementation and interface, but competing source
+    # roots or filename casings are ambiguous. Do not pick the first match.
+    # Python import roots add stripped aliases for every file type. Optional
+    # language conventions require the actual physical path, not those aliases.
+    matches = {tuple(sorted({file_index[key] for key in group
+                            if key in file_index and file_index[key].replace("\\", "/") == key}))
+               for group in groups}
+    matches.discard(())
+    return list(next(iter(matches))) if len(matches) == 1 else []
+
+
+def _optional_import_target(language, module, source_file, file_index):
+    targets = _optional_import_targets(language, module, source_file, file_index)
+    return targets[0] if len(targets) == 1 else None
+
+
 IMPORT_RESOLVERS = {
+    **{language: partial(_optional_import_target, language) for language in ("ocaml", "perl", "crystal")},
     "python": _resolve_python_import, "javascript": _resolve_js_import,
     "typescript": _resolve_js_import, "rust": _resolve_rust_import,
     "go": _resolve_go_import, "java": _resolve_java_import,

{attocode_code_intel-0.1.18 → attocode_code_intel-0.1.20}/src/attocode_intel/_internal/integrations/context/syntax_evidence.py

@@ -79,7 +79,9 @@ def reference_candidates(path: str, content: str, language: str):
         if node.type in {"comment", "line_comment", "block_comment", "string", "string_literal"}:
             continue
         if node.type in {"call", "call_expression", "method_invocation", "object_creation_expression", "new_expression",
-                         "function_call", "invocation_expression", "scoped_call_expression", "command"}:
+                         "function_call", "invocation_expression", "scoped_call_expression", "command"} or (
+                language == "ocaml" and node.type == "application_expression") or (
+                language == "perl" and node.type == "function_call_expression"):
             target = (node.child_by_field_name("function") or node.child_by_field_name("name")
                       or node.child_by_field_name("constructor") or node.child_by_field_name("target")
                       or node.child_by_field_name("method"))

{attocode_code_intel-0.1.18 → attocode_code_intel-0.1.20}/src/attocode_intel/_internal/integrations/context/ts_parser.py

@@ -297,7 +297,7 @@ LANGUAGE_CONFIGS: dict[str, _LangConfig] = {
         grammar_module="tree_sitter_ocaml",
         function_types=("let_binding",),
         class_types=("type_definition", "module_definition", "class_definition"),
-        import_types=("open_statement",),
+        import_types=("open_statement", "open_module"),
         language_func="language_ocaml",
     ),
     "fsharp": _LangConfig(
@@ -862,9 +862,13 @@ def _extract_import_module(node, source_bytes: bytes, language: str) -> str:
                 if len(parts) >= 2:
                     return parts[1]
     elif language == "ocaml":
-        # open Module_name
-        if text.startswith("open "):
+        # New grammars use open_module; only a static module path is evidence.
+        module = node.child_by_field_name("module")
+        if module is not None and module.type == "module_path":
+            return _node_text(module, source_bytes)
+        if node.type == "open_statement" and text.startswith("open "):
             return text[5:].strip()
+        return ""
     elif language == "fsharp":
         # open System.Collections.Generic or module M = Module.Path
         if text.startswith("open "):

{attocode_code_intel-0.1.18 → attocode_code_intel-0.1.20}/src/attocode_intel/output.py

@@ -140,6 +140,73 @@ def _fill_search_prefix(metadata, data, rows, total, max_tokens, *, upstream_tru
     return compact_result(metadata, data)
 
 
+
+_SEARCH_SNIPPET_PROBES = 12
+_SNIPPET_FIELDS = ("snippet", "snippet_start_line", "snippet_end_line", "snippet_truncated")
+
+
+def _restore_search_snippets(result, originals, max_tokens, *, upstream_truncated=False):
+    """Spend spare space without replacing any evidence on the fitted page.
+
+    BPE counts and anchored windows need not be monotone. These are bounded
+    probes, not a maximality search; every accepted page is checked in full.
+    """
+    page = json.loads(result.content[0].text)
+    remaining = _SEARCH_SNIPPET_PROBES
+    for index, original in enumerate(originals[:len(page["data"]["results"])]):
+        if not remaining:
+            break
+        delivered = page["data"]["results"][index]
+        if (not all(key in original and key in delivered for key in _SNIPPET_FIELDS)
+                or {k: v for k, v in original.items() if k not in _SNIPPET_FIELDS}
+                != {k: v for k, v in delivered.items() if k not in _SNIPPET_FIELDS}):
+            continue
+        body = original["snippet"]
+        if (not isinstance(body, str) or not isinstance(delivered["snippet"], str)
+                or len(body) <= len(delivered["snippet"])):
+            continue
+
+        def probe(window, *, position=index):
+            nonlocal remaining, page, result
+            remaining -= 1
+            current = page["data"]["results"][position]
+            if (len(window["snippet"]) <= len(current["snippet"])
+                    or current["snippet"] not in window["snippet"]):
+                return "skip"
+            old_first, old_last = current["snippet_start_line"], current["snippet_end_line"]
+            first, last = window["snippet_start_line"], window["snippet_end_line"]
+            if old_first is None and old_last is None:
+                if first is not None or last is not None:
+                    return "skip"
+            elif (not all(type(n) is int for n in (old_first, old_last, first, last))
+                  or not 1 <= first <= old_first <= old_last <= last):
+                return "skip"
+            trial = deepcopy(page)
+            trial["data"]["results"][position].update(window)
+            _search_truncation(trial["metadata"], trial["data"], upstream_truncated)
+            candidate = compact_result(trial["metadata"], trial["data"])
+            if response_tokens(candidate) > max_tokens:
+                return "over"
+            page, result = trial, candidate
+            return "fit"
+
+        # The original window is the only source of additional text. Check it
+        # first, then retain the best tested larger anchored window that fits.
+        if probe({key: original[key] for key in _SNIPPET_FIELDS}) == "fit":
+            continue
+        lo, hi = len(delivered["snippet"]) + 1, len(body) - 1
+        while lo <= hi and remaining:
+            cap = (lo + hi) // 2
+            window = snippet_window(body, page["data"].get("query", ""), cap,
+                                    original["snippet_start_line"])
+            window["snippet_truncated"] |= original["snippet_truncated"]
+            if probe(window) == "over":
+                hi = cap - 1
+            else:
+                lo = cap + 1
+    return result
+
+
 def bounded_search(metadata, data, max_tokens, *, all_results, follow_up=None):
     """Fit search delivery, reserving a progressing retry after final omissions."""
     payload = deepcopy(data)
@@ -179,7 +246,8 @@ def bounded_search(metadata, data, max_tokens, *, all_results, follow_up=None):
             and len(delivered["data"]["results"]) >= delivered["data"]["ranking"]["candidate_pool_count"]):
         delivered["data"].pop("follow_up", None)
         result = compact_result(delivered["metadata"], delivered["data"])
-    return result
+    return _restore_search_snippets(result, all_results, max_tokens,
+                                    upstream_truncated=metadata.get("truncated", False))
 
 
 def bounded_compact(metadata: dict, data, max_tokens: int, *, search_results=None) -> types.CallToolResult:

attocode_code_intel-0.1.20/tests/test_experiment_dispatch.py

@@ -0,0 +1,176 @@
+"""Real import/body controls for maintained experiment bindings; no trial runs."""
+from __future__ import annotations
+
+import importlib
+import json
+import sys
+import uuid
+import warnings
+
+import pytest
+import yaml
+
+from eval.quality import experiments
+
+
+@pytest.fixture
+def operator_case(tmp_path, monkeypatch):
+    """Place real isolated Python operators on the existing package search path."""
+    import eval.quality
+
+    repo = tmp_path / "repo"
+    package = repo / "eval/quality"
+    package.mkdir(parents=True)
+    root = tmp_path / "attempt"
+    (root / "evidence").mkdir(parents=True)
+    monkeypatch.setenv("ATTOCODE_EXPERIMENT_ENGINE", str(experiments.ENGINE))
+    monkeypatch.setattr(experiments, "REPO", repo)
+    monkeypatch.setattr(eval.quality, "__path__", [str(package), *eval.quality.__path__])
+    modules = []
+
+    def make(source, *, alias=False, registered=True, shadow=False):
+        name = "dispatch_test_" + uuid.uuid4().hex
+        stem = name + ("_bound" if alias else "_experiment")
+        module = "eval.quality." + stem
+        path = package / (stem + ".py")
+        if shadow:
+            other = tmp_path / "shadow"
+            other.mkdir()
+            monkeypatch.setattr(eval.quality, "__path__", [str(other), str(package), *eval.quality.__path__])
+            path.write_text("def run(root):\n    raise AssertionError('declared source must not execute')\n")
+            path = other / path.name
+        if source is not None:
+            path.write_text(source)
+        bindings = dict(getattr(experiments, "OPERATORS", {}))
+        if registered:
+            bindings[name] = module
+        monkeypatch.setattr(experiments, "OPERATORS", bindings, raising=False)
+        modules.append(module)
+        importlib.invalidate_caches()
+        return name, root, path
+
+    yield make
+    for module in modules:
+        sys.modules.pop(module, None)
+    importlib.invalidate_caches()
+
+
+GOOD = "def run(root):\n    (root / 'body-ran').write_text(str(root))\n"
+
+
+def rejection(name, root):
+    error = None
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", message="coroutine .* was never awaited", category=RuntimeWarning)
+        try:
+            experiments.payload(name, root)
+        except Exception as caught:
+            error = caught
+    assert isinstance(error, ValueError), "dispatcher binding guard: invalid handler not explicitly rejected"
+    assert not (root / "body-ran").exists()
+    assert not (root / "evidence/controller-complete.json").exists()
+    return error
+
+
+def test_explicit_alias_uses_registered_module(operator_case):
+    name, root, _ = operator_case(GOOD, alias=True)
+    error = None
+    try:
+        experiments.payload(name, root)
+    except Exception as caught:
+        error = caught
+    assert error is None, "dispatcher binding guard: registered alias was guessed from its name"
+    assert (root / "body-ran").read_text() == str(root)
+    assert json.loads((root / "evidence/controller-complete.json").read_text())["complete"] is True
+
+
+def test_unregistered_conventional_module_never_runs(operator_case):
+    name, root, _ = operator_case(GOOD, registered=False)
+    rejection(name, root)
+
+
+@pytest.mark.parametrize("source", [
+    "answer = 42\n",
+    "run = 42\n",
+    "def run():\n    raise AssertionError('body')\n",
+    "def run(root, required):\n    (root / 'body-ran').touch()\n",
+    "def run(root, *, required):\n    (root / 'body-ran').touch()\n",
+    "async def run(root):\n    (root / 'body-ran').touch()\n",
+    "class Runner:\n    async def __call__(self, root):\n        (root / 'body-ran').touch()\nrun = Runner()\n",
+    "def run(root):\n    (root / 'body-ran').touch()\n    yield None\n",
+    "class Runner:\n    def __call__(self, root):\n        (root / 'body-ran').touch()\n        yield None\nrun = Runner()\n",
+    "async def run(root):\n    (root / 'body-ran').touch()\n    yield None\n",
+    "class Runner:\n    async def __call__(self, root):\n        (root / 'body-ran').touch()\n        yield None\nrun = Runner()\n",
+], ids=["missing", "noncallable", "no-root", "extra-required", "keyword-required", "async", "async-callable",
+        "generator", "generator-callable", "async-generator", "async-generator-callable"])
+def test_invalid_entrypoint_rejected_before_body(operator_case, source):
+    name, root, _ = operator_case(source)
+    rejection(name, root)
+
+
+def test_missing_module_is_explicit_binding_error(operator_case):
+    name, root, _ = operator_case(None)
+    error = rejection(name, root)
+    assert isinstance(error.__cause__, ModuleNotFoundError)
+
+
+def test_import_error_keeps_original_cause(operator_case):
+    name, root, _ = operator_case("raise RuntimeError('retained import trigger')\n")
+    error = rejection(name, root)
+    assert isinstance(error.__cause__, RuntimeError)
+    assert str(error.__cause__) == "retained import trigger"
+
+
+def test_shadow_module_cannot_execute_body(operator_case):
+    name, root, _ = operator_case(GOOD, shadow=True)
+    rejection(name, root)
+
+
+@pytest.mark.parametrize("source", [
+    GOOD,
+    "def run(root, /):\n    (root / 'body-ran').write_text(str(root))\n",
+    "def run(root, option=42):\n    assert option == 42\n    (root / 'body-ran').write_text(str(root))\n",
+], ids=["ordinary", "positional-only", "optional"])
+def test_compatible_root_entrypoint_runs(operator_case, source):
+    name, root, _ = operator_case(source)
+    experiments.payload(name, root)
+    assert (root / "body-ran").read_text() == str(root)
+
+
+@pytest.mark.parametrize("name", ["native", "preview", "restart"])
+def test_maintained_operator_qualifies_without_running(name):
+    loader = getattr(experiments, "load_operator", None)
+    assert callable(loader), "dispatcher binding guard: maintained qualification is missing"
+    operator = loader(name)
+    assert callable(operator)
+    assert operator.__module__ == "eval.quality." + name + "_experiment"
+
+
+@pytest.mark.parametrize("name", ["preflight", "broad"])
+def test_inline_handler_qualification_needs_no_operator(name):
+    loader = getattr(experiments, "load_operator", None)
+    assert callable(loader), "dispatcher binding guard: maintained qualification is missing"
+    assert loader(name) is None
+
+
+def test_workflow_choices_and_registered_targets_qualify():
+    registry = getattr(experiments, "OPERATORS", None)
+    assert registry is not None, "dispatcher binding guard: explicit bindings are missing"
+    workflow = yaml.safe_load((experiments.REPO / ".github/workflows/intelligence-experiments.yml").read_text())
+    trigger = workflow.get("on", workflow.get(True))
+    choices = trigger["workflow_dispatch"]["inputs"]["experiment"]["options"]
+    assert len(choices) == len(set(choices))
+    assert set(choices) == set(experiments.SECONDS) == {"preflight", "broad", *registry}
+    for name in registry:
+        assert callable(experiments.load_operator(name))
+
+
+def test_engine_guard_precedes_operator_import(operator_case, monkeypatch):
+    name, root, path = operator_case(GOOD)
+    marker = root / "import-ran"
+    path.write_text("from pathlib import Path\nPath(" + repr(str(marker)) + ").touch()\n" + GOOD)
+    monkeypatch.setenv("ATTOCODE_EXPERIMENT_ENGINE", str(root / "wrong-engine"))
+    with pytest.raises(ValueError, match="engine_origin"):
+        experiments.payload(name, root)
+    assert not marker.exists()
+    assert not (root / "body-ran").exists()