attocode-code-intel 0.1.0__py3-none-any.whl

attocode_intel/symbol_inspection.py

@@ -0,0 +1,141 @@
+"""Small evidence bundles composed from one refreshed workspace."""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def select_definitions(service, symbol_name, file_path=None, line=None):
+    root = Path(service.project_dir).resolve()
+    if file_path is not None:
+        path = (root / file_path).resolve()
+        if not path.is_relative_to(root):
+            raise ValueError("Path must remain inside the selected repository")
+        file_path = path.relative_to(root).as_posix()
+    if line is not None and line < 1:
+        raise ValueError("line must be a positive definition start line")
+    ast = service._get_ast_service()
+    if (file_path is not None and file_path not in ast._ast_cache
+            and any(fi.relative_path == file_path for fi in ast._context_mgr._files)):
+        ast.ensure_file_parsed(file_path)
+    if file_path is not None:
+        # A top-level exact name elsewhere must not hide a method in this file.
+        definitions = ast.get_file_symbols(file_path)
+        definitions = [d for d in definitions if d.file_path == file_path
+                       and (d.qualified_name == symbol_name or d.name == symbol_name
+                            or d.qualified_name.endswith(f".{symbol_name}"))]
+    else:
+        definitions = ast.find_symbol(symbol_name, include_shadowed=line is not None)
+    return [d for d in definitions if line is None or d.start_line == line]
+
+
+def location(definition):
+    return {key: getattr(definition, key) for key in
+            ("name", "qualified_name", "kind", "file_path", "start_line", "end_line")}
+
+
+def scoped_references(service, symbol_name, file_path=None, line=None):
+    data = service.cross_references_data(symbol_name)
+    if file_path is not None or line is not None:
+        definitions = select_definitions(service, symbol_name, file_path, line)
+        data["definitions"] = [location(d) for d in definitions]
+        data["selection_unique"] = len(definitions) == 1
+        if not definitions:
+            data["references"] = []
+            data["total_references"] = 0
+            data["reference_candidates"] = []
+            data["total_reference_candidates"] = 0
+        elif len(definitions) == 1:
+            from attocode_intel.symbol_links import classify_symbol_references
+            linked, candidates = classify_symbol_references(service._get_ast_service(), definitions[0])
+            data["references"] = linked
+            data["total_references"] = len(linked)
+            data["reference_candidates"] = candidates[:20]
+            data["total_reference_candidates"] = len(candidates)
+            data["reference_caveat"] = (
+                "References are linked by same-file identity, explicit import bindings, or a language server. "
+                "Same-name syntax matches without that evidence remain reference_candidates."
+            )
+    data["references"] = sorted(data["references"], key=lambda r: (
+        r["file_path"], r["line"], r["ref_kind"], r["source"], r.get("symbol", "")))
+    seen = set()
+    unique = []
+    for ref in data["references"]:
+        identity = tuple(sorted((key, str(value)) for key, value in ref.items()))
+        if identity not in seen:
+            seen.add(identity)
+            unique.append(ref)
+    data["references"] = unique
+    return data
+
+
+def inspect_symbol_data(service, symbol_name, file_path=None, line=None, source_start_line=None, task_hint=None):
+    definitions = select_definitions(service, symbol_name, file_path, line)
+    if len(definitions) != 1:
+        return {"status": "ambiguous" if definitions else "not_found", "symbol": symbol_name,
+                "definitions": [location(d) for d in definitions[:10]],
+                "total_definitions": len(definitions), "ambiguous": len(definitions) > 1,
+                "follow_up": {"tool": "inspect_symbol", "select": "file_path and start_line as line"}}
+    definition = definitions[0]
+    path = definition.file_path
+    root = Path(service.project_dir).resolve()
+    source_path = (root / path).resolve()
+    if not source_path.is_relative_to(root):
+        raise ValueError("Path must remain inside the selected repository")
+    # Check file identity across reading so an outside editor cannot pair stale lines with new text.
+    before = source_path.stat()
+    from attocode_intel.request_context import current_request
+    request = current_request.get()
+    tracker = request.stores.get("freshness") if request else None
+    expected = (tracker.manifest or {}).get(path) if tracker else None
+    if expected is not None and expected != (before.st_mtime_ns, before.st_ctime_ns, before.st_size):
+        raise ValueError("Source changed after indexing; retry inspection")
+    source = source_path.read_text(encoding="utf-8", errors="replace").splitlines()
+    after = source_path.stat()
+    if (before.st_mtime_ns, before.st_ctime_ns, before.st_size) != (
+            after.st_mtime_ns, after.st_ctime_ns, after.st_size):
+        raise ValueError("Source changed during inspection; retry")
+    from attocode_intel.tools.composite_tools import suggest_tests_data
+
+    references = scoped_references(service, symbol_name, path, definition.start_line)
+    imports = service.dependencies_data(path)
+    linked_test_files = {ref["file_path"] for ref in references["references"]}
+    tests = suggest_tests_data([path], symbol_name=definition.qualified_name, task_hint=task_hint,
+                               linked_reference_files=linked_test_files)["candidates"]
+    if source_start_line is not None and (isinstance(source_start_line, bool) or int(source_start_line) != source_start_line):
+        raise ValueError("source_start_line must be an integer inside the selected definition")
+    start = max(1, definition.start_line) if source_start_line is None else int(source_start_line)
+    if not definition.start_line <= start <= min(len(source), definition.end_line):
+        raise ValueError("source_start_line must be inside the selected definition")
+    focused_preview = task_hint and source_start_line is None and definition.end_line - definition.start_line >= 60
+    end = min(len(source), definition.end_line, start + (11 if focused_preview else 59))
+    selection = {"symbol_name": definition.qualified_name, "file_path": path,
+                 "line": definition.start_line}
+    relationships = ([{"file_path": p, "kind": "imports"} for p in imports["imports"]]
+                     + [{"file_path": p, "kind": "imported_by"} for p in imports["imported_by"]])
+    result = {
+        "status": "found", "definition": location(definition),
+        "source": {"start_line": start, "end_line": end,
+                   "text": "\n".join(source[start - 1:end]),
+                   "truncated": start > definition.start_line or end < definition.end_line},
+        "references": references["references"][:8], "total_references": references["total_references"],
+        "reference_candidates": references.get("reference_candidates", [])[:5],
+        "total_reference_candidates": references.get("total_reference_candidates", 0),
+        "ambiguous": references["ambiguous"],
+        "reference_caveat": references.get("reference_caveat", "Syntax references are candidates; verify source."),
+        "imports": relationships[:5], "total_imports": len(relationships),
+        "tests": tests[:5], "total_tests": len(tests), "absence_proven": False,
+        "follow_up": {
+            "references": {"tool": "cross_references", **selection},
+            "imports": {"tool": "dependencies", "path": path},
+            "tests": {"tool": "suggest_tests", "files": [path], "symbol_name": definition.qualified_name,
+                      **({"task_hint": task_hint} if task_hint else {})},
+            "source": {"file_path": path, "start_line": definition.start_line, "end_line": definition.end_line},
+            "next_source": {"tool": "inspect_symbol", **selection, "source_start_line": end + 1}
+                if end < definition.end_line else None,
+        },
+    }
+    if task_hint:
+        from attocode_intel.focused_evidence import source_excerpts
+        result["source_excerpts"] = source_excerpts(source, definition, task_hint, preview_end=end)
+        result["excerpt_selection"] = "Identifiers and executable literals ranked with enclosing syntax context; not exhaustive behavior coverage or data flow. Context ranges belong to their excerpt; cite each range separately."
+    return result

attocode_intel/symbol_links.py

@@ -0,0 +1,167 @@
+"""Resolve selected-symbol evidence through local import bindings."""
+from __future__ import annotations
+
+from collections import deque
+from pathlib import Path, PurePosixPath
+
+from attocode_intel._internal.integrations.context.cross_references import SymbolRef
+from attocode_intel._internal.integrations.context.syntax_evidence import reference_candidates
+
+
+def _file_index(ast):
+    try:
+        from attocode_intel._internal.integrations.context.codebase_context import _build_file_index
+        return _build_file_index(ast._context_mgr._files, ast._root_dir)
+    except AttributeError:
+        return None
+
+
+def _imports_from(ast, source, target, index):
+    """Return bindings in *source* whose module resolves to *target*."""
+    if index is None:
+        return []
+    try:
+        from attocode_intel._internal.integrations.context.codebase_context import IMPORT_RESOLVERS
+        file_ast = ast._ast_cache.get(source)
+        if file_ast is None:
+            ast.ensure_file_parsed(source)
+            file_ast = ast._ast_cache.get(source)
+        resolver = IMPORT_RESOLVERS.get(file_ast.language) if file_ast else None
+        return [imp for imp in (file_ast.imports if file_ast else [])
+                if resolver and resolver(imp.module, source, index) == target]
+    except (AttributeError, OSError, ValueError):
+        return []
+
+
+def linked_names_by_file(ast, definition):
+    """Map importers to local names explicitly bound to one definition.
+
+    Reexports propagate the public name through TypeScript export clauses and
+    Python package initializers. Ordinary imports establish a binding only in
+    the importing file.
+    """
+    names = {definition.file_path: {definition.name, definition.qualified_name}}
+    index = _file_index(ast)
+    queue = deque([(definition.file_path, definition.name)])
+    visited = set(queue)
+    while queue:
+        target, exported_name = queue.popleft()
+        try:
+            dependents = ast.get_dependents(target)
+        except AttributeError:
+            break
+        for source in dependents:
+            for imp in _imports_from(ast, source, target, index):
+                imported = imp.names[-1] if imp.names else ("*" if imp.is_reexport else "")
+                if imported not in {exported_name, "*"}:
+                    continue
+                local = imp.alias or (exported_name if imported == "*" else imported)
+                bound = names.setdefault(source, set())
+                bound.update({exported_name, imported, local})
+                reexport = imp.is_reexport or PurePosixPath(source).name == "__init__.py"
+                state = (source, local)
+                if reexport and local and state not in visited:
+                    visited.add(state)
+                    queue.append(state)
+    return names
+
+
+def classify_symbol_references(ast, definition):
+    """Partition references into linked evidence and unresolved candidates."""
+    names_by_file = linked_names_by_file(ast, definition)
+    query_names = {definition.name, definition.qualified_name}
+    for names in names_by_file.values():
+        query_names.update(names)
+    for path in names_by_file:
+        try:
+            ast.ensure_references_indexed(path)
+        except AttributeError:
+            pass
+    candidates = []
+    seen = set()
+    for name in query_names:
+        try:
+            refs = ast.get_callers(name)
+        except AttributeError:
+            refs = []
+        for ref in refs:
+            identity = (ref.file_path, ref.line, ref.ref_kind, ref.source, ref.symbol_name,
+                        getattr(ref, "syntax_name", ""))
+            if identity in seen:
+                continue
+            seen.add(identity)
+            candidates.append(ref)
+
+    # Calls through a public alias may not be in the global reference index:
+    # the alias itself is not a definition, so the normal indexer deliberately
+    # skips it. Scan only files that an explicit binding connected to the
+    # selected definition, keeping this bounded and structurally scoped.
+    try:
+        root = Path(ast._root_dir)
+        original_names = {definition.name, definition.qualified_name}
+        for path, local_names in names_by_file.items():
+            if not local_names - original_names:
+                continue
+            file_ast = ast._ast_cache.get(path)
+            if file_ast is None:
+                continue
+            content = (root / path).read_text(encoding="utf-8", errors="replace")
+            for written, kind, line in reference_candidates(str(root / path), content, file_ast.language) or []:
+                parts = written.split(".")
+                if not ({written, parts[0], parts[-1]} & local_names):
+                    continue
+                ref = SymbolRef(symbol_name=written, ref_kind=kind, file_path=path,
+                                line=line, source="tree-sitter")
+                identity = (ref.file_path, ref.line, ref.ref_kind, ref.source, ref.symbol_name,
+                            getattr(ref, "syntax_name", ""))
+                if identity not in seen:
+                    seen.add(identity)
+                    candidates.append(ref)
+    except (AttributeError, OSError):
+        pass
+
+    try:
+        same_name_definitions = ast.find_symbol(definition.name)
+        definition_count = len({(item.file_path, item.qualified_name)
+                                for item in same_name_definitions})
+    except AttributeError:
+        same_name_definitions = []
+        definition_count = 2
+    same_file_count = len({item.qualified_name for item in same_name_definitions
+                           if item.file_path == definition.file_path})
+    selected_parent = (definition.qualified_name.rsplit(".", 1)[0]
+                       if "." in definition.qualified_name else "")
+    linked, unresolved = [], []
+    for ref in candidates:
+        local_names = names_by_file.get(ref.file_path, set())
+        syntax_name = getattr(ref, "syntax_name", "") or ref.symbol_name
+        caller = getattr(ref, "caller_qualified_name", "")
+        if (ref.file_path == definition.file_path
+                and (same_file_count <= 1
+                     or (selected_parent and caller.rsplit(".", 1)[0] == selected_parent))):
+            resolution = "same_file"
+        elif {syntax_name, syntax_name.split(".", 1)[0]} & local_names:
+            resolution = "import_binding"
+        elif ref.source == "lsp" and definition_count == 1:
+            resolution = "language_server"
+        else:
+            resolution = "same_name_candidate"
+        row = {"ref_kind": ref.ref_kind, "file_path": ref.file_path, "line": ref.line,
+               "source": ref.source, "symbol": ref.symbol_name, "resolution": resolution}
+        if syntax_name != ref.symbol_name:
+            row["syntax"] = syntax_name
+        (linked if resolution != "same_name_candidate" else unresolved).append(row)
+
+    by_site = {}
+    for row in unresolved + linked:
+        site = row["file_path"], row["line"], row["ref_kind"], row["source"]
+        existing = by_site.get(site)
+        if (existing is None or existing["resolution"] == "same_name_candidate"
+                or row["resolution"] != "same_name_candidate"):
+            by_site[site] = row
+    linked = [row for row in by_site.values() if row["resolution"] != "same_name_candidate"]
+    unresolved = [row for row in by_site.values() if row["resolution"] == "same_name_candidate"]
+    def order(row):
+        return row["file_path"], row["line"], row["ref_kind"], row["source"], row["symbol"]
+
+    return sorted(linked, key=order), sorted(unresolved, key=order)

attocode_intel/telemetry.py

@@ -0,0 +1,42 @@
+"""Opt-in timings outside model responses; never writes source or arguments."""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import time
+from contextlib import contextmanager
+from contextvars import ContextVar
+from pathlib import Path
+
+timings: ContextVar[dict | None] = ContextVar("intelligence_timings", default=None)
+
+
+@contextmanager
+def measure(name):
+    start = time.monotonic()
+    try:
+        yield
+    finally:
+        current = timings.get()
+        if current is not None:
+            current[name] = round(current.get(name, 0) + (time.monotonic() - start) * 1000, 2)
+
+
+def enabled():
+    return bool(os.environ.get("ATTOCODE_INTEL_TRACE"))
+
+
+def emit(event: dict) -> None:
+    destination = os.environ.get("ATTOCODE_INTEL_TRACE")
+    if not destination:
+        return
+    try:
+        path = Path(destination).expanduser()
+        if not path.is_absolute():
+            return
+        fd = os.open(path, os.O_WRONLY | os.O_APPEND | os.O_CREAT, 0o600)
+        with os.fdopen(fd, "a") as stream:
+            stream.write(json.dumps(event, separators=(",", ":")) + "\n")
+    except OSError:
+        logging.getLogger(__name__).warning("Could not write intelligence timing trace")

attocode_intel/test_ranking.py

@@ -0,0 +1,73 @@
+"""Symbol-focused test evidence, reusing the parsed index instead of scanning file bodies."""
+from __future__ import annotations
+
+from pathlib import PurePosixPath
+
+from attocode_intel.focused_evidence import task_terms, terms
+
+
+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)
+            or name.startswith("test_") or ".test." in name or ".spec." in name
+            or name.endswith(("_test.py", "_test.go", "Test.java", "Test.kt")))
+
+
+def rank_symbol_tests(ast, suggestions, files, symbol_name, task_hint, distances,
+                      linked_reference_files=None, relevance_by_file=None):
+    selected = [s for f in files for s in ast.get_file_symbols(f)
+                if s.file_path == f and (s.name == symbol_name or s.qualified_name == symbol_name)]
+    symbol_terms = terms(symbol_name or "")
+    hint_terms, excluded_terms = task_terms(task_hint or "")
+    relevance_by_file = relevance_by_file or {}
+    direct = set(linked_reference_files or ())
+    if linked_reference_files is None:
+        for symbol in selected:
+            from attocode_intel.symbol_links import classify_symbol_references
+            linked, _ = classify_symbol_references(ast, symbol)
+            direct.update(r["file_path"] for r in linked if is_test_path(r["file_path"]))
+    # Search indexed test names as well as paths. A generic suite filename can
+    # contain a focused regression; filename matching alone should not hide it.
+    matches = {}
+    for path in set(ast.index.file_symbols) | set(suggestions) | direct:
+        inline = path in files and any("Rust inline test" in r for r in suggestions.get(path, {}).get("reasons", []))
+        if not is_test_path(path) and not inline:
+            continue
+        path_terms = terms(PurePosixPath(path).stem)
+        names = set().union(*(terms(s.name) for s in ast.get_file_symbols(path) if s.file_path == path))
+        symbol_hits = symbol_terms & (path_terms | names)
+        hint_hits = hint_terms & (path_terms | names)
+        excluded_hits = excluded_terms & (path_terms | names)
+        if path not in suggestions and path not in direct and not symbol_hits and not hint_hits:
+            continue
+        reasons = []
+        if path in direct:
+            reasons.append(f"Reference linked to selected symbol `{symbol_name}` by import or language-server evidence")
+        if symbol_hits:
+            reasons.append("Test name/path matches symbol terms: " + ", ".join(sorted(symbol_hits)))
+        if hint_hits:
+            reasons.append("Test name/path matches task terms: " + ", ".join(sorted(hint_hits)))
+        info = suggestions.get(path, {"priority": 3, "reasons": []})
+        matches[path] = {"file_path": path, "priority": 1 if path in direct else info["priority"],
+                         "reasons": (reasons + info["reasons"])[:3],
+                         "evidence": {"selected_symbol_reference": path in direct,
+                                      "reference_resolution": "linked" if path in direct else None,
+                                      "symbol_terms": sorted(symbol_hits), "task_terms": sorted(hint_hits),
+                                      "import_distance": distances.get(path)},
+                         "_excluded_hits": len(excluded_hits)}
+    def order(row):
+        evidence = row["evidence"]
+        # Selected-symbol references are strongest, followed by an actual reverse
+        # import path. Lexical matches remain useful candidates after graph evidence.
+        return (not evidence["selected_symbol_reference"],
+                evidence["import_distance"] is None,
+                row["_excluded_hits"] > 0,
+                -relevance_by_file.get(row["file_path"], 0.0),
+                -(len(evidence["task_terms"]) + len(evidence["symbol_terms"])),
+                row["priority"], evidence["import_distance"] if evidence["import_distance"] is not None else float("inf"),
+                row["file_path"].startswith("docs/"), row["file_path"])
+    ranked = sorted(matches.values(), key=order)
+    for row in ranked:
+        row.pop("_excluded_hits")
+    return ranked

attocode_intel/testing/__init__.py

@@ -0,0 +1,43 @@
+"""Testing utilities for attocode-code-intel.
+
+This module provides standardized fixtures, mocks, and helpers for
+testing code intelligence tools and MCP integrations.
+
+Example usage in tests::
+
+    import pytest
+    from attocode_intel.testing import (
+        code_intel_service,
+        ast_service,
+        sample_project,
+        MockServiceFactory,
+        create_sample_project,
+    )
+
+    class TestSearchTools:
+        @pytest.fixture(autouse=True)
+        def setup(self, code_intel_service, ast_service):
+            self.service = code_intel_service
+            self.ast = ast_service
+
+        def test_symbol_search(self):
+            result = search_tools.symbol_search(symbol_name="foo")
+            assert "foo" in result
+"""
+
+from attocode_intel.testing.fixtures import (
+    ast_service,
+    code_intel_service,
+    sample_project,
+)
+from attocode_intel.testing.mocks import MockServiceFactory
+from attocode_intel.testing.helpers import create_sample_project, get_tool_names
+
+__all__ = [
+    "ast_service",
+    "code_intel_service",
+    "sample_project",
+    "MockServiceFactory",
+    "create_sample_project",
+    "get_tool_names",
+]

attocode_intel/testing/fixtures.py

@@ -0,0 +1,122 @@
+"""Standardized pytest fixtures for code intelligence testing.
+
+Provides reusable fixtures for CodeIntelService, ASTService, and
+related components. These fixtures handle initialization, cleanup,
+and reset of singletons to ensure test isolation.
+
+For real repos, set ATTOCODE_PROJECT_DIR env var before running tests.
+
+Usage::
+
+    import pytest
+    from attocode_intel.testing.fixtures import code_intel_service, ast_service
+
+    class TestMyTool:
+        def test_something(self, code_intel_service, ast_service):
+            assert code_intel_service is not None
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import pytest
+
+if TYPE_CHECKING:
+    from attocode_intel.service import CodeIntelService
+    from attocode_intel._internal.integrations.context.ast_service import ASTService
+
+
+# ---------------------------------------------------------------------------
+# Service fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def sample_project(tmp_path: Path) -> Path:
+    """Create a minimal Python project in tmp_path for testing.
+
+    Creates:
+        - src/main.py, src/utils.py
+        - tests/test_main.py
+        - pyproject.toml
+    """
+    src = tmp_path / "src"
+    tests = tmp_path / "tests"
+
+    src.mkdir(parents=True, exist_ok=True)
+    tests.mkdir(parents=True, exist_ok=True)
+
+    (src / "__init__.py").write_text("")
+    (src / "main.py").write_text(
+        'import os\nfrom src.utils import helper\n\ndef main():\n    """Entry point."""\n    return helper(42)\n\ndef cli(args: list) -> int:\n    """CLI interface."""\n    return 0\n'
+    )
+    (src / "utils.py").write_text(
+        'import os\n\ndef helper(value: int) -> str:\n    """Process a value."""\n    return str(value)\n\nclass BaseProcessor:\n    """Base class."""\n    def process(self) -> None: pass\n'
+    )
+    (tests / "__init__.py").write_text("")
+    (tests / "test_main.py").write_text(
+        'import pytest\nfrom src.main import main\n\ndef test_main():\n    assert main() == "42"\n'
+    )
+    (tmp_path / "pyproject.toml").write_text(
+        '[project]\nname = "test"\nversion = "0.1.0"\n'
+    )
+
+    return tmp_path
+
+
+@pytest.fixture
+def code_intel_service(
+    sample_project: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> "CodeIntelService":
+    """Provide a CodeIntelService instance for the sample project.
+
+    Resets all singletons before and after the test to ensure isolation.
+    """
+    import attocode_intel._shared as ci_shared
+    from attocode_intel.service import CodeIntelService
+
+    monkeypatch.setenv("ATTOCODE_PROJECT_DIR", str(sample_project))
+
+    CodeIntelService._reset_instances()
+    ci_shared._service = None
+    ci_shared._remote_service = None
+
+    service = CodeIntelService.get_instance(str(sample_project))
+
+    yield service
+
+    CodeIntelService._reset_instances()
+    ci_shared._service = None
+    ci_shared._remote_service = None
+    monkeypatch.delenv("ATTOCODE_PROJECT_DIR", raising=False)
+
+
+@pytest.fixture
+def ast_service(
+    sample_project: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> "ASTService":
+    """Provide an ASTService instance for the sample project.
+
+    Initializes skeleton indexing for fast test execution.
+    """
+    import attocode_intel._shared as ci_shared
+    from attocode_intel._internal.integrations.context.ast_service import ASTService
+
+    monkeypatch.setenv("ATTOCODE_PROJECT_DIR", str(sample_project))
+
+    ASTService.clear_instances()
+    ci_shared._ast_service = None
+
+    service = ASTService.get_instance(str(sample_project))
+    if not service.initialized:
+        service.initialize_skeleton(indexing_depth="minimal")
+
+    yield service
+
+    ASTService.clear_instances()
+    ci_shared._ast_service = None
+    monkeypatch.delenv("ATTOCODE_PROJECT_DIR", raising=False)

attocode_intel/testing/helpers.py

@@ -0,0 +1,75 @@
+"""Helper utilities for code intelligence testing.
+
+Provides utility functions for creating test projects and
+common test patterns. For real repos, use ATTOCODE_PROJECT_DIR.
+
+Usage::
+
+    from attocode_intel.testing.helpers import create_sample_project
+
+    # Create a project with custom files
+    project = create_sample_project(tmp_path, {
+        "src/main.py": "def foo(): pass",
+        "src/utils.py": "def bar(): pass",
+    })
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def create_sample_project(
+    tmp_path: Path,
+    files: dict[str, str],
+    *,
+    with_git: bool = False,
+) -> Path:
+    """Create a sample project with custom file structure.
+
+    Args:
+        tmp_path: The parent temporary directory.
+        files: Dict mapping file paths (relative to project root)
+               to their contents.
+        with_git: Whether to create a .git directory.
+
+    Returns:
+        Path to the created project root.
+
+    Example::
+
+        project = create_sample_project(tmp_path, {
+            "src/main.py": "def main(): pass",
+            "src/utils.py": "def helper(): pass",
+            "tests/test_main.py": "def test_main(): pass",
+        })
+    """
+    for file_path, content in files.items():
+        full_path = tmp_path / file_path
+        full_path.parent.mkdir(parents=True, exist_ok=True)
+        full_path.write_text(content)
+
+    if with_git:
+        git_dir = tmp_path / ".git"
+        git_dir.mkdir(parents=True, exist_ok=True)
+        (git_dir / "config").write_text("[core]\n\tautocrlf = true\n")
+
+    return tmp_path
+
+
+def get_tool_names() -> list[str]:
+    """Return the list of MCP tool module names.
+
+    Returns:
+        List of tool module names (without .py extension).
+    """
+    from attocode_intel import tools as tools_module
+
+    tool_dir = Path(tools_module.__file__).parent
+    return [f.stem for f in tool_dir.glob("*.py") if not f.stem.startswith("_")]
+
+
+__all__ = [
+    "create_sample_project",
+    "get_tool_names",
+]