attocode-code-intel 0.1.24__tar.gz → 0.1.25__tar.gz

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: attocode-code-intel
-Version: 0.1.24
+Version: 0.1.25
 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.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.
+
 Version 0.1.24 adds `ATTOCODE_INTEL_RANKING_PROVIDER=openrouter`, a preset for the opt-in hosted rerank. In a frozen trial with 24 short questions, the rerank found 24 of 26 labeled files in the first five results, against 20 without it; see [Hosted rerank](https://github.com/eren23/attocode/blob/main/docs/intelligence-search.md#hosted-rerank-experimental). Rerank stays off by default, because it sends source excerpts to OpenRouter.
 
 Version 0.1.23 is listed in the official MCP Registry and documents a `uvx` quick start. The opt-in hosted rerank now accepts the dated model ID that OpenRouter returns; see [Hosted rerank](https://github.com/eren23/attocode/blob/main/docs/intelligence-search.md#hosted-rerank-experimental). Rerank stays off by default.

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.25}/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.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.
+
 Version 0.1.24 adds `ATTOCODE_INTEL_RANKING_PROVIDER=openrouter`, a preset for the opt-in hosted rerank. In a frozen trial with 24 short questions, the rerank found 24 of 26 labeled files in the first five results, against 20 without it; see [Hosted rerank](https://github.com/eren23/attocode/blob/main/docs/intelligence-search.md#hosted-rerank-experimental). Rerank stays off by default, because it sends source excerpts to OpenRouter.
 
 Version 0.1.23 is listed in the official MCP Registry and documents a `uvx` quick start. The opt-in hosted rerank now accepts the dated model ID that OpenRouter returns; see [Hosted rerank](https://github.com/eren23/attocode/blob/main/docs/intelligence-search.md#hosted-rerank-experimental). Rerank stays off by default.

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.25}/pyproject.toml

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

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.25}/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.24"
+__version__ = "0.1.25"

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.25}/src/attocode_intel/_internal/integrations/context/embeddings.py

@@ -1,10 +1,13 @@
 """Embedding provider abstraction for semantic search.
 
-Tries providers in order:
-1. Local: sentence-transformers with code-optimized model (no API cost)
+Auto-detect tries local providers only:
+1. Local: sentence-transformers with code-trained or code-optimized models
 2. Local: sentence-transformers with general model (smaller fallback)
-3. API: OpenAI text-embedding-3-small (if OPENAI_API_KEY set)
-4. None: graceful degradation (returns empty vectors)
+3. None: graceful degradation (returns empty vectors)
+
+The OpenAI API sends source text off the machine. It is used only when
+``ATTOCODE_EMBEDDING_MODEL=openai`` (or ``model="openai"``) selects it, never
+because ``OPENAI_API_KEY`` is set, and never with ``ATTOCODE_LOCAL_ONLY``.
 """
 
 from __future__ import annotations
@@ -172,14 +175,20 @@ def create_embedding_provider(
             - "bge" (768-dim, recommended for code search)
             - "all-MiniLM-L6-v2" (384-dim, fast, smaller)
             - "nomic-embed-text" (768-dim, better code understanding)
-            - "openai" (API-based, requires OPENAI_API_KEY)
-            - "" (auto-detect best available)
+            - "openai" (API-based, requires OPENAI_API_KEY; sends source text)
+            - "" (auto-detect best available local provider)
 
-    Auto-detect order: bge (code-optimized) > MiniLM > OpenAI API > null.
+    Auto-detect order: nomic > bge > MiniLM > null. It never selects a remote
+    provider, so an API key in the environment alone sends no source text.
     Note: switching models requires reindexing (different vector dims).
     """
     model = model or os.environ.get("ATTOCODE_EMBEDDING_MODEL", "")
 
+    # Checked before the cache, so a provider created earlier is not reused.
+    if model == "openai" and os.environ.get("ATTOCODE_LOCAL_ONLY", "").lower() in {"1", "true", "yes", "on"}:
+        logger.warning("ATTOCODE_LOCAL_ONLY is set; refusing the OpenAI embedding provider")
+        return NullEmbeddingProvider()
+
     if model in _provider_cache:
         return _provider_cache[model]
 
@@ -251,7 +260,7 @@ def create_embedding_provider(
         _provider_cache[model] = provider
         return provider
     except ImportError:
-        logger.debug("sentence-transformers not installed, trying OpenAI")
+        logger.debug("sentence-transformers not installed")
     except Exception as exc:
         logger.info("BGE model unavailable (%s), falling back to MiniLM", exc)
         try:
@@ -260,23 +269,11 @@ def create_embedding_provider(
             _provider_cache[model] = provider
             return provider
         except ImportError:
-            logger.debug("sentence-transformers not installed, trying OpenAI")
+            logger.debug("sentence-transformers not installed")
         except Exception as exc2:
             logger.warning("Local embedding provider unavailable: %s", exc2)
             logger.debug("Local embedding provider traceback", exc_info=True)
 
-    # Try OpenAI API
-    if os.environ.get("OPENAI_API_KEY"):
-        try:
-            provider = OpenAIEmbeddingProvider()
-            logger.info("Using OpenAI embedding provider: %s", provider.name)
-            _provider_cache[model] = provider
-            return provider
-        except ImportError:
-            logger.debug("openai package not installed")
-        except Exception:
-            logger.debug("OpenAI embedding provider failed", exc_info=True)
-
     # Graceful degradation — don't cache so retry picks up newly installed packages
     logger.info("No embedding provider available; semantic search will use keyword fallback")
     return NullEmbeddingProvider()

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.25}/src/attocode_intel/_internal/integrations/context/systemone_ranker.py

@@ -24,6 +24,85 @@ _MAX_RESPONSE_BYTES = 64 * 1024
 _REMOTE_BLOCKED = {"1", "true", "yes", "on"}
 
 
+def workspace_consent(opt_in: bool, workspace: str, project_dir: str) -> bool:
+    """The hosted-source consent: an opt-in and this exact absolute project directory."""
+    return opt_in and os.path.isabs(workspace) and os.path.realpath(workspace) == project_dir
+
+
+def check_endpoint(endpoint: str, *, allow_remote: bool, service_mode: bool, auth_env: str) -> bool:
+    """Validate an opt-in hosted endpoint; return whether it is remote.
+
+    Raises ``ValueError`` for an unsafe URL, a refused remote endpoint or an
+    auth setting that is not an environment-variable name.
+    """
+    parsed = urlsplit(endpoint)
+    try:
+        host = parsed.hostname
+        _ = parsed.port
+    except ValueError as exc:
+        raise ValueError("invalid ranking endpoint") from exc
+    if (
+        parsed.scheme not in {"http", "https"}
+        or not host
+        or not parsed.path
+        or parsed.username
+        or parsed.password
+        or parsed.query
+        or parsed.fragment
+    ):
+        raise ValueError(
+            "ranking endpoint must be an absolute HTTP(S) URL without credentials or query"
+        )
+    try:
+        loopback = ipaddress.ip_address(host).is_loopback
+    except ValueError:
+        # A hostname can resolve differently between validation and use.
+        # Local source access requires an explicit loopback IP literal.
+        loopback = False
+    if not loopback and parsed.scheme != "https":
+        raise ValueError("non-loopback ranking endpoints require HTTPS")
+    if not loopback and (
+        not allow_remote
+        or service_mode
+        or os.environ.get("ATTOCODE_LOCAL_ONLY", "").lower() in _REMOTE_BLOCKED
+    ):
+        raise ValueError("remote source ranking is not permitted")
+    if auth_env and re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", auth_env) is None:
+        raise ValueError("ranking credential must be an environment-variable name")
+    return not loopback
+
+
+def post_json(
+    endpoint: str,
+    body: dict,
+    headers: dict[str, str],
+    timeout_seconds: float,
+    transport: httpx.BaseTransport | None,
+    max_bytes: int = _MAX_RESPONSE_BYTES,
+) -> object:
+    """POST JSON and decode a response of at most ``max_bytes`` (64 KiB)."""
+    # Do not inherit proxy settings or follow a redirect to a different
+    # origin; both could silently send source to an unapproved host.
+    with (
+        httpx.Client(
+            timeout=timeout_seconds,
+            trust_env=False,
+            follow_redirects=False,
+            transport=transport,
+        ) as client,
+        client.stream("POST", endpoint, json=body, headers=headers) as response,
+    ):
+        response.raise_for_status()
+        chunks: list[bytes] = []
+        size = 0
+        for chunk in response.iter_bytes():
+            size += len(chunk)
+            if size > max_bytes:
+                raise ValueError("ranking response too large")
+            chunks.append(chunk)
+    return json.loads(b"".join(chunks))
+
+
 class SystemOneChoiceReranker:
     """One ``choice`` request for a bounded page of distinct files.
 
@@ -46,40 +125,9 @@ class SystemOneChoiceReranker:
         max_excerpt_chars: int = 1350,
         transport: httpx.BaseTransport | None = None,
     ) -> None:
-        parsed = urlsplit(endpoint)
-        try:
-            host = parsed.hostname
-            _ = parsed.port
-        except ValueError as exc:
-            raise ValueError("invalid ranking endpoint") from exc
-        if (
-            parsed.scheme not in {"http", "https"}
-            or not host
-            or not parsed.path
-            or parsed.username
-            or parsed.password
-            or parsed.query
-            or parsed.fragment
-        ):
-            raise ValueError(
-                "ranking endpoint must be an absolute HTTP(S) URL without credentials or query"
-            )
-        try:
-            loopback = ipaddress.ip_address(host).is_loopback
-        except ValueError:
-            # A hostname can resolve differently between validation and use.
-            # Local source access requires an explicit loopback IP literal.
-            loopback = False
-        if not loopback and parsed.scheme != "https":
-            raise ValueError("non-loopback ranking endpoints require HTTPS")
-        if not loopback and (
-            not allow_remote
-            or service_mode
-            or os.environ.get("ATTOCODE_LOCAL_ONLY", "").lower() in _REMOTE_BLOCKED
-        ):
-            raise ValueError("remote source ranking is not permitted")
-        if auth_env and re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", auth_env) is None:
-            raise ValueError("ranking credential must be an environment-variable name")
+        loopback = not check_endpoint(
+            endpoint, allow_remote=allow_remote, service_mode=service_mode, auth_env=auth_env
+        )
         if timeout_seconds is None:
             timeout_seconds = 5.0 if loopback else 0.8
         if not 1 <= max_candidates <= 64 or not 0 < timeout_seconds <= 30:
@@ -106,26 +154,7 @@ class SystemOneChoiceReranker:
         return True
 
     def _post(self, body: dict, headers: dict[str, str]) -> dict:
-        # Do not inherit proxy settings or follow a redirect to a different
-        # origin; both could silently send source to an unapproved host.
-        with (
-            httpx.Client(
-                timeout=self.timeout_seconds,
-                trust_env=False,
-                follow_redirects=False,
-                transport=self._transport,
-            ) as client,
-            client.stream("POST", self.endpoint, json=body, headers=headers) as response,
-        ):
-            response.raise_for_status()
-            chunks: list[bytes] = []
-            size = 0
-            for chunk in response.iter_bytes():
-                size += len(chunk)
-                if size > _MAX_RESPONSE_BYTES:
-                    raise ValueError("ranking response too large")
-                chunks.append(chunk)
-        result = json.loads(b"".join(chunks))
+        result = post_json(self.endpoint, body, headers, self.timeout_seconds, self._transport)
         if not isinstance(result, dict):
             raise ValueError("invalid ranking response")
         # Workers AI wraps every answer as {"result": {...}, "success": true, "errors": []}.

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.25}/src/attocode_intel/_internal/integrations/lsp/client.py

@@ -194,6 +194,10 @@ class _LSPClient:
         self._stderr_task: asyncio.Task[None] | None = None
         self._is_stopping = False  # Suppress spurious errors during shutdown
         self._trace_enabled = False  # Protocol tracing (set via feature flag)
+        # rust-analyzer replies null while its VFS loads; experimental/serverStatus
+        # tells when it is ready. Servers that send no status count as ready.
+        self._ready = asyncio.Event()
+        self._ready.set()
 
     @property
     def language_id(self) -> str:
@@ -210,6 +214,7 @@ class _LSPClient:
     async def start(self) -> None:
         """Start the language server and initialize it."""
         self._documents.clear()
+        self._ready.set()
         self._process = await asyncio.create_subprocess_exec(  # noqa: S603
             self._config.command,
             *self._config.args,
@@ -231,6 +236,7 @@ class _LSPClient:
             "rootUri": self._root_uri,
             "workspaceFolders": [{"uri": self._root_uri, "name": "workspace"}],
             "capabilities": {
+                "experimental": {"serverStatusNotification": True},
                 "workspace": {"workspaceFolders": True},
                 "textDocument": {
                     "completion": {"completionItem": {"snippetSupport": True}},
@@ -461,8 +467,13 @@ class _LSPClient:
         line: int,
         character: int,
         include_declaration: bool = True,
-    ) -> list[LSPLocation]:
-        """Get all references to a symbol."""
+    ) -> list[LSPLocation] | None:
+        """Get all references to a symbol.
+
+        Returns None when the server replied null. A server that is not ready
+        (rust-analyzer while its VFS loads) does this; an answer with no
+        references is an empty list.
+        """
         if not self._initialized:
             return []
 
@@ -471,7 +482,9 @@ class _LSPClient:
             "position": {"line": line, "character": character},
             "context": {"includeDeclaration": include_declaration},
         })
-        if not result or not isinstance(result, list):
+        if result is None:
+            return None
+        if not isinstance(result, list):
             return []
 
         return [
@@ -806,9 +819,24 @@ class _LSPClient:
         elif "method" in message:
             self._handle_notification(message["method"], message.get("params"))
 
+    async def wait_ready(self, timeout: float) -> bool:
+        """Wait up to ``timeout`` seconds until the server reports it is ready."""
+        if self._ready.is_set():
+            return True
+        try:
+            await asyncio.wait_for(self._ready.wait(), max(timeout, 0))
+        except TimeoutError:
+            return False
+        return True
+
     def _handle_notification(self, method: str, params: Any) -> None:
         """Handle server notification."""
-        if method == "textDocument/publishDiagnostics" and self._on_diagnostics:
+        if method == "experimental/serverStatus" and isinstance(params, dict):
+            if params.get("quiescent"):
+                self._ready.set()
+            else:
+                self._ready.clear()
+        elif method == "textDocument/publishDiagnostics" and self._on_diagnostics:
             uri = params.get("uri", "")
             raw_diags = params.get("diagnostics", [])
             severity_map = {1: "error", 2: "warning", 3: "information", 4: "hint"}
@@ -1002,8 +1030,8 @@ class LSPManager:
     async def get_references(
         self, file: str, line: int, col: int,
         include_declaration: bool = True,
-    ) -> list[LSPLocation]:
-        """Get all references to a symbol."""
+    ) -> list[LSPLocation] | None:
+        """Get all references to a symbol. None: the server replied null."""
         client = self._get_client_for_file(file)
         if not client:
             return []
@@ -1103,6 +1131,11 @@ class LSPManager:
             return file
         return f"file://{os.path.abspath(file)}"
 
+    async def wait_ready(self, file: str, timeout: float) -> bool:
+        """Wait until the server for ``file`` reports it is ready."""
+        client = self._get_client_for_file(file)
+        return True if client is None else await client.wait_ready(timeout)
+
     def _get_client_for_file(self, file: str) -> _LSPClient | None:
         """Find the appropriate client for a file extension."""
         ext = Path(file).suffix.lower()

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.25}/src/attocode_intel/api/routes/embeddings.py

@@ -146,7 +146,7 @@ async def get_embedding_status(
             response.provider_available = False
             response.provider_hint = (
                 "No embedding provider detected. "
-                "Install sentence-transformers (`pip install attocode[semantic]`) or set OPENAI_API_KEY."
+                "Install sentence-transformers (`pip install attocode[semantic]`) or set ATTOCODE_EMBEDDING_MODEL=openai with OPENAI_API_KEY."
             )
     except (ImportError, RuntimeError) as exc:
         response.provider_available = False
@@ -297,7 +297,7 @@ async def trigger_generate_embeddings(
     if provider.name == "none":
         raise HTTPException(
             status_code=400,
-            detail="No embedding provider available. Install sentence-transformers or set OPENAI_API_KEY.",
+            detail="No embedding provider available. Install sentence-transformers or set ATTOCODE_EMBEDDING_MODEL=openai with OPENAI_API_KEY.",
         )
 
     # Enqueue the ARQ job

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.25}/src/attocode_intel/precision.py

@@ -100,6 +100,7 @@ class PrecisionSession:
                         candidates = ast.get_callers(definition.qualified_name)
                         resolved, references = None, []
                         for attempt in range(4):
+                            answered = False
                             try:
                                 resolved = await manager.get_definition(path, *position)
                                 # Some servers (including rust-analyzer) return no
@@ -134,29 +135,42 @@ class PrecisionSession:
                                 if str(exc).lower() != "content modified" or attempt == 3:
                                     raise
                             else:
+                                answered = resolved is not None and references is not None
                                 # No syntax callers does not establish server
                                 # readiness: both native lookups may be transiently
                                 # unresolved. A resolved unused declaration can
-                                # still take the fast path.
-                                if references or (resolved is not None and not candidates):
+                                # still take the fast path, but only on an answer:
+                                # null references (None) mean "not ready".
+                                if references or (resolved is not None and references is not None
+                                                  and not candidates):
                                     break
                             # A server can briefly return null after a successful
                             # warmup or edit. Yield before retrying, never extend
                             # the enclosing two-second deadline or loop forever.
                             if attempt < 3:
                                 await asyncio.sleep(.05 * 2 ** attempt)
+                                # After a null or failed reply, a server that reports
+                                # its status (rust-analyzer) can stay not ready for
+                                # longer than this backoff. Wait for it, but leave half
+                                # the deadline for the remaining lookups. Do not wait
+                                # after an answer: rust-analyzer also answers while
+                                # its status is not ready. Other servers return at once.
+                                if not answered:
+                                    await manager.wait_ready(path, (deadline - asyncio.get_running_loop().time()) / 2)
                         if resolved is None and not references:
                             outcomes.append({"language": language, "status": "not_resolved"})
                             continue
                     finally:
                         manager.on_result_callback = callback
-                    ast.ingest_lsp_results("references", path, references,
+                    ast.ingest_lsp_results("references", path, references or [],
                                            {"line": position[0], "col": position[1],
                                             "symbol_name": definition.qualified_name,
                                             "definition_key": json.dumps([definition.file_path, definition.start_line, definition.qualified_name])})
                     self.verified_languages.add(language)
-                    outcomes.append({"language": language, "status": "verified" if references or not candidates else "no_references",
-                                     "symbol": definition.qualified_name, "references": len(references)})
+                    answered = references is not None
+                    outcomes.append({"language": language,
+                                     "status": "verified" if references or (answered and not candidates) else "no_references",
+                                     "symbol": definition.qualified_name, "references": len(references or [])})
             except Exception as exc:
                 status = "timeout" if isinstance(exc, TimeoutError) or isinstance(exc.__cause__, TimeoutError) else "failed"
                 self.failures[server_id] = (status, _now() + _RETRY_SECONDS)

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.25}/src/attocode_intel/service.py

@@ -123,6 +123,7 @@ class CodeIntelService:
             try:
                 from attocode_intel._internal.integrations.context.systemone_ranker import (
                     SystemOneChoiceReranker,
+                    workspace_consent,
                 )
 
                 environment = os.environ if config is None else {}
@@ -141,8 +142,7 @@ class CodeIntelService:
                     or preset.get("model", ""),
                     auth_env=self._config.ranking_auth_env or environment.get("ATTOCODE_INTEL_RANKING_AUTH_ENV", "")
                     or preset.get("auth_env", ""),
-                    allow_remote=(remote_opt_in and os.path.isabs(remote_workspace) and
-                                  os.path.realpath(remote_workspace) == self._project_dir),
+                    allow_remote=workspace_consent(remote_opt_in, remote_workspace, self._project_dir),
                     service_mode=self._config.is_service_mode,
                     timeout_seconds=None if timeout_ms == 0 else timeout_ms / 1000,
                     max_candidates=(self._config.ranking_max_candidates if config is not None else
@@ -1816,7 +1816,7 @@ class CodeIntelService:
         except Exception as e:
             return {"locations": [], "total": 0, "error": f"LSP error: {e}"}
         locations = []
-        for loc in locs:
+        for loc in locs or []:
             uri = loc.uri
             if uri.startswith("file://"):
                 uri = uri[7:]

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.25}/src/attocode_intel/workers/jobs.py

@@ -292,7 +292,7 @@ async def generate_embeddings(ctx: dict, repo_id: str, branch_name: str = "main"
             except (ImportError, RuntimeError) as exc:
                 return {"error": str(exc)}
             if provider.name == "none":
-                return {"error": "No embedding provider available", "hint": "Install sentence-transformers or set OPENAI_API_KEY"}
+                return {"error": "No embedding provider available", "hint": "Install sentence-transformers or set ATTOCODE_EMBEDDING_MODEL=openai with OPENAI_API_KEY"}
 
             dim = provider.dimension()
 

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.25}/tests/test_precision_recovery.py

@@ -194,3 +194,127 @@ async def test_null_lookup_without_static_callers_after_warmup(
     finally:
         await gateway.close()
     assert process is not None and process.returncode == 0
+
+
+def _status_server(window: float) -> str:
+    """A server like rust-analyzer: null replies while its VFS loads, with status."""
+    gate = f'''
+    if method in ('textDocument/definition', 'textDocument/references'):
+        if timer is None:
+            def become_ready():
+                global ready
+                ready = True
+                if status:
+                    send({{'jsonrpc':'2.0','method':'experimental/serverStatus','params':{{'health':'ok','quiescent':True}}}})
+            timer = threading.Timer({window!r}, become_ready)
+            timer.daemon = True
+            timer.start()
+        if not ready:
+            send({{'jsonrpc':'2.0','id':msg['id'],'result':None}})
+            continue
+'''
+    source = (SERVER
+              .replace('root = None', 'import threading\nlock = threading.Lock()\n'
+                       'ready = status = False\ntimer = None\nroot = None')
+              .replace('def send(value):', 'def _send(value):')
+              .replace('while True:\n    header', 'def send(value):\n    with lock:\n        _send(value)\n\n'
+                       'while True:\n    header')
+              .replace("        pending_init = msg['id']\n", "        pending_init = msg['id']\n"
+                       "        status = bool(params['capabilities'].get('experimental', {})"
+                       ".get('serverStatusNotification'))\n")
+              .replace("        pending_init = None\n        continue", "        pending_init = None\n"
+                       "        if status:\n"
+                       "            send({'jsonrpc':'2.0','method':'experimental/serverStatus',"
+                       "'params':{'health':'ok','quiescent':False}})\n        continue")
+              .replace('    result = None', gate + '\n    result = None'))
+    assert source.count('experimental/serverStatus') == 2 and 'def _send' in source
+    return source
+
+
+async def test_not_ready_window_longer_than_backoff_is_waited_out(tmp_path, monkeypatch):
+    """The null window (0.6 s) is longer than the retry backoff (about 0.35 s)."""
+    script = tmp_path / 'server.py'
+    script.write_text(_status_server(0.6))
+    monkeypatch.setitem(BUILTIN_SERVERS, 'python', LanguageServerConfig(
+        command=sys.executable, args=[str(script)], extensions=['.py'], language_id='python'))
+    monkeypatch.setenv('ATTOCODE_INTEL_PRECISION', 'auto')
+    root = tmp_path / 'project'
+    root.mkdir()
+    (root / 'helper.py').write_text('def helper(): return 1\n')
+    (root / 'caller.py').write_text('from helper import helper\nhelper()\n')
+    gateway = OperationGateway(str(root), 'daily', watch=False)
+    try:
+        response = await gateway.execute('inspect_symbol', {
+            'symbol_name': 'helper', 'file_path': 'helper.py', 'line': 1})
+        assert not response.isError
+        result = response.structuredContent
+        precision = result['metadata']['analysis']['precision']
+        assert precision['status'] == 'verified', precision
+        assert any(r['file_path'] == 'caller.py' and r['source'] == 'lsp'
+                   for r in result['data']['references'])
+    finally:
+        await gateway.close()
+
+
+async def test_null_references_are_not_an_answer_of_zero(tmp_path, monkeypatch):
+    """A resolved symbol with no static callers needs an answer, not a null reply."""
+    script = tmp_path / 'server.py'
+    gate = '''
+    if method == 'textDocument/references':
+        send({'jsonrpc':'2.0','id':msg['id'],'result':None})
+        continue
+'''
+    script.write_text(SERVER.replace('    result = None', gate + '\n    result = None'))
+    monkeypatch.setitem(BUILTIN_SERVERS, 'python', LanguageServerConfig(
+        command=sys.executable, args=[str(script)], extensions=['.py'], language_id='python'))
+    monkeypatch.setenv('ATTOCODE_INTEL_PRECISION', 'auto')
+    root = tmp_path / 'project'
+    root.mkdir()
+    (root / 'helper.py').write_text('def helper(): return 1\n')
+    gateway = OperationGateway(str(root), 'daily', watch=False)
+    try:
+        response = await gateway.execute('inspect_symbol', {
+            'symbol_name': 'helper', 'file_path': 'helper.py', 'line': 1})
+        assert not response.isError
+        precision = response.structuredContent['metadata']['analysis']['precision']
+        assert precision['queries'][0]['status'] == 'no_references', precision
+        assert precision['status'] == 'partial'
+    finally:
+        await gateway.close()
+
+
+async def test_empty_answer_is_not_a_wait_for_readiness(tmp_path, monkeypatch):
+    """rust-analyzer can answer [] while it reports not ready: do not wait then."""
+    from attocode_intel._internal.integrations.lsp.client import LSPManager
+    null_gate = ("        if not ready:\n"
+                 "            send({'jsonrpc':'2.0','id':msg['id'],'result':None})")
+    source = _status_server(30.0)
+    assert source.count(null_gate) == 1
+    script = tmp_path / 'server.py'
+    script.write_text(source.replace(null_gate, (
+        "        if not ready and method == 'textDocument/references':\n"
+        "            send({'jsonrpc':'2.0','id':msg['id'],'result':[]})")))
+    waits = []
+
+    async def record_wait(self, file, timeout):
+        waits.append(timeout)
+        return False
+
+    monkeypatch.setattr(LSPManager, 'wait_ready', record_wait)
+    monkeypatch.setitem(BUILTIN_SERVERS, 'python', LanguageServerConfig(
+        command=sys.executable, args=[str(script)], extensions=['.py'], language_id='python'))
+    monkeypatch.setenv('ATTOCODE_INTEL_PRECISION', 'auto')
+    root = tmp_path / 'project'
+    root.mkdir()
+    (root / 'helper.py').write_text('def helper(): return 1\n')
+    (root / 'caller.py').write_text('from helper import helper\nhelper()\n')
+    gateway = OperationGateway(str(root), 'daily', watch=False)
+    try:
+        response = await gateway.execute('inspect_symbol', {
+            'symbol_name': 'helper', 'file_path': 'helper.py', 'line': 1})
+        assert not response.isError
+        precision = response.structuredContent['metadata']['analysis']['precision']
+        assert precision['queries'][0]['status'] == 'no_references', precision
+        assert waits == []
+    finally:
+        await gateway.close()

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.25}/tests/test_real_language_server.py

@@ -123,7 +123,7 @@ async def test_real_server_warmed_selected_definition_and_edit(tmp_path, monkeyp
                             manager.notify_file_opened(str(tmp_path / name), content)
                     while True:
                         try:
-                            refs = await manager.get_references(str(tmp_path / target), line - 1, column, include_declaration=False)
+                            refs = await manager.get_references(str(tmp_path / target), line - 1, column, include_declaration=False) or []
                         except ToolError as error:
                             if str(error).lower() != 'content modified':
                                 raise
@@ -156,7 +156,7 @@ async def test_real_server_warmed_selected_definition_and_edit(tmp_path, monkeyp
                 async with asyncio.timeout(15):
                     while True:
                         try:
-                            refs = await manager.get_references(str(tmp_path / other), line - 1, column, include_declaration=False)
+                            refs = await manager.get_references(str(tmp_path / other), line - 1, column, include_declaration=False) or []
                         except ToolError as error:
                             if str(error).lower() != 'content modified':
                                 raise