attocode-code-intel 0.1.19__tar.gz → 0.1.21__tar.gz

{attocode_code_intel-0.1.19 → attocode_code_intel-0.1.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: attocode-code-intel
-Version: 0.1.19
+Version: 0.1.21
 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.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
+must be explicitly available before analysis; navigation never downloads them.
+
 Version 0.1.19 restores source text into spare space after fitting a complete
 compact search page. Existing hits, visible text, source lines and continuations
 remain protected within the same response budget; ranking and retrieval are unchanged.

{attocode_code_intel-0.1.19 → attocode_code_intel-0.1.21}/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.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
+must be explicitly available before analysis; navigation never downloads them.
+
 Version 0.1.19 restores source text into spare space after fitting a complete
 compact search page. Existing hits, visible text, source lines and continuations
 remain protected within the same response budget; ranking and retrieval are unchanged.

{attocode_code_intel-0.1.19 → attocode_code_intel-0.1.21}/pyproject.toml

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

{attocode_code_intel-0.1.19 → attocode_code_intel-0.1.21}/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.19"
+__version__ = "0.1.21"

{attocode_code_intel-0.1.19 → attocode_code_intel-0.1.21}/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.19 → attocode_code_intel-0.1.21}/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.19 → attocode_code_intel-0.1.21}/src/attocode_intel/_internal/integrations/context/codebase_context.py

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

{attocode_code_intel-0.1.19 → attocode_code_intel-0.1.21}/src/attocode_intel/_internal/integrations/context/cross_references.py

@@ -57,7 +57,7 @@ class SymbolRef:
     ref_kind: str           # "call" | "import" | "attribute"
     file_path: str
     line: int
-    source: str = "tree-sitter"  # "tree-sitter" | "lsp"
+    source: str = "tree-sitter"  # "tree-sitter" | "regex" | "lsp"
     syntax_name: str = ""  # identifier/member expression as written in source
     # Qualified name of the function/method enclosing this reference. Empty
     # when the reference is at module top level or the enclosing symbol
@@ -76,7 +76,7 @@ class SymbolLocation:
     file_path: str
     start_line: int
     end_line: int
-    source: str = "tree-sitter"  # "tree-sitter" | "lsp"
+    source: str = "tree-sitter"  # "tree-sitter" | "regex" | "lsp"
 
 
 @dataclass(slots=True)