attocode-code-intel 0.1.2__tar.gz → 0.1.3__tar.gz

{attocode_code_intel-0.1.2 → attocode_code_intel-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: attocode-code-intel
-Version: 0.1.2
+Version: 0.1.3
 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

{attocode_code_intel-0.1.2 → attocode_code_intel-0.1.3}/evals/results/2026-10-11-agent-r4-stage0.md

@@ -9,6 +9,13 @@ and Recall@5 was 0.545 against 0.477 (Δ +0.068, range -0.020 to +0.158).
 That is also below the rule. By the rule, the next work is better test
 ranking, not agent runs.
 
+**Update after the ranking change (#164): the holdout check also does not
+meet the rule.** On the 56 holdout tasks, `suggest_tests` had Recall@5
+0.640 and the name grep 0.586 (Δ +0.054, range -0.047 to +0.167). On the
+dev tasks, which we used to make the change, Δ was +0.213. Thus no agent
+runs. The section [After the ranking change](#after-the-ranking-change)
+gives the details.
+
 R4 follows the R3 rule: after the localization studies, test a review
 task. The [R3 results](2026-10-10-agent-r3.md) give the background.
 
@@ -123,12 +130,57 @@ for the ranking work, not results of the rule.
 - We now know the dev tasks. A ranking change that we tune on them needs
   a check on tasks that we did not look at.
 
+## After the ranking change
+
+The user approved these steps on 2026-10-11 (`studies/r4-addendum.md` in
+the evals store). Because we used the dev results to make the change, the
+holdout tasks decide. Each holdout task ran once, with the final version.
+
+- **Change.** PR #164 at commit `381ece4`. `suggest_tests` finds tests by
+  name in the whole repository, and any folder that holds a top-level
+  Python package is an import root.
+- **Setup.** The same script, arms and metric, on a new RunPod CPU pod
+  (128 CPUs). Dev and holdout ran at the same time, with 12 workers each.
+  The pod ran for about 0.5 hours and cost about USD 0.45.
+- **Two record-only fields.** `product_detail` holds the priority of each
+  candidate. `name_v011` is the name grep with the test detector of 0.1.1.
+  The `name` arm uses the detector of the installed version, and #164 adds
+  .NET, C# and C/C++ test names to it.
+
+| Set | Tasks | Failed | `product` R@5 | `name` R@5 | Δ | Range of Δ (95%) | `product` Hit@5 | `name` Hit@5 | Higher / lower | Rule met |
+|---|---:|---:|---:|---:|---:|---|---:|---:|---:|---|
+| Dev (tuning) | 123 | 1 | 0.694 | 0.481 | +0.213 | +0.139 to +0.286 | 0.740 | 0.520 | 33 / 1 | Yes |
+| Holdout (decides) | 56 | 1 | 0.640 | 0.586 | +0.054 | -0.047 to +0.167 | 0.696 | 0.625 | 6 / 3 | No |
+
+With the 0.1.1 detector, the name grep had 0.477 on dev and 0.580 on the
+holdout. The Δ changes by less than 0.01. Each set has one task whose
+patch does not apply at the base commit (dubbo-3317 and dubbo-4678).
+
+**Reading.** On dev, `suggest_tests` improved on 21 tasks against the fix
+view, and no task got worse. All 7 matplotlib tasks had no test before.
+After the change, their Recall@5 is 0.50. On the holdout, the gain is
+small, and the range includes 0. By the rule, this is no evidence that
+the product names the tests for a change better than a file-name grep.
+The name grep is strong on the holdout. Both arms had a Hit@5 on 33 of
+55 tasks, because the developers changed the test that has the name of
+the source file.
+
+**Holdout misses.** These are leads only. The holdout tasks cannot check
+a fix for them.
+
+- `suggest_tests` found no test on 8 tasks.
+- In coreutils, the changed file is `src/uu/cp/src/cp.rs`. The name
+  finder skips names with fewer than 3 letters, so it did not find
+  `tests/by-util/test_cp.rs`.
+- In grommet and decap-cms, the gold set holds a Jest snapshot file
+  (`.snap`). `suggest_tests` gives only test source files, and the name
+  grep also gives data files.
+
 ## Next
 
-1. Release the race fix (#161) as code intel 0.1.2.
-2. Improve test ranking. Close the name-rule gaps above: a `tests/`
-   folder next to the source, Java packages and modules, C# and C/C++.
-   When the graph gives no test, use file-name matches as a fallback.
-3. Measure the change on the dev tasks, then once on the 56 holdout
-   tasks. The holdout tasks have not run yet, so they stay a clean check.
-   Stage 1 runs only if the change meets the rule.
+1. Merge #164 as a product change. Its claims are the numbers above, not
+   a measured gain on new tasks.
+2. No R4 agent runs. This also gives no new evidence for the cut of the
+   daily tool list.
+3. Any new test-ranking study needs new tasks, because we know the results
+   of all 179 tasks now.

{attocode_code_intel-0.1.2 → attocode_code_intel-0.1.3}/pyproject.toml

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

{attocode_code_intel-0.1.2 → attocode_code_intel-0.1.3}/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.2"
+__version__ = "0.1.3"

{attocode_code_intel-0.1.2 → attocode_code_intel-0.1.3}/src/attocode_intel/_internal/integrations/context/codebase_context.py

@@ -366,28 +366,52 @@ def _build_file_index(
         normalized = f.relative_path.replace(os.sep, "/")
         file_index[normalized] = f.relative_path
 
-    # Detect source prefixes and add stripped alternate keys. A package below
-    # any src/ folder adds that folder too, as in packages/<name>/src/ of a monorepo.
-    source_prefixes = set(_detect_source_prefixes(root_dir))
-    for normalized in file_index:
-        path = "/" + normalized
-        if normalized.endswith("/__init__.py") and "/src/" in path:
-            source_prefixes.add(path[1:path.index("/src/") + 5])
+    # Detect source prefixes and add stripped alternate keys.
+    source_prefixes = set(_detect_source_prefixes(root_dir)) | _python_import_roots(file_index)
     if source_prefixes:
-        extra: dict[str, str] = {}
-        for normalized, rel_path in file_index.items():
-            for prefix in sorted(source_prefixes):
-                if normalized.startswith(prefix):
-                    stripped = normalized[len(prefix):]
-                    # Don't override direct matches
-                    if stripped not in file_index:
-                        extra[stripped] = rel_path
-        file_index.update(extra)
+        _add_root_keys(file_index, source_prefixes)
 
     file_index.configure_javascript(root_dir)
     return file_index
 
 
+def _python_import_roots(paths) -> set[str]:
+    """Folders that hold a top-level Python package, as ``lib/`` for ``lib/pkg/__init__.py``.
+
+    Such a folder is an import root: src/, packages/<name>/src/ of a monorepo,
+    lib/ of matplotlib or python/ of ray.
+    """
+    roots: set[str] = set()
+    for path in paths:
+        package, _, name = path.rpartition("/")
+        parent = package.rpartition("/")[0]
+        if name == "__init__.py" and parent and parent + "/__init__.py" not in paths:
+            roots.add(parent + "/")
+    return roots
+
+
+def _add_root_keys(file_index: dict[str, str], roots: set[str]) -> None:
+    """Add a key without the root prefix for each file below an import root."""
+    extra: dict[str, str] = {}
+    for normalized, rel_path in file_index.items():
+        parts = normalized.split("/")
+        # Shallow roots first, so a deeper root wins, as in sorted prefix order.
+        for depth in range(1, len(parts)):
+            prefix = "/".join(parts[:depth]) + "/"
+            stripped = normalized[len(prefix):]
+            # Don't override direct matches
+            if prefix in roots and stripped not in file_index:
+                extra[stripped] = rel_path
+    file_index.update(extra)
+
+
+def python_module_index(paths) -> dict[str, str]:
+    """Module-path keys for ``_resolve_python_import`` from repository paths alone."""
+    file_index = {path: path for path in paths}
+    _add_root_keys(file_index, _python_import_roots(file_index))
+    return file_index
+
+
 def _resolve_python_import(module: str, source_file: str, file_index: dict[str, str]) -> str | None:
     """Resolve a Python import module name to a relative file path.
 

{attocode_code_intel-0.1.2 → attocode_code_intel-0.1.3}/src/attocode_intel/_internal/integrations/context/index_store.py

@@ -23,7 +23,7 @@ logger = logging.getLogger(__name__)
 SCHEMA_VERSION = "6"
 # Bump the suffix when a change alters the saved graph edges, for example import resolution.
 # Stores keep their tables, and the next start rebuilds the index once.
-SNAPSHOT_KEY = "structural_snapshot_v2"
+SNAPSHOT_KEY = "structural_snapshot_v3"
 SQLITE_BUSY_TIMEOUT_MS = 30_000
 INDEX_INIT_LOCK_TIMEOUT_SECONDS = 30
 

{attocode_code_intel-0.1.2 → attocode_code_intel-0.1.3}/src/attocode_intel/api/providers/db_provider.py

@@ -340,6 +340,9 @@ class DbAnalysisProvider:
 
         from sqlalchemy import select
 
+        from attocode_intel._internal.integrations.context.codebase_context import (
+            python_module_index,
+        )
         from attocode_intel.db.models import FileContent
         from attocode_intel.indexing.full_indexer import _resolve_import_path
         from attocode_intel.indexing.parser import detect_language, extract_imports
@@ -347,6 +350,7 @@ class DbAnalysisProvider:
         logger = logging.getLogger(__name__)
         manifest = branch_ctx.manifest  # path -> sha
         known_paths = set(manifest.keys())
+        python_index = python_module_index(known_paths)
         sha_to_path = {sha: path for path, sha in manifest.items()}
         content_shas = list(set(manifest.values()))
 
@@ -378,7 +382,8 @@ class DbAnalysisProvider:
                 raw_content = content if isinstance(content, bytes) else content.encode("utf-8")
                 imports = extract_imports(raw_content, source_path, language)
                 for imp in imports:
-                    target = _resolve_import_path(imp, source_path, known_paths, language)
+                    target = _resolve_import_path(imp, source_path, known_paths, language,
+                                                  python_index=python_index)
                     if target and target != source_path:
                         edges.append({
                             "source": source_path,

{attocode_code_intel-0.1.2 → attocode_code_intel-0.1.3}/src/attocode_intel/indexing/full_indexer.py

@@ -69,18 +69,23 @@ def _resolve_import_path(
     known_paths: set[str],
     language: str | None,
     aliases: dict[str, str] | None = None,
+    python_index: dict[str, str] | None = None,
 ) -> str | None:
     """Resolve an import string to a file path in the repo.
 
-    Returns the matching path or None if unresolvable.
+    Returns the matching path or None if unresolvable. For Python, pass
+    ``python_index = python_module_index(known_paths)`` when resolving many imports.
     """
     from pathlib import PurePosixPath
 
     if language == "python":
-        # foo.bar -> foo/bar.py or foo/bar/__init__.py
-        parts = import_name.replace(".", "/")
-        candidates = [f"{parts}.py", f"{parts}/__init__.py"]
-    elif language in ("javascript", "typescript"):
+        # The resolver of the local index: relative imports and import roots such as src/ or lib/.
+        from attocode_intel._internal.integrations.context.codebase_context import (
+            _resolve_python_import,
+            python_module_index,
+        )
+        return _resolve_python_import(import_name, source_path, python_index or python_module_index(known_paths))
+    if language in ("javascript", "typescript"):
         if import_name.startswith("."):
             # Relative import — resolve against source dir
             source_dir = str(PurePosixPath(source_path).parent)
@@ -249,8 +254,13 @@ class FullIndexer:
         if overlay_updates:
             await overlay.set_files_batch(branch_id, overlay_updates)
 
+        from attocode_intel._internal.integrations.context.codebase_context import (
+            python_module_index,
+        )
+
         # Resolve path aliases from tsconfig/jsconfig
         aliases = _load_path_aliases(known_paths, config_contents)
+        python_index = python_module_index(known_paths)
 
         # Second pass: resolve imports to dependencies
         self._progress({"phase": "resolving_dependencies", "total": len(deferred_deps), "current": 0})
@@ -260,7 +270,8 @@ class FullIndexer:
                     continue
                 deps: list[dict] = []
                 for imp in imports:
-                    target_path = _resolve_import_path(imp, source_path, known_paths, language, aliases=aliases)
+                    target_path = _resolve_import_path(imp, source_path, known_paths, language, aliases=aliases,
+                                                       python_index=python_index)
                     if target_path and target_path in path_to_sha:
                         deps.append({
                             "target_sha": path_to_sha[target_path],

{attocode_code_intel-0.1.2 → attocode_code_intel-0.1.3}/src/attocode_intel/indexing/incremental.py

@@ -159,9 +159,15 @@ class IncrementalPipeline:
                     for u_path, u_sha, _ in overlay_updates:
                         path_to_sha[u_path] = u_sha
 
+                    python_index = None
+                    if language == "python":
+                        from attocode_intel._internal.integrations.context.codebase_context import (
+                            python_module_index,
+                        )
+                        python_index = python_module_index(known_paths)
                     deps = []
                     for imp in imports:
-                        target = _resolve_import_path(imp, path, known_paths, language)
+                        target = _resolve_import_path(imp, path, known_paths, language, python_index=python_index)
                         if target and target in path_to_sha:
                             deps.append({
                                 "target_sha": path_to_sha[target],

{attocode_code_intel-0.1.2 → attocode_code_intel-0.1.3}/src/attocode_intel/test_ranking.py

@@ -1,6 +1,7 @@
 """Symbol-focused test evidence, reusing the parsed index instead of scanning file bodies."""
 from __future__ import annotations
 
+import re
 from pathlib import PurePosixPath
 
 from attocode_intel.focused_evidence import task_terms, terms
@@ -10,8 +11,77 @@ def is_test_path(path):
     parts = PurePosixPath(path).parts
     name = parts[-1] if parts else ""
     return (any(p in {"test", "tests", "__tests__", "spec", "specs"} for p in parts)
+            # .NET test projects: UnitsNet.Tests/, Kavita.Services.Tests/
+            or any(p.endswith((".Tests", ".Test", ".UnitTests", ".IntegrationTests")) for p in parts[:-1])
             or name.startswith("test_") or ".test." in name or ".spec." in name
-            or name.endswith(("_test.py", "_test.go", "Test.java", "Test.kt")))
+            or name.endswith(("_test.py", "_test.go", "Test.java", "Test.kt", "Tests.java", "Tests.kt",
+                              "Test.cs", "Tests.cs", "_test.c", "_test.cc", "_test.cpp", "_unittest.cc")))
+
+
+_TEST_PREFIX = re.compile(r"^(?:unit)?tests?[_-]|^Tests?(?=[A-Z])")
+_TEST_SUFFIX = re.compile(r"(?:[_-](?:unit)?(?:tests?|spec)|Tests?|Spec)$")
+# These names say little; the folder names the module (pkg/__init__.py, src/index.ts).
+_GENERIC_STEMS = {"__init__", "index", "mod", "lib", "main"}
+
+
+def _plain(name):
+    return name.lower().replace("_", "").replace("-", "")
+
+
+def file_subject(path):
+    """The name that a test for this file would carry: lib/pkg/figure.py -> figure."""
+    p = PurePosixPath(path)
+    stem = p.name.split(".")[0]
+    if stem in _GENERIC_STEMS and p.parent.name:
+        stem = p.parent.name
+    return _plain(stem)
+
+
+def test_subject(path):
+    """The name that a test file is for: test_figure.py, FigureTest.java, figure.test.ts -> figure.
+
+    None when the name has no test affix: a fixture or generated file in a test folder.
+    """
+    p = PurePosixPath(path)
+    stem = p.name.split(".")[0]
+    core = _TEST_SUFFIX.sub("", _TEST_PREFIX.sub("", stem))
+    if core == stem and ".test." not in p.name and ".spec." not in p.name and "__tests__" not in p.parts:
+        return None
+    return _plain(core)
+
+
+def folder_overlap(path, other):
+    """The number of folder names that two paths share, in any position."""
+    return len(set(PurePosixPath(path).parent.parts) & set(PurePosixPath(other).parent.parts))
+
+
+def name_matched_tests(changed_file, test_paths, limit=10):
+    """Test files named for ``changed_file``, best first, as (path, priority, reason).
+
+    Priority 1: the nearest tests whose name without the test affix is the file name, if
+    they share a folder name with it. Priority 3: the same name farther away. Priority 4: the test file name only
+    contains the file name, as a plain file-name search finds it. Nearest means the most
+    folder names in common, so src/test/java/org/x mirrors src/main/java/org/x.
+    """
+    subject = file_subject(changed_file)
+    if len(subject) < 2:
+        return []
+
+    def shared(path):
+        return folder_overlap(path, changed_file)
+
+    exact = [path for path in test_paths if test_subject(path) == subject]
+    named = set(exact)
+    # A short name is part of too many file names: cp.rs gets test_cp.rs, not every *cp* file.
+    loose = [path for path in test_paths if len(subject) >= 3 and path not in named
+             and subject in _plain(PurePosixPath(path).name)]
+    exact.sort(key=lambda path: (-shared(path), len(path), path))
+    loose.sort(key=lambda path: (-shared(path), len(path), path))
+    nearest = shared(exact[0]) if exact else 0
+    rows = [(path, 1 if nearest and shared(path) == nearest else 3, f"Test file named for `{changed_file}`")
+            for path in exact]
+    rows += [(path, 4, f"Test file name contains `{PurePosixPath(changed_file).stem}`") for path in loose]
+    return rows[:limit]
 
 
 def rank_symbol_tests(ast, suggestions, files, symbol_name, task_hint, distances,

{attocode_code_intel-0.1.2 → attocode_code_intel-0.1.3}/src/attocode_intel/tools/composite_tools.py

@@ -123,6 +123,30 @@ def _find_test_files_by_convention(file_path: str, project_dir: str) -> list[str
     return existing
 
 
+def _test_paths(project_dir: str) -> list[str]:
+    """Tracked test source files. The index can leave out tests of a large repository."""
+    from pathlib import PurePosixPath
+
+    from attocode_intel._internal.integrations.context.codebase_context import EXTENSION_LANGUAGES
+    from attocode_intel.test_ranking import is_test_path
+
+    try:
+        listed = subprocess.run(
+            ["git", "ls-files", "-z"],
+            cwd=project_dir, capture_output=True, text=True, timeout=30, check=True,
+        ).stdout.split("\0")
+    except (OSError, subprocess.SubprocessError):
+        listed = []
+    if not any(listed):  # Not a git repository, or nothing tracked yet.
+        try:
+            listed = [f.relative_path for f in _get_context_mgr()._files]
+        except Exception:
+            return []
+    data = {"data", "yaml", "json", "toml", "markdown", "html", "css", "scss"}
+    return [path for path in listed if path
+            and EXTENSION_LANGUAGES.get(PurePosixPath(path).suffix, "data") not in data and is_test_path(path)]
+
+
 # ---------------------------------------------------------------------------
 # Tools
 # ---------------------------------------------------------------------------
@@ -429,6 +453,13 @@ def suggest_tests_data(files: list[str], *, symbol_name: str | None = None,
                 reason=f"Direct test file for `{f}`",
             )
 
+    # Test files named for a changed file, anywhere in the repository.
+    from attocode_intel.test_ranking import folder_overlap, name_matched_tests
+    test_paths = _test_paths(project_dir)
+    for f in files:
+        for test_file, priority, reason in name_matched_tests(f, test_paths):
+            _add_suggestion(test_file, priority, reason)
+
     # --- Priority 2: Import-based discovery ---
     try:
         ctx = _get_context_mgr()
@@ -558,10 +589,14 @@ def suggest_tests_data(files: list[str], *, symbol_name: str | None = None,
     except (AttributeError, OSError) as exc:
         logger.debug("Test reference ranking incomplete: %s", exc)
 
-    # Sort by evidence, then put repository tests before documentation examples.
+    # Sort by evidence, then put repository tests before documentation examples, then nearest first.
+    def nearness(path):
+        return max(folder_overlap(path, changed) for changed in files) if files else 0
+
     sorted_suggestions = sorted(
         suggestions.items(),
-        key=lambda kv: (kv[1]["priority"], kv[0] not in representatives, -symbol_hits.get(kv[0], 0), kv[0].startswith("docs"), kv[0]),
+        key=lambda kv: (kv[1]["priority"], kv[0] not in representatives, -symbol_hits.get(kv[0], 0),
+                        kv[0].startswith("docs"), -nearness(kv[0]), kv[0]),
     )
 
     return {"files": files, "candidates": [
@@ -598,6 +633,7 @@ def format_test_suggestions(data: dict) -> str:
         1: "DIRECT",
         2: "IMPORTS",
         3: "INDIRECT",
+        4: "NAME",
     }
 
     lines = [

{attocode_code_intel-0.1.2 → attocode_code_intel-0.1.3}/tests/test_focused_inspection.py

@@ -307,3 +307,53 @@ async def test_workspace_member_src_layout_links_its_tests(tmp_path, monkeypatch
         assert bundle["tests"][0]["evidence"]["selected_symbol_reference"]
     finally:
         await gateway.close()
+
+
+def test_name_matched_tests_prefer_the_nearest_test_for_the_file():
+    from attocode_intel.test_ranking import is_test_path, name_matched_tests
+
+    tests = ["lib/pkg/tests/test_figure.py", "lib/other/tests/test_figure.py", "lib/pkg/tests/test_figure_legend.py"]
+    assert name_matched_tests("lib/pkg/figure.py", tests) == [
+        ("lib/pkg/tests/test_figure.py", 1, "Test file named for `lib/pkg/figure.py`"),
+        ("lib/other/tests/test_figure.py", 3, "Test file named for `lib/pkg/figure.py`"),
+        ("lib/pkg/tests/test_figure_legend.py", 4, "Test file name contains `figure`"),
+    ]
+    # Java tests in another package or module, and .NET test projects.
+    java = "core/src/main/java/org/x/Version.java"
+    assert name_matched_tests(java, ["core-testing/src/test/java/org/x/v/VersionTest.java"])[0][1] == 1
+    assert is_test_path("App.Tests/Parsing/ParserTests.cs")
+    assert name_matched_tests("App/Parsing/Parser.cs", ["App.Tests/Parsing/ParserTests.cs"])[0][1] == 1
+    # A word that ends in "test" is not a test affix.
+    assert name_matched_tests("src/latest.py", ["tests/contest.py"]) == []
+    # A fixture in a test folder has no test affix, and a test with no shared folder is far.
+    assert [row[1] for row in name_matched_tests("lib/pkg/figure.py", ["lib/pkg/tests/data/figure.py"])] == [4]
+    assert [row[1] for row in name_matched_tests("kernel/core.c", ["tools/selftests/test_core.c"])] == [3]
+    # A two-letter name matches its test exactly, but a name that only contains it is noise.
+    assert [row[0] for row in name_matched_tests("src/uu/cp/src/cp.rs", ["tests/test_cp.rs", "tests/test_scp.rs"])] == [
+        "tests/test_cp.rs"]
+
+
+async def test_lib_layout_links_tests_by_name_and_by_import(tmp_path, monkeypatch):
+    # matplotlib keeps its package in lib/, and its tests in a tests/ folder next to the source.
+    import subprocess
+
+    monkeypatch.setenv("ATTOCODE_INTEL_PRECISION", "off")
+    (tmp_path / "lib/pkg/tests").mkdir(parents=True)
+    (tmp_path / "lib/pkg/__init__.py").write_text("")
+    (tmp_path / "lib/pkg/figure.py").write_text("class Figure:\n    pass\n")
+    (tmp_path / "lib/pkg/tests/__init__.py").write_text("")
+    (tmp_path / "lib/pkg/tests/test_figure.py").write_text("def test_figure(): assert True\n")
+    (tmp_path / "lib/pkg/tests/test_layout.py").write_text(
+        "from pkg.figure import Figure\ndef test_layout(): assert Figure()\n")
+    (tmp_path / "lib/pkg/tests/test_text.py").write_text("def test_text(): assert True\n")
+    subprocess.run(["git", "init", "-q"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "add", "-A"], cwd=tmp_path, check=True)
+    gateway = OperationGateway(str(tmp_path), "daily", watch=False)
+    try:
+        result = await gateway.execute_mcp("suggest_tests", {"files": ["lib/pkg/figure.py"]})
+        paths = [row["file_path"] for row in decode(result)["candidates"]]
+        assert paths[:2] == ["lib/pkg/tests/test_figure.py", "lib/pkg/tests/test_layout.py"]
+        assert "lib/pkg/tests/test_text.py" not in paths
+    finally:
+        await gateway.close()
+

{attocode_code_intel-0.1.2 → attocode_code_intel-0.1.3}/tests/test_navigation_evidence.py

@@ -196,3 +196,15 @@ def test_index_lookups_wait_for_a_background_writer():
             assert reader.is_alive()
         reader.join(5)
         assert not reader.is_alive()
+
+
+def test_http_indexer_resolves_relative_imports_and_import_roots():
+    from attocode_intel.indexing.full_indexer import _resolve_import_path
+
+    paths = {"lib/pkg/__init__.py", "lib/pkg/utils.py", "lib/pkg/sub/__init__.py", "lib/pkg/sub/f.py", "utils.py"}
+    resolve = lambda name: _resolve_import_path(name, "lib/pkg/sub/f.py", paths, "python")  # noqa: E731
+    assert resolve("..utils") == "lib/pkg/utils.py"
+    assert resolve("pkg.utils") == "lib/pkg/utils.py"  # lib/ holds the top-level package.
+    assert resolve(".") == "lib/pkg/sub/__init__.py"
+    # Before, the dots were dropped and .utils linked the unrelated top-level utils.py.
+    assert resolve(".utils") is None