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

attocode_code_intel-0.1.22/.gitignore

@@ -0,0 +1,59 @@
+# Python
+dist/
+__pycache__/
+.venv/
+*.egg-info/
+*.db
+*.db-shm
+*.db-wal
+*.jsonl
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+
+# Node
+node_modules/
+*.tsbuildinfo
+
+# Environment
+.env
+
+# Claude/Agent
+.claude/
+.agent/
+.traces/
+.production-agent-sessions/
+.test-sandbox/
+
+# Attocode index, caches and private quality runs
+/.attocode/
+
+docs/superpowers/
+eval/charts/
+eval/*.md
+eval/*.log
+eval/*.json
+
+# Build outputs
+*.vsix
+site/
+snapshot_report.html
+.internal
+
+# scripts
+scripts/*
+!scripts/check_pack_licenses.py
+.DS_Store
+
+#playwright
+.playwright-mcp
+
+#gsd
+.gsd/
+.bg-shell/
+
+#cursor
+.cursor/
+
+# search-quality sweep scratch output
+eval/sweep_out/

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: attocode-code-intel
-Version: 0.1.20
+Version: 0.1.22
 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.22 adds an opt-in discovery budget of up to 100,000 files
+(`ATTOCODE_INTEL_DISCOVERY_MAX_FILES`; the default stays 50,000). It also packages
+the LLM client, so `ATTOCODE_FLAG_CONFIDENCE=llm` and LLM rule synthesis work from
+a PyPI install when an OpenRouter or Anthropic key is set.
+
+Version 0.1.21 includes configured search-discovery coverage, OCaml interface
+parsing and more conservative Go/Rust fallback evidence. The existing 100 ms native
+budget and 50,000-file discovery safety ceiling remain; bounded fallback is heuristic.
+
 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
@@ -229,7 +238,7 @@ failed the frozen protocol. It provides no quality, cost or time benefit evidenc
 
 - **First search.** The first tool call starts the index build. A search waits up to 15 seconds for the index. On a large repository, a search can report that the index is warming. Then search again. An empty result during warm-up does not prove that the code is absent.
 - **Index location.** The index is in `.attocode/` in your project. When the server makes that folder, it adds a `.gitignore`, so the index stays out of commits.
-- **What the index reads.** The server reads at most 50,000 files and skips files over 1 MB. It skips files that `.gitignore` ignores, and folders that start with a dot. It also skips folders named `dist`, `build`, `out`, `output`, `target`, `env`, `tmp`, `vendor` or `coverage`, and binary, media and lock files. If a build-named folder contains real source, explicitly re-include it with a root `.gitignore` entry such as `!dist/`; discovery and edit refresh honor that override.
+- **What the index reads.** By default the server discovers at most 50,000 eligible files and skips files over 1 MB. From 0.1.22, the [discovery budget setting](https://github.com/eren23/attocode/blob/main/docs/intelligence-discovery.md) allows an explicit limit up to 100,000; the selected index can be smaller under its independent file limit. It skips files that `.gitignore` ignores, and folders that start with a dot. It also skips folders named `dist`, `build`, `out`, `output`, `target`, `env`, `tmp`, `vendor` or `coverage`, and binary, media and lock files. If a build-named folder contains real source, explicitly re-include it with a root `.gitignore` entry such as `!dist/`; discovery and edit refresh honor that override.
 - **Languages.** The base install parses Bash, C, C#, C++, CSS, Elixir, Go, HCL, HTML, Java, JavaScript, JSON, Kotlin, Lua, PHP, Python, Ruby, Rust, Scala, Swift, TOML, TypeScript, YAML and Zig. Optional grammars are loaded only when already installed or cached; installing the `tree-sitter-all` extra does not trigger grammar downloads during navigation. A slow grammar falls back after a 100 ms parse budget. Static imports and references are partial evidence, not compiler/type resolution.
 - **Degraded parsing (development builds).** Selecting a missing definition in
   a file with a recorded native parse failure permits one bounded retry for

{attocode_code_intel-0.1.20 → attocode_code_intel-0.1.22}/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.22 adds an opt-in discovery budget of up to 100,000 files
+(`ATTOCODE_INTEL_DISCOVERY_MAX_FILES`; the default stays 50,000). It also packages
+the LLM client, so `ATTOCODE_FLAG_CONFIDENCE=llm` and LLM rule synthesis work from
+a PyPI install when an OpenRouter or Anthropic key is set.
+
+Version 0.1.21 includes configured search-discovery coverage, OCaml interface
+parsing and more conservative Go/Rust fallback evidence. The existing 100 ms native
+budget and 50,000-file discovery safety ceiling remain; bounded fallback is heuristic.
+
 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
@@ -116,7 +125,7 @@ failed the frozen protocol. It provides no quality, cost or time benefit evidenc
 
 - **First search.** The first tool call starts the index build. A search waits up to 15 seconds for the index. On a large repository, a search can report that the index is warming. Then search again. An empty result during warm-up does not prove that the code is absent.
 - **Index location.** The index is in `.attocode/` in your project. When the server makes that folder, it adds a `.gitignore`, so the index stays out of commits.
-- **What the index reads.** The server reads at most 50,000 files and skips files over 1 MB. It skips files that `.gitignore` ignores, and folders that start with a dot. It also skips folders named `dist`, `build`, `out`, `output`, `target`, `env`, `tmp`, `vendor` or `coverage`, and binary, media and lock files. If a build-named folder contains real source, explicitly re-include it with a root `.gitignore` entry such as `!dist/`; discovery and edit refresh honor that override.
+- **What the index reads.** By default the server discovers at most 50,000 eligible files and skips files over 1 MB. From 0.1.22, the [discovery budget setting](https://github.com/eren23/attocode/blob/main/docs/intelligence-discovery.md) allows an explicit limit up to 100,000; the selected index can be smaller under its independent file limit. It skips files that `.gitignore` ignores, and folders that start with a dot. It also skips folders named `dist`, `build`, `out`, `output`, `target`, `env`, `tmp`, `vendor` or `coverage`, and binary, media and lock files. If a build-named folder contains real source, explicitly re-include it with a root `.gitignore` entry such as `!dist/`; discovery and edit refresh honor that override.
 - **Languages.** The base install parses Bash, C, C#, C++, CSS, Elixir, Go, HCL, HTML, Java, JavaScript, JSON, Kotlin, Lua, PHP, Python, Ruby, Rust, Scala, Swift, TOML, TypeScript, YAML and Zig. Optional grammars are loaded only when already installed or cached; installing the `tree-sitter-all` extra does not trigger grammar downloads during navigation. A slow grammar falls back after a 100 ms parse budget. Static imports and references are partial evidence, not compiler/type resolution.
 - **Degraded parsing (development builds).** Selecting a missing definition in
   a file with a recorded native parse failure permits one bounded retry for

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

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "attocode-code-intel"
-version = "0.1.20"
+version = "0.1.22"
 description = "Local code search and navigation for coding agents and people"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -142,8 +142,8 @@ packages = [
 ]
 
 [tool.hatch.build.targets.sdist]
-# Frozen experiment results remain available in the tagged Git repository.
-exclude = ["/evals/results/"]
+# Frozen study designs and results remain available in the tagged Git repository.
+exclude = ["/evals/"]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"

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

{attocode_code_intel-0.1.20 → attocode_code_intel-0.1.22}/src/attocode_intel/_internal/integrations/context/ast_service.py

@@ -1428,6 +1428,7 @@ class ASTService:
     def _index_definitions(self, rel_path: str, ast: FileAST, *, index=None) -> None:
         """Phase 1: Index all *definitions* (functions, classes, methods)."""
         index = self._index if index is None else index
+        source = 'regex' if ast.language in {'go', 'rust'} and ast.parsing_tier == 'regex' else 'tree-sitter'
         # Top-level functions
         for func in ast.functions:
             loc = SymbolLocation(
@@ -1437,6 +1438,7 @@ class ASTService:
                 file_path=rel_path,
                 start_line=func.start_line,
                 end_line=func.end_line,
+                source=source,
             )
             index.add_definition(loc)
 
@@ -1449,6 +1451,7 @@ class ASTService:
                 file_path=rel_path,
                 start_line=cls.start_line,
                 end_line=cls.end_line,
+                source=source,
             )
             index.add_definition(cls_loc)
 
@@ -1460,6 +1463,7 @@ class ASTService:
                     file_path=rel_path,
                     start_line=method.start_line,
                     end_line=method.end_line,
+                    source=source,
                 )
                 index.add_definition(method_loc)
 
@@ -1472,6 +1476,7 @@ class ASTService:
                 file_path=rel_path,
                 start_line=0,
                 end_line=0,
+                source=source,
             )
             index.add_definition(var_loc)
 
@@ -1563,6 +1568,10 @@ class ASTService:
         # Build a regex pattern for call sites: symbol_name(
         # Only scan for symbols that are actually defined somewhere.
         # Skip comment lines and string literals to reduce false positives.
+        lexical_fallback = ast.language in {'go', 'rust'}
+        if lexical_fallback:
+            from .codebase_ast import _mask_go_rust_source
+            content = _mask_go_rust_source(content, ast.language)
         in_multiline_string = False
         for i, line in enumerate(content.split("\n"), 1):
             stripped = line.lstrip()
@@ -1591,12 +1600,19 @@ class ASTService:
 
             # Strip inline comments and string literals for matching
             # Remove quoted strings to avoid matching inside them
-            clean_line = re.sub(r'(["\'])(?:(?!\1).)*\1', '""', line)
+            clean_line = line if lexical_fallback else re.sub(r'(["\'])(?:(?!\1).)*\1', '""', line)
+            declaration = None
+            if ast.language == 'go':
+                declaration = re.match(r'^\s*func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(', clean_line)
+            elif ast.language == 'rust':
+                declaration = re.match(r'^\s*(?:pub(?:\([^)]*\))?\s+)?(?:(?:async|unsafe|extern|const)\s+)*fn\s+(\w+)', clean_line)
             caller = _enclosing_qname(i)
 
             # Find function/method calls: name(
             for m in re.finditer(r"(?<!\.)\b(\w+)\s*\(", clean_line):
                 name = m.group(1)
+                if declaration is not None and m.start(1) == declaration.start(1):
+                    continue
                 if name in known_symbols and name not in ("if", "for", "while", "return", "print"):
                     ref = SymbolRef(
                         symbol_name=name,
@@ -1605,6 +1621,7 @@ class ASTService:
                         line=i,
                         syntax_name=name,
                         caller_qualified_name=caller,
+                        source='regex' if lexical_fallback else 'tree-sitter',
                     )
                     index.add_reference(ref)
 
@@ -1619,5 +1636,6 @@ class ASTService:
                         line=i,
                         syntax_name=m.group(0).rsplit("(", 1)[0].strip(),
                         caller_qualified_name=caller,
+                        source='regex' if lexical_fallback else 'tree-sitter',
                     )
                     index.add_reference(ref)

{attocode_code_intel-0.1.20 → attocode_code_intel-0.1.22}/src/attocode_intel/_internal/integrations/context/codebase_ast.py

@@ -863,12 +863,116 @@ def parse_javascript(content: str, path: str = "") -> FileAST:
     return ast
 
 
+def _mask_go_rust_source(content: str, language: str, *, keep_quoted: bool = False) -> str:
+    """Keep coordinates while hiding comments/literals from bounded heuristics.
+
+    keep_quoted retains ordinary double-quoted Go import paths. Raw literals
+    stay hidden in both views so their interior lines cannot become imports.
+    This is lexical filtering, not a complete language grammar.
+    """
+    output = list(content)
+    size, i = len(content), 0
+    raw_string = re.compile(r'(?:b|c)?r(#{0,255})"')
+    rust_char = re.compile(r"'(?:\\(?:u\{[0-9a-fA-F_]+\}|x[0-9a-fA-F]{2}|[^\r\n])|[^\\'\r\n])'")
+
+    def hide(start, end):
+        for at in range(start, min(end, size)):
+            if content[at] not in '\r\n':
+                output[at] = ' '
+
+    while i < size:
+        start = i
+        if content.startswith('//', i):
+            end = content.find('\n', i + 2)
+            i = size if end < 0 else end
+            hide(start, i)
+        elif content.startswith('/*', i):
+            i, depth = i + 2, 1
+            while i < size and depth:
+                if language == 'rust' and content.startswith('/*', i):
+                    depth += 1
+                    i += 2
+                elif content.startswith('*/', i):
+                    depth -= 1
+                    i += 2
+                else:
+                    i += 1
+            hide(start, i)
+        elif language == 'go' and content[i] == '`':
+            end = content.find('`', i + 1)
+            i = size if end < 0 else end + 1
+            hide(start, i)
+        elif language == 'rust' and (i == 0 or not (content[i - 1].isalnum() or content[i - 1] == '_')) and (raw := raw_string.match(content, i)):
+            closing = '"' + raw.group(1)
+            end = content.find(closing, raw.end())
+            i = size if end < 0 else end + len(closing)
+            hide(start, i)
+        elif language == 'rust' and content[i] == "'":
+            # An apostrophe also introduces a lifetime/label. Only a complete
+            # character token is hidden; &'a and 'label: stay code.
+            char = rust_char.match(content, i)
+            if char:
+                i = char.end()
+                hide(start, i)
+            else:
+                i += 1
+        elif content[i] == '"' or (language == 'go' and content[i] == "'"):
+            quote = content[i]
+            i += 1
+            while i < size:
+                if content[i] == '\\':
+                    i += 2
+                elif content[i] == quote:
+                    i += 1
+                    break
+                else:
+                    i += 1
+            if not (keep_quoted and quote == '"'):
+                hide(start, i)
+        else:
+            i += 1
+    return ''.join(output)
+
+
+def _bounded_fallback_end(lines: list[str], start: int) -> int:
+    """Find an ordinary declaration body within the existing500-line window."""
+    depth = parens = brackets = 0
+    opened = False
+    for number in range(start, min(start + 500, len(lines))):
+        line = lines[number]
+        if number > start and not opened and not parens and not brackets and re.match(
+            r'\s*(?:pub(?:\([^)]*\))?\s+)?(?:async\s+|unsafe\s+)?(?:func|fn|struct|enum|trait|type|impl|mod|use|import|const|var)\b', line,
+        ):
+            return start + 1
+        for char in line:
+            if opened:
+                depth += (char == '{') - (char == '}')
+            elif char == '(':
+                parens += 1
+            elif char == ')':
+                parens = max(0, parens - 1)
+            elif char == '[':
+                brackets += 1
+            elif char == ']':
+                brackets = max(0, brackets - 1)
+            elif not parens and not brackets:
+                if char == ';':
+                    return start + 1
+                if char == '{':
+                    opened, depth = True, 1
+        # A return type may close its own braces before the function body
+        # opens on the same line. Finish only after processing that line.
+        if opened and depth == 0:
+            return number + 1
+    return start + 1
+
+
 def parse_rust(content: str, path: str = "") -> FileAST:
     """Parse Rust source using regex patterns.
 
     Extracts functions, structs, enums, traits, impl blocks, imports (use/mod).
     """
-    lines = content.split("\n")
+    lines = _mask_go_rust_source(content, 'rust').split("\n")
     ast = FileAST(path=path, language="rust", line_count=len(lines))
 
     for i, line in enumerate(lines):
@@ -894,20 +998,13 @@ def parse_rust(content: str, path: str = "") -> FileAST:
 
         # Functions: (pub)? (async)? fn name(...)
         fn_match = re.match(
-            r"^(?:pub(?:\([\w:]+\))?\s+)?(?:async\s+)?(?:unsafe\s+)?(?:extern\s+\"[^\"]*\"\s+)?fn\s+(\w+)",
+            r"^(?:pub(?:\([\w:]+\))?\s+)?(?:async\s+)?(?:unsafe\s+)?(?:extern\s+)?fn\s+(\w+)",
             stripped,
         )
         if fn_match:
             func_name = fn_match.group(1)
             # Find end via brace matching
-            end_line = i + 1
-            brace_count = stripped.count("{") - stripped.count("}")
-            if brace_count > 0:
-                for j in range(i + 1, min(i + 500, len(lines))):
-                    brace_count += lines[j].count("{") - lines[j].count("}")
-                    if brace_count <= 0:
-                        end_line = j + 1
-                        break
+            end_line = _bounded_fallback_end(lines, i)
             is_async = "async " in stripped.split("fn")[0]
             ast.functions.append(FunctionDef(
                 name=func_name,
@@ -920,14 +1017,7 @@ def parse_rust(content: str, path: str = "") -> FileAST:
         # Structs: (pub)? struct Name
         struct_match = re.match(r"^(?:pub(?:\([\w:]+\))?\s+)?struct\s+(\w+)", stripped)
         if struct_match:
-            end_line = i + 1
-            brace_count = stripped.count("{") - stripped.count("}")
-            if brace_count > 0:
-                for j in range(i + 1, min(i + 500, len(lines))):
-                    brace_count += lines[j].count("{") - lines[j].count("}")
-                    if brace_count <= 0:
-                        end_line = j + 1
-                        break
+            end_line = _bounded_fallback_end(lines, i)
             ast.classes.append(ClassDef(
                 name=struct_match.group(1),
                 start_line=i + 1,
@@ -938,14 +1028,7 @@ def parse_rust(content: str, path: str = "") -> FileAST:
         # Enums: (pub)? enum Name
         enum_match = re.match(r"^(?:pub(?:\([\w:]+\))?\s+)?enum\s+(\w+)", stripped)
         if enum_match:
-            end_line = i + 1
-            brace_count = stripped.count("{") - stripped.count("}")
-            if brace_count > 0:
-                for j in range(i + 1, min(i + 500, len(lines))):
-                    brace_count += lines[j].count("{") - lines[j].count("}")
-                    if brace_count <= 0:
-                        end_line = j + 1
-                        break
+            end_line = _bounded_fallback_end(lines, i)
             ast.classes.append(ClassDef(
                 name=enum_match.group(1),
                 start_line=i + 1,
@@ -956,14 +1039,7 @@ def parse_rust(content: str, path: str = "") -> FileAST:
         # Traits: (pub)? trait Name
         trait_match = re.match(r"^(?:pub(?:\([\w:]+\))?\s+)?(?:unsafe\s+)?trait\s+(\w+)", stripped)
         if trait_match:
-            end_line = i + 1
-            brace_count = stripped.count("{") - stripped.count("}")
-            if brace_count > 0:
-                for j in range(i + 1, min(i + 500, len(lines))):
-                    brace_count += lines[j].count("{") - lines[j].count("}")
-                    if brace_count <= 0:
-                        end_line = j + 1
-                        break
+            end_line = _bounded_fallback_end(lines, i)
             ast.classes.append(ClassDef(
                 name=trait_match.group(1),
                 start_line=i + 1,
@@ -984,7 +1060,8 @@ def parse_go(content: str, path: str = "") -> FileAST:
 
     Extracts functions, methods, structs, interfaces, imports.
     """
-    lines = content.split("\n")
+    lines = _mask_go_rust_source(content, 'go').split("\n")
+    import_lines = _mask_go_rust_source(content, 'go', keep_quoted=True).split("\n")
     ast = FileAST(path=path, language="go", line_count=len(lines))
 
     i = 0
@@ -995,7 +1072,7 @@ def parse_go(content: str, path: str = "") -> FileAST:
         if stripped == "import (" or stripped.startswith("import ("):
             i += 1
             while i < len(lines):
-                imp_line = lines[i].strip()
+                imp_line = import_lines[i].strip()
                 if imp_line == ")":
                     break
                 # Parse "pkg" or alias "pkg"
@@ -1009,7 +1086,7 @@ def parse_go(content: str, path: str = "") -> FileAST:
             continue
 
         # Single import: import "pkg"
-        single_imp = re.match(r'^import\s+(?:\w+\s+)?"([^"]+)"', stripped)
+        single_imp = re.match(r'^import\s+(?:\w+\s+)?"([^"]+)"', import_lines[i].strip()) if stripped.startswith('import') else None
         if single_imp:
             ast.imports.append(ImportDef(
                 module=single_imp.group(1), is_from=False, line=i + 1,
@@ -1021,14 +1098,7 @@ def parse_go(content: str, path: str = "") -> FileAST:
         method_match = re.match(r"^func\s+\([^)]+\)\s+(\w+)\s*\(", stripped)
         if method_match:
             func_name = method_match.group(1)
-            end_line = i + 1
-            brace_count = stripped.count("{") - stripped.count("}")
-            if brace_count > 0:
-                for j in range(i + 1, min(i + 500, len(lines))):
-                    brace_count += lines[j].count("{") - lines[j].count("}")
-                    if brace_count <= 0:
-                        end_line = j + 1
-                        break
+            end_line = _bounded_fallback_end(lines, i)
             ast.functions.append(FunctionDef(
                 name=func_name,
                 start_line=i + 1,
@@ -1042,14 +1112,7 @@ def parse_go(content: str, path: str = "") -> FileAST:
         fn_match = re.match(r"^func\s+(\w+)\s*\(", stripped)
         if fn_match:
             func_name = fn_match.group(1)
-            end_line = i + 1
-            brace_count = stripped.count("{") - stripped.count("}")
-            if brace_count > 0:
-                for j in range(i + 1, min(i + 500, len(lines))):
-                    brace_count += lines[j].count("{") - lines[j].count("}")
-                    if brace_count <= 0:
-                        end_line = j + 1
-                        break
+            end_line = _bounded_fallback_end(lines, i)
             ast.functions.append(FunctionDef(
                 name=func_name,
                 start_line=i + 1,
@@ -1061,14 +1124,7 @@ def parse_go(content: str, path: str = "") -> FileAST:
         # Struct: type Name struct {
         struct_match = re.match(r"^type\s+(\w+)\s+struct\s*\{", stripped)
         if struct_match:
-            end_line = i + 1
-            brace_count = stripped.count("{") - stripped.count("}")
-            if brace_count > 0:
-                for j in range(i + 1, min(i + 500, len(lines))):
-                    brace_count += lines[j].count("{") - lines[j].count("}")
-                    if brace_count <= 0:
-                        end_line = j + 1
-                        break
+            end_line = _bounded_fallback_end(lines, i)
             ast.classes.append(ClassDef(
                 name=struct_match.group(1),
                 start_line=i + 1,
@@ -1080,14 +1136,7 @@ def parse_go(content: str, path: str = "") -> FileAST:
         # Interface: type Name interface {
         iface_match = re.match(r"^type\s+(\w+)\s+interface\s*\{", stripped)
         if iface_match:
-            end_line = i + 1
-            brace_count = stripped.count("{") - stripped.count("}")
-            if brace_count > 0:
-                for j in range(i + 1, min(i + 500, len(lines))):
-                    brace_count += lines[j].count("{") - lines[j].count("}")
-                    if brace_count <= 0:
-                        end_line = j + 1
-                        break
+            end_line = _bounded_fallback_end(lines, i)
             ast.classes.append(ClassDef(
                 name=iface_match.group(1),
                 start_line=i + 1,

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

@@ -821,6 +821,27 @@ def build_dependency_graph(
     return graph
 
 
+_DISCOVERY_ENV = "ATTOCODE_INTEL_DISCOVERY_MAX_FILES"
+_DEFAULT_DISCOVERY_MAX_FILES = 50_000
+_HARD_DISCOVERY_MAX_FILES = 100_000
+
+
+def _validate_discovery_max_files(value: int) -> int:
+    if type(value) is not int or not 1 <= value <= _HARD_DISCOVERY_MAX_FILES:
+        raise ValueError(f"discovery_max_files must be an integer from 1 to {_HARD_DISCOVERY_MAX_FILES}")
+    return value
+
+
+def _discovery_max_files_from_env() -> int:
+    raw = os.environ.get(_DISCOVERY_ENV)
+    if raw is None:
+        return _DEFAULT_DISCOVERY_MAX_FILES
+    try:
+        return _validate_discovery_max_files(int(raw))
+    except ValueError as exc:
+        raise ValueError(f"{_DISCOVERY_ENV} must be an integer from 1 to {_HARD_DISCOVERY_MAX_FILES}") from exc
+
+
 @dataclass
 class CodebaseContextManager:
     """Manages codebase context for intelligent code understanding.
@@ -853,6 +874,12 @@ class CodebaseContextManager:
     _ignored_checkout_dirs_capped: bool = field(default=False, repr=False)
     cancelled: Callable[[], bool] | None = field(default=None, repr=False, compare=False)
     _discovery_snapshot: Any = field(default=None, repr=False, compare=False)
+    # Separate from max_files, which caps selection after importance scoring.
+    # Capture the environment per instance; preserve existing positional fields.
+    discovery_max_files: int = field(default_factory=_discovery_max_files_from_env, kw_only=True)
+
+    def __post_init__(self) -> None:
+        _validate_discovery_max_files(self.discovery_max_files)
 
     def _check_cancelled(self) -> None:
         if self.cancelled is not None and self.cancelled():
@@ -906,7 +933,8 @@ class CodebaseContextManager:
         directory/file and the ignore-file identity must still match. A failed
         validation leaves this context empty so its normal fresh discovery runs.
         """
-        if snapshot is None or not snapshot.valid_for(self):
+        scan_limit = _validate_discovery_max_files(self.discovery_max_files)
+        if snapshot is None or len(snapshot.files) > scan_limit or not snapshot.valid_for(self):
             return False
         files = [FileInfo(*row) for row in snapshot.files]
         cap = _compute_dynamic_cap(files, self.max_files)
@@ -927,6 +955,7 @@ class CodebaseContextManager:
         Returns:
             List of FileInfo objects for discovered files.
         """
+        scan_limit = _validate_discovery_max_files(self.discovery_max_files)
         root = Path(self.root_dir)
         resolved_root = root.resolve()
         from attocode_intel._internal.integrations.context.discovery_snapshot import (
@@ -962,7 +991,7 @@ class CodebaseContextManager:
         guard(root / ".gitignore", missing_ok=True)
         ignore = IgnoreManager(root, default_dirs=self.ignore_patterns)
         files: list[FileInfo] = []
-        _SAFETY_CEILING = 50_000  # noqa: N806  # OOM guard for massive repos
+        scan_truncated = False
         self._ignored_checkout_dirs = []
         self._ignored_checkout_dirs_capped = False
 
@@ -1028,6 +1057,12 @@ class CodebaseContextManager:
                 if size > 1_000_000:  # 1MB
                     continue
 
+                # One further eligible file proves overflow. Excluded files do
+                # not, and no descriptor/content is allocated for this lookahead.
+                if len(files) >= scan_limit:
+                    scan_truncated = True
+                    break
+
                 is_test = any(p in rel_path.lower() for p in TEST_PATTERNS)
                 is_config = any(p in rel_path.lower() for p in CONFIG_PATTERNS)
 
@@ -1050,10 +1085,7 @@ class CodebaseContextManager:
                     line_count=line_count,
                 ))
 
-                if len(files) >= _SAFETY_CEILING:
-                    break
-
-            if len(files) >= _SAFETY_CEILING:
+            if scan_truncated:
                 break
 
         # Score importance
@@ -1084,14 +1116,14 @@ class CodebaseContextManager:
         # Truncate to dynamic cap AFTER scoring (smart truncation)
         cap = _compute_dynamic_cap(files, self.max_files)
         self.discovered_file_count = len(files)
-        self.discovery_truncated = len(files) > cap
+        self.discovery_truncated = scan_truncated or len(files) > cap
         if len(files) > cap:
             files = files[:cap]
 
         self._files = files
         self.refresh_excluded_checkout_roots()
         self._last_refresh_time = time.monotonic()
-        if snapshot_safe and not self.discovery_truncated and self.discovered_file_count < _SAFETY_CEILING:
+        if snapshot_safe and not self.discovery_truncated and self.discovered_file_count < scan_limit:
             self._discovery_snapshot = DiscoverySnapshot(
                 os.path.abspath(self.root_dir), frozenset(self.ignore_patterns),
                 self._last_refresh_time,
@@ -1375,55 +1407,6 @@ class CodebaseContextManager:
 
         return result
 
-    # --- Recursive context retrieval ---
-
-    def get_recursive_context(
-        self,
-        seed_files: list[str],
-        token_budget: int = 20_000,
-        max_depth: int = 3,
-        max_files: int = 15,
-    ) -> str:
-        """Gather context by recursively following imports from seed files.
-
-        Uses the RecursiveContextRetriever to mechanically follow Python/JS
-        imports starting from seed files, gathering content up to a depth
-        and token budget. Zero LLM cost.
-
-        Args:
-            seed_files: Files to start traversal from.
-            token_budget: Maximum tokens to gather.
-            max_depth: Maximum import-following depth.
-            max_files: Maximum files to visit.
-
-        Returns:
-            Combined content from all gathered files.
-        """
-        from attocode_intel._internal.tricks.recursive_context import RecursiveContextRetriever
-
-        class _FileProvider:
-            def __init__(self, root: str) -> None:
-                self._root = os.path.realpath(root)
-
-            def get_content(self, path: str) -> str | None:
-                candidate = os.path.normpath(os.path.join(self._root, path))
-                if not candidate.startswith(self._root):
-                    return None  # Path traversal rejected
-                try:
-                    with open(candidate, encoding="utf-8", errors="replace") as f:
-                        return f.read()
-                except (OSError, UnicodeDecodeError):
-                    return None
-
-        retriever = RecursiveContextRetriever(
-            _FileProvider(self.root_dir),
-            max_depth=max_depth,
-            token_budget=token_budget,
-            max_files=max_files,
-        )
-        result = retriever.retrieve(seed_files)
-        return result.content
-
     # --- Incremental update API ---
 
     def mark_file_dirty(self, file_path: str) -> None: