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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: attocode-code-intel
-Version: 0.1.1
+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.3/evals/results/2026-10-11-agent-r4-stage0.md

@@ -0,0 +1,186 @@
+# Agent study R4, Stage 0: tests for a change
+
+**Status: The rule for Stage 1 is not met, so no agent runs. On 123 dev
+tasks, `suggest_tests` of code intel 0.1.1 had a test Recall@5 of 0.469.
+A file-name grep had 0.477 (Δ -0.008, range -0.117 to +0.101).** In 19
+tasks, `suggest_tests` failed with `RuntimeError: dictionary changed size
+during iteration`. #161 fixes this race. With the fix, the 19 tasks ran,
+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.
+
+## Rules
+
+We wrote these rules before Stage 0 ran, and the user approved them on
+2026-10-11. The design file is `studies/r4-design.md` in the evals store
+(sha256 `17b80ae0…`). We did not change it after results existed.
+
+- **Question.** When an agent reviews a change, does code intel help it
+  name the existing tests that check the change?
+- **Tasks.** R1 core-mix tasks whose `test_patch` changes 1 to 5 test
+  files that exist at the base commit. These files are the gold set. The
+  change is the `patch`, applied to the base commit and not committed.
+- **Stage 0 arms.** Each arm gets the changed files of the patch.
+  - `product`: the first 10 paths of `suggest_tests(files=changed)`, code
+    intel 0.1.1 from PyPI.
+  - `name`: the test files whose file name contains the stem of a changed
+    file, in path order.
+- **Metric.** Test Recall@5: the share of gold files in the first 5 paths.
+  Also Hit@5: at least one gold file in the first 5.
+- **Rule.** Go to Stage 1 (agent runs) only if `product` Recall@5 on dev
+  is 0.10 or more above `name`. Also, the 95% range from a repository
+  bootstrap must be above 0. If not, improve test ranking first.
+- **Failures.** A task where `suggest_tests` fails keeps an empty
+  `product` list. Thus a failure counts against the product.
+
+The design file gives 121 repositories for the 179 core-mix tasks. The
+correct count is 100. The dev split has 123 tasks from 78 repositories.
+
+## Setup
+
+- A RunPod CPU pod, 12 workers, one repository group for each worker.
+- For each task: a blobless clone at the base commit, `git clean`, then
+  `git apply` of the patch. The `product` arm polls `suggest_tests` every
+  5 seconds until the index phase is `ready`, for at most 900 seconds.
+- Two tasks failed in the first pass because `git clone` failed. We
+  removed their rows and ran them again. One task (dubbo-3317) failed
+  because its patch does not apply at the base commit. It stays in the
+  results as a failure.
+- The fix view ran the 19 failed tasks again with the #161 branch. All
+  other rows are the same as in the primary view.
+
+The pod ran for about 1.3 hours and cost about USD 1.15.
+
+## Results
+
+| View | Tasks | Failed | `product` R@5 | `name` R@5 | Δ | Range of Δ (95%) | `product` Hit@5 | `name` Hit@5 | Rule met |
+|---|---:|---:|---:|---:|---:|---|---:|---:|---|
+| Primary (0.1.1) | 123 | 20 | 0.469 | 0.477 | -0.008 | -0.117 to +0.101 | 0.496 | 0.512 | No |
+| Fix view (#161) | 123 | 1 | 0.545 | 0.477 | +0.068 | -0.020 to +0.158 | 0.577 | 0.512 | No |
+
+The range comes from 10,000 repository bootstrap draws. In the primary
+view, `product` was higher on 18 tasks and `name` on 17. In the fix view,
+the counts are 22 and 10.
+
+**Reading.** The primary view is the result of the study. Its Δ is near 0
+and its range includes 0. The fix view shows the product as it will ship
+in the next release. Its Δ is positive, but it is below 0.10, and its
+range includes 0. The race fix does not change the decision.
+
+## Where each arm finds the tests
+
+These counts use the fix view and the 122 tasks that ran. They are leads
+for the ranking work, not results of the rule.
+
+| Language of the change | Tasks | `product` R@5 | `name` R@5 | Empty `product` list |
+|---|---:|---:|---:|---:|
+| Python | 67 | 0.59 | 0.50 | 11 |
+| JavaScript/TypeScript | 23 | 0.78 | 0.61 | 3 |
+| Java | 12 | 0.31 | 0.51 | 6 |
+| Go | 6 | 0.83 | 0.67 | 0 |
+| Rust | 6 | 0.17 | 0.00 | 1 |
+| C# | 5 | 0.00 | 0.20 | 5 |
+| C/C++ | 3 | 0.00 | 0.00 | 3 |
+| No code file | 1 | 0.00 | 0.00 | 1 |
+
+- Both arms had a Hit@5 on 53 tasks. Only `product` had one on 18 tasks,
+  and only `name` on 10. Neither arm had one on 41 tasks.
+- `suggest_tests` gave an empty list on 30 tasks. On 3 more tasks, a gold
+  file was at rank 6 to 10 and not in the first 5.
+- **Python test folders.** All 7 matplotlib tasks got an empty list. For
+  example, the change is `lib/matplotlib/figure.py`, and the gold test is
+  `lib/matplotlib/tests/test_figure.py`. The name rules do not look in a
+  `tests/` folder next to the source file. The imports do not link either,
+  because the resolver does not know the `lib/` source root. Prefect
+  (`<package>/tests/test_worker.py`) and pylint (`unittest_misc.py`) are
+  similar.
+- **Java.** The name rule maps only `src/main/` to `src/test/` with the
+  same package. Gold tests in another package (dubbo `version/VersionTest`)
+  or in another module (javaparser `javaparser-core-testing`) are not
+  found.
+- **C# and C/C++.** `suggest_tests` has no name rule for these languages,
+  so it found no test in 8 tasks.
+- **Neither arm.** Many of the 41 tasks have gold tests whose name does
+  not contain a changed stem. For example, a change to `figure.py` has the
+  gold test `test_constrainedlayout.py`. Only import or reference evidence
+  can find these.
+- **The `name` arm.** Its list also holds files that are not tests, such
+  as baseline images below `tests/`. These files fill some of its first 5
+  places.
+
+## What this does not show
+
+- The gold set holds the tests that the developers changed. Other
+  existing tests can also check the change. Recall is thus a lower bound,
+  and the study does not measure precision.
+- The `name` arm is a strong baseline for this gold set. Developers often
+  change the test file that has the name of the source file.
+- Stage 0 measures the tool output only. It does not show how an agent
+  uses that output.
+- 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. 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.1 → attocode_code_intel-0.1.3}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "attocode-code-intel"
-version = "0.1.1"
+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.1 → 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.1"
+__version__ = "0.1.3"

{attocode_code_intel-0.1.1 → attocode_code_intel-0.1.3}/src/attocode_intel/_internal/integrations/context/ast_service.py

@@ -892,10 +892,10 @@ class ASTService:
         """Return all symbols defined in *path*."""
         self._ensure_initialized()
         rel = self._to_rel(path)
-        qnames = self._index.file_symbols.get(rel, set())
         result: list[SymbolLocation] = []
-        for qn in qnames:
-            result.extend(self._index.definitions.get(qn, []))
+        with self._index._lock:  # Background hydration adds to these sets.
+            for qn in self._index.file_symbols.get(rel, set()):
+                result.extend(self._index.definitions.get(qn, []))
         return result
 
     def find_symbol(self, name: str, *, include_shadowed: bool = False) -> list[SymbolLocation]:

{attocode_code_intel-0.1.1 → 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.1 → attocode_code_intel-0.1.3}/src/attocode_intel/_internal/integrations/context/cross_references.py

@@ -438,15 +438,17 @@ class CrossRefIndex:
 
     def get_definitions(self, symbol_name: str, *, include_shadowed: bool = False) -> list[SymbolLocation]:
         """Look up definitions for a symbol (exact or suffix match)."""
-        # Try exact qualified name first
-        if symbol_name in self.definitions and not include_shadowed:
-            return self.definitions[symbol_name]
-        # Try suffix match (e.g. "discover_files" matches "CodebaseContextManager.discover_files")
-        results: list[SymbolLocation] = []
-        for qname, locs in self.definitions.items():
-            if qname == symbol_name or qname.endswith(f".{symbol_name}"):
-                results.extend(locs)
-        return results
+        # The lock keeps a background index writer from changing the dict during the scan.
+        with self._lock:
+            # Try exact qualified name first
+            if symbol_name in self.definitions and not include_shadowed:
+                return self.definitions[symbol_name]
+            # Try suffix match (e.g. "discover_files" matches "CodebaseContextManager.discover_files")
+            results: list[SymbolLocation] = []
+            for qname, locs in self.definitions.items():
+                if qname == symbol_name or qname.endswith(f".{symbol_name}"):
+                    results.extend(locs)
+            return results
 
     def search_definitions(
         self,
@@ -455,7 +457,18 @@ class CrossRefIndex:
         limit: int = 50,
         kind_filter: str = "",
     ) -> list[tuple[SymbolLocation, float]]:
-        """Multi-strategy symbol search returning (location, score) pairs.
+        """Multi-strategy symbol search returning (location, score) pairs."""
+        with self._lock:
+            return self._search_definitions_locked(symbol_name, limit=limit, kind_filter=kind_filter)
+
+    def _search_definitions_locked(
+        self,
+        symbol_name: str,
+        *,
+        limit: int,
+        kind_filter: str,
+    ) -> list[tuple[SymbolLocation, float]]:
+        """Search the definitions. The caller holds the lock.
 
         Search strategies (in priority order):
         1. Exact qualified name match (score 1.0)
@@ -536,9 +549,10 @@ class CrossRefIndex:
         # Include exact and qualified candidates; an exact key must not hide others.
         # Suffix match (e.g. "clear" matches refs keyed as "MCPMetaTools.clear")
         results: list[SymbolRef] = []
-        for ref_name, refs in self.references.items():
-            if ref_name == symbol_name or ref_name.endswith(f".{symbol_name}"):
-                results.extend(refs)
+        with self._lock:
+            for ref_name, refs in self.references.items():
+                if ref_name == symbol_name or ref_name.endswith(f".{symbol_name}"):
+                    results.extend(refs)
         return results
 
     def get_dependents(self, file_path: str) -> set[str]:

{attocode_code_intel-0.1.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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 = [