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

attocode_intel/_shared.py

@@ -0,0 +1,341 @@
+"""Shared dependencies for code-intel MCP tool modules.
+
+Extracted from server.py to break the circular import:
+  server.py → tool modules → server.py
+
+Tool modules should import from here instead of server.py.
+server.py re-exports these symbols for backward compatibility.
+
+Note: Existing tests set ``server._ast_service = mock`` directly on the
+server module's ``__dict__``. The ``_check_server_override`` helper
+ensures the getters respect those overrides without requiring tests to
+change.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+from typing import TYPE_CHECKING
+
+try:
+    from mcp.server.fastmcp import FastMCP
+except ImportError:
+    print(
+        "Error: 'mcp' package not installed. "
+        "Reinstall with: uv tool install --force --reinstall --from . attocode",
+        file=sys.stderr,
+    )
+    sys.exit(1)
+
+if TYPE_CHECKING:
+    from attocode_intel.api.providers.remote_provider import RemoteTextService
+    from attocode_intel.service import CodeIntelService
+    from attocode_intel._internal.integrations.context.ast_service import ASTService
+    from attocode_intel._internal.integrations.context.code_analyzer import CodeAnalyzer
+    from attocode_intel._internal.integrations.context.codebase_context import CodebaseContextManager
+    from attocode_intel._internal.integrations.context.frecency import FrecencyTracker
+    from attocode_intel._internal.integrations.context.hierarchical_explorer import HierarchicalExplorer
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# FastMCP instance (singleton)
+# ---------------------------------------------------------------------------
+
+mcp = FastMCP("attocode-code-intel")
+
+# ---------------------------------------------------------------------------
+# Lazily initialized singletons
+# ---------------------------------------------------------------------------
+
+_ast_service: ASTService | None = None
+_context_mgr: CodebaseContextManager | None = None
+_code_analyzer: CodeAnalyzer | None = None
+_semantic_search: object | None = None  # Backward compat: tests may set this directly
+_memory_store: object | None = None  # Backward compat: tests may set this directly
+_explorer: HierarchicalExplorer | None = None
+_service: CodeIntelService | None = None
+_remote_service: RemoteTextService | None = None
+_remote_degraded_reason: str = ""
+
+
+def _check_server_override(name: str) -> object | None:
+    """Return the value of *name* from ``server.__dict__`` if set there.
+
+    Tests (and some internal code) set e.g. ``server._ast_service = mock``
+    directly. Since getters live here, we must check the server module's
+    __dict__ so those overrides are respected. Uses sys.modules to avoid
+    a circular import.
+    """
+    srv = sys.modules.get("attocode_intel.server")
+    if srv is not None and name in srv.__dict__:
+        return srv.__dict__[name]  # type: ignore[no-any-return]
+    return None
+
+
+# Project-directory discovery lives in the neutral ``project_dir``
+# module so HTTP providers can import it without dragging in the MCP
+# runtime. Re-export here for backward compatibility with the existing
+# ~25 call sites that do ``from attocode_intel._shared import
+# _get_project_dir`` (or access it as ``_shared._get_project_dir``).
+from attocode_intel.project_dir import (  # noqa: F401, E402
+    _get_project_dir,
+    _walk_up,
+)
+
+
+def _get_ast_service() -> ASTService:
+    """Lazily initialize and return the ASTService singleton."""
+    from attocode_intel.request_context import current_request
+    if (request := current_request.get()) is not None:
+        return request.service._get_ast_service()
+    global _ast_service
+    override = _check_server_override("_ast_service")
+    if override is not None:
+        return override  # type: ignore[return-value]
+    if _ast_service is None:
+        from attocode_intel._internal.integrations.context.ast_service import ASTService
+
+        project_dir = _get_project_dir()
+        _ast_service = ASTService.get_instance(project_dir)
+        if not _ast_service.initialized:
+            logger.info("Initializing ASTService (skeleton) for %s...", project_dir)
+            _ast_service.initialize_skeleton(indexing_depth="auto")
+            if (
+                _ast_service._hydration_state
+                and _ast_service._hydration_state.phase != "ready"
+            ):
+                _ast_service.start_hydration()
+            logger.info(
+                "ASTService ready: %d files indexed (skeleton/hydration)",
+                len(_ast_service._ast_cache),
+            )
+    return _ast_service
+
+
+def _get_context_mgr() -> CodebaseContextManager:
+    """Lazily initialize and return the CodebaseContextManager."""
+    from attocode_intel.request_context import current_request
+    if (request := current_request.get()) is not None:
+        return request.service._get_context_mgr()
+    global _context_mgr
+    override = _check_server_override("_context_mgr")
+    if override is not None:
+        return override  # type: ignore[return-value]
+    if _context_mgr is None:
+        from attocode_intel._internal.integrations.context.codebase_context import CodebaseContextManager
+
+        project_dir = _get_project_dir()
+        _context_mgr = CodebaseContextManager(root_dir=project_dir)
+        _context_mgr.discover_files()
+    return _context_mgr
+
+
+def _get_code_analyzer() -> CodeAnalyzer:
+    """Lazily initialize and return the CodeAnalyzer."""
+    from attocode_intel.request_context import current_request
+    if (request := current_request.get()) is not None:
+        return request.service._get_code_analyzer()
+    global _code_analyzer
+    override = _check_server_override("_code_analyzer")
+    if override is not None:
+        return override  # type: ignore[return-value]
+    if _code_analyzer is None:
+        from attocode_intel._internal.integrations.context.code_analyzer import CodeAnalyzer
+
+        _code_analyzer = CodeAnalyzer()
+    return _code_analyzer
+
+
+def _get_service() -> CodeIntelService | RemoteTextService:
+    """Lazily initialize and return the CodeIntelService singleton."""
+    from attocode_intel.request_context import current_request
+    if (request := current_request.get()) is not None:
+        return request.service
+    global _service
+    srv = sys.modules.get("attocode_intel.server")
+    if srv is not None and "_service" in srv.__dict__:
+        override = srv.__dict__["_service"]
+        if override is None:
+            _service = None
+        else:
+            return override  # type: ignore[no-any-return]
+    if _remote_service is not None:
+        return _remote_service
+    if _service is not None:
+        from attocode_intel import service as code_intel_service_module
+
+        if _service.project_dir not in code_intel_service_module._instances:
+            _service = None
+    if _service is None:
+        from attocode_intel.service import CodeIntelService
+
+        project_dir = _get_project_dir()
+        _service = CodeIntelService.get_instance(project_dir)
+    return _service
+
+
+def _get_local_service() -> CodeIntelService:
+    """Return the local CodeIntelService, bypassing any remote proxy.
+
+    Some tools (e.g. ``regex_search``, ``call_graph``) have no server-side
+    HTTP route, so they cannot be proxied to a remote. They call this to run
+    against the local index even when a remote is configured, instead of
+    crashing with ``AttributeError`` on the missing remote method.
+    """
+    from attocode_intel.request_context import current_request
+    if (request := current_request.get()) is not None:
+        return request.service
+    global _service
+    srv = sys.modules.get("attocode_intel.server")
+    if srv is not None and "_service" in srv.__dict__:
+        override = srv.__dict__["_service"]
+        if override is not None and not _is_remote_service(override):
+            return override  # type: ignore[return-value]
+        if override is None:
+            _service = None
+    if _service is not None:
+        from attocode_intel import service as code_intel_service_module
+
+        if _service.project_dir not in code_intel_service_module._instances:
+            _service = None
+    if _service is None:
+        from attocode_intel.service import CodeIntelService
+
+        _service = CodeIntelService.get_instance(_get_project_dir())
+    return _service
+
+
+def _is_remote_service(obj: object) -> bool:
+    """True when *obj* is a remote proxy rather than the local service."""
+    return type(obj).__name__ == "RemoteTextService"
+
+
+def _get_remote_service() -> RemoteTextService | None:
+    """Return the configured remote text service, if any."""
+    from attocode_intel.request_context import current_request
+    if current_request.get() is not None:
+        return None
+    srv = sys.modules.get("attocode_intel.server")
+    if srv is not None and "_remote_service" in srv.__dict__:
+        return srv.__dict__["_remote_service"]  # type: ignore[no-any-return]
+    return _remote_service
+
+
+def configure_remote_service(remote_url: str, remote_token: str, remote_repo_id: str) -> None:
+    """Proxy the shared service through a remote HTTP server **if it is usable**.
+
+    Gracefully degrades to local mode (leaving ``_remote_service`` unset) when
+    the JWT is expired or the server is unreachable, recording a human-readable
+    reason in :func:`get_remote_degraded_reason`. This prevents a stale or dead
+    ``[remote]`` config from making every tool fail with "Connection refused".
+    """
+    global _remote_service, _service, _remote_degraded_reason
+    from attocode_intel.api.providers.remote_provider import RemoteTextService
+    from attocode_intel.config import token_is_expired
+
+    # Drop any previously-configured client (avoid a socket leak on reconfigure).
+    if _remote_service is not None:
+        try:
+            _remote_service.close()
+        except Exception:
+            pass
+    _remote_service = None
+    _service = None
+    _remote_degraded_reason = ""
+
+    if token_is_expired(remote_token):
+        _remote_degraded_reason = (
+            f"remote token expired — using local mode (server={remote_url})"
+        )
+        logger.warning("Code-intel %s", _remote_degraded_reason)
+        return
+
+    candidate = RemoteTextService(remote_url, remote_token, remote_repo_id)
+    if not candidate.ping():
+        _remote_degraded_reason = (
+            f"remote server unreachable at {remote_url} — using local mode"
+        )
+        logger.warning("Code-intel %s", _remote_degraded_reason)
+        try:
+            candidate.close()
+        except Exception:
+            pass
+        return
+
+    _remote_service = candidate
+    logger.info("Code-intel remote mode active: %s (repo=%s)", remote_url, remote_repo_id)
+
+
+def clear_remote_service() -> None:
+    """Reset remote service wiring (back to local mode)."""
+    global _remote_service, _remote_degraded_reason
+    if _remote_service is not None:
+        try:
+            _remote_service.close()
+        except Exception:
+            pass
+    _remote_service = None
+    _remote_degraded_reason = ""
+
+
+def get_remote_degraded_reason() -> str:
+    """Why remote mode is inactive despite being configured ('' when N/A)."""
+    return _remote_degraded_reason
+
+
+def enable_remote_if_configured(
+    project_dir: str,
+    *,
+    local_only: bool = False,
+    remote_url: str = "",
+    remote_token: str = "",
+    remote_repo_id: str = "",
+) -> None:
+    """Enable remote mode from explicit args / config / env, else stay local.
+
+    Single source of truth for the startup wiring previously duplicated (and
+    divergent) between ``server.main`` and ``cli._cmd_serve``. Explicit
+    ``remote_*`` args win; otherwise ``.attocode/config.toml`` + env are read
+    via :func:`load_remote_config`. ``configure_remote_service`` then health/
+    expiry-gates the remote and falls back to local on any problem.
+    """
+    clear_remote_service()
+    if local_only:
+        return
+    if not remote_url:
+        from attocode_intel.config import load_remote_config
+
+        rc = load_remote_config(project_dir)
+        if rc.is_configured:
+            remote_url, remote_token, remote_repo_id = rc.server, rc.token, rc.repo_id
+    if remote_url:
+        configure_remote_service(remote_url, remote_token, remote_repo_id)
+
+
+def _get_explorer() -> HierarchicalExplorer:
+    """Lazily initialize the hierarchical explorer."""
+    from attocode_intel.request_context import current_request
+    if (request := current_request.get()) is not None:
+        return request.service._get_explorer()
+    global _explorer
+    override = _check_server_override("_explorer")
+    if override is not None:
+        return override  # type: ignore[return-value]
+    if _explorer is None:
+        from attocode_intel._internal.integrations.context.hierarchical_explorer import HierarchicalExplorer
+        ctx = _get_context_mgr()
+        ast_svc = _get_ast_service()
+        _explorer = HierarchicalExplorer(ctx, ast_service=ast_svc)
+    return _explorer
+
+
+def _get_frecency_tracker() -> FrecencyTracker:
+    """Get shared frecency tracker (thread-safe via get_tracker lock)."""
+    from attocode_intel._internal.integrations.context.frecency import get_tracker
+
+    project_dir = _get_project_dir()
+    db_path = os.path.join(project_dir, ".attocode", "frecency")
+    return get_tracker(db_path=db_path)

attocode_intel/analysis_coverage.py

@@ -0,0 +1,56 @@
+"""Report analysis capabilities independently of index progress."""
+from __future__ import annotations
+
+import shutil
+from collections import Counter
+
+
+def language_capabilities(verified_languages=()):
+    from ._internal.integrations.context.codebase_ast import LANG_EXTENSIONS
+    from ._internal.integrations.context.codebase_context import IMPORT_RESOLVERS
+    from ._internal.integrations.context.ts_parser import is_available, supported_languages
+    from ._internal.integrations.lsp.client import BUILTIN_SERVERS
+
+    result = {}
+    for language in sorted(set(LANG_EXTENSIONS.values()) | set(supported_languages())):
+        server = BUILTIN_SERVERS.get("typescript" if language == "javascript" else language)
+        parser = is_available(language)
+        result[language] = {
+            "search": "available",
+            "definitions": "syntax" if parser else "fallback",
+            "references": "syntax_candidates" if parser else "text_candidates",
+            "dependencies": "partial" if language in IMPORT_RESOLVERS else "unavailable",
+            "test_relationships": "heuristic",
+            "precision_server": server.command if server else None,
+            "precision_installed": bool(server and shutil.which(server.command)),
+            "precision_verified": language in verified_languages,
+        }
+    return result
+
+
+def analysis_report(service, precision=None):
+    ast = service._ast_service
+    if ast is None:
+        return {"status": "not_started", "absence_proven": False}
+    cache = ast._ast_cache.copy()
+    tiers = Counter(getattr(a, "parsing_tier", "unknown") or "unknown" for a in cache.values())
+    graph = ast._context_mgr._dep_graph
+    unresolved = graph.unresolved if graph else {}
+    limitations = [
+        "Syntax matches are candidates; dynamic dispatch and external dependencies may be unresolved.",
+        "No matches do not prove absence of references or impact.",
+    ]
+    return {
+        "status": "partial",
+        "absence_proven": False,
+        "sources": sorted(tiers),
+        "files_by_parser": dict(tiers),
+        "unresolved_imports": sum(len(v) for v in unresolved.values()),
+        "unresolved_import_samples": [
+            {"file": path, "module": module}
+            for path, modules in sorted(unresolved.items())[:5] for module in modules[:3]
+        ],
+        "unresolved_includes_external": True,
+        "precision": precision or {"status": "not_requested"},
+        "limitations": limitations,
+    }

attocode_intel/api/__init__.py

@@ -0,0 +1 @@
+"""FastAPI HTTP API for Attocode Code Intelligence."""

attocode_intel/api/access.py

@@ -0,0 +1,32 @@
+"""Apply repository authorization before legacy routes can consult cached services."""
+
+from __future__ import annotations
+
+import re
+
+from fastapi import HTTPException
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import JSONResponse
+
+
+class RepositoryAccessMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request, call_next):
+        config = request.app.state.config
+        if config.is_service_mode:
+            match = re.match(r"/api/v[12]/(?:projects|repos)/([^/]+)", request.url.path)
+            if match:
+                from attocode_intel.api.auth import resolve_auth
+                from attocode_intel.remote import authorized_repo
+
+                try:
+                    auth = await resolve_auth(request.headers.get("authorization"))
+                    await authorized_repo(
+                        match.group(1), auth, write=request.method not in {"GET", "HEAD", "OPTIONS"}
+                    )
+                except HTTPException as exc:
+                    return JSONResponse({"detail": exc.detail}, status_code=exc.status_code)
+            elif request.url.path.rstrip("/") == "/api/v1/projects":
+                return JSONResponse(
+                    {"detail": "Use organization-scoped repository management"}, status_code=403
+                )
+        return await call_next(request)

attocode_intel/api/app.py

@@ -0,0 +1,247 @@
+"""FastAPI application factory for Attocode Code Intelligence."""
+
+from __future__ import annotations
+
+import logging
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING
+
+from attocode_intel import __version__
+from attocode_intel.config import CodeIntelConfig
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator
+
+    from fastapi import FastAPI
+
+logger = logging.getLogger(__name__)
+
+
+async def _run_migrations(database_url: str) -> None:
+    """Run Alembic migrations programmatically."""
+    import asyncio
+    from pathlib import Path
+
+    from alembic import command
+    from alembic.config import Config
+
+    migrations_dir = Path(__file__).resolve().parent.parent / "migrations"
+    alembic_cfg = Config(str(migrations_dir / "alembic.ini"))
+    alembic_cfg.set_main_option("script_location", str(migrations_dir))
+    alembic_cfg.set_main_option("sqlalchemy.url", database_url)
+
+    # Alembic is sync — run in thread to avoid blocking the event loop
+    loop = asyncio.get_running_loop()
+    await loop.run_in_executor(None, command.upgrade, alembic_cfg, "head")
+
+
+@asynccontextmanager
+async def _lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Startup/shutdown lifecycle — initialize DB engine in service mode."""
+    config: CodeIntelConfig = app.state.config
+    if config.is_service_mode:
+        from attocode_intel.db.engine import dispose_engine, init_engine
+
+        init_engine(config.database_url)
+        logger.info("Service mode: database engine initialized")
+
+        # Auto-run migrations on startup
+        try:
+            await _run_migrations(config.database_url)
+            logger.info("Service mode: migrations applied")
+        except Exception:
+            logger.exception("Failed to run migrations on startup")
+            raise
+    async with app.state.mcp_transport.manager.run():
+        yield
+    await app.state.mcp_transport.gateway.close()
+
+    # Shutdown debouncer
+    from attocode_intel.api.routes.notify import _debouncer
+
+    if _debouncer is not None:
+        await _debouncer.shutdown()
+
+    if config.is_service_mode:
+        from attocode_intel.db.engine import dispose_engine
+
+        await dispose_engine()
+        logger.info("Service mode: database engine disposed")
+
+
+def create_app(config: CodeIntelConfig | None = None) -> FastAPI:
+    """Create and configure the FastAPI application.
+
+    Args:
+        config: Service configuration. If None, reads from environment.
+    """
+    from fastapi import FastAPI
+    from fastapi.middleware.cors import CORSMiddleware
+
+    from attocode_intel.api import deps
+    from attocode_intel.api.middleware import MetricsMiddleware, RequestLoggingMiddleware
+    from attocode_intel.api.routes import (
+        adr,
+        analysis,
+        files,
+        graph,
+        graph_viz,
+        health,
+        history,
+        learning,
+        lsp,
+        notify,
+        projects,
+        search,
+    )
+
+    if config is None:
+        config = CodeIntelConfig.from_env()
+
+    deps.configure(config)
+
+    app = FastAPI(
+        title="Attocode Code Intelligence",
+        description=(
+            "Code intelligence service with AST parsing, dependency graphs, "
+            "semantic search, impact analysis, and more. "
+            "v1 endpoints return text (MCP-compatible), "
+            "v2 endpoints return structured JSON (UI-ready)."
+        ),
+        version=__version__,
+        docs_url="/docs",
+        redoc_url="/redoc",
+        lifespan=_lifespan,
+    )
+    app.state.config = config
+    from attocode_intel.api.mcp_transport import MCPTransport
+    from starlette.routing import Mount, Route
+
+    transport = MCPTransport(config)
+    app.state.mcp_transport = transport
+    app.router.routes.append(Route("/mcp", endpoint=transport, methods=["GET", "POST", "DELETE"]))
+    app.router.routes.append(Mount("/mcp", app=transport))
+
+    # Without configured origins, no other web origin can call the API, so no CORS headers.
+    # credentials=True is invalid with origins=["*"] per the CORS spec.
+    if config.cors_origins:
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=config.cors_origins,
+            allow_credentials="*" not in config.cors_origins,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+    from attocode_intel.api.access import RepositoryAccessMiddleware
+
+    app.add_middleware(RepositoryAccessMiddleware)
+    app.add_middleware(RequestLoggingMiddleware)
+    app.add_middleware(MetricsMiddleware)
+
+    # Rate limiting (service mode only)
+    if config.is_service_mode:
+        from attocode_intel.api.middleware import RateLimitMiddleware
+
+        app.add_middleware(RateLimitMiddleware, requests_per_minute=300)
+
+    # Core routes — each module has router_v1 (text) + router_v2 (JSON)
+    from attocode_intel.api.routes.operations import router as operations_router
+
+    app.include_router(operations_router)
+    app.include_router(health.router)
+    app.include_router(projects.router)
+    app.include_router(adr.router_v1)
+    app.include_router(analysis.router_v1)
+    app.include_router(analysis.router_v2)
+    app.include_router(search.router_v1)
+    app.include_router(search.router_v2)
+    app.include_router(graph.router_v1)
+    app.include_router(graph.router_v2)
+    app.include_router(lsp.router_v1)
+    app.include_router(lsp.router_v2)
+    app.include_router(learning.router)
+    app.include_router(learning.router_v2)
+    app.include_router(notify.router)
+    app.include_router(files.router)
+    app.include_router(history.router_v1)
+    app.include_router(history.router_v2)
+    app.include_router(graph_viz.router)
+
+    # Service mode routes
+    if config.is_service_mode:
+        from attocode_intel.api.routes import (
+            activity,
+            api_keys,
+            auth,
+            branches,
+            cross_repo_search,
+            embeddings,
+            files_v2,
+            gc,
+            git_v2,
+            jobs,
+            orgs,
+            preferences,
+            presence,
+            repos,
+            snapshots,
+            webhooks,
+            websocket,
+        )
+
+        app.include_router(auth.router)
+        app.include_router(orgs.router)
+        app.include_router(repos.router)
+        app.include_router(api_keys.router)
+        app.include_router(branches.router)
+        app.include_router(webhooks.router)
+        app.include_router(websocket.router)
+        app.include_router(jobs.router)
+        # v2 service-mode routes
+        app.include_router(files_v2.router)
+        app.include_router(git_v2.router)
+        app.include_router(embeddings.router)
+        app.include_router(presence.router)
+        app.include_router(activity.router)
+        app.include_router(preferences.router)
+        app.include_router(cross_repo_search.router)
+        app.include_router(gc.router)
+        app.include_router(snapshots.router)
+
+    # Graph visualization — serve the bundled HTML page at /graph
+    import os
+    from pathlib import Path
+
+    from starlette.responses import FileResponse as _FileResponse
+
+    _graph_html = Path(__file__).resolve().parent / "static" / "graph.html"
+
+    @app.get("/graph", include_in_schema=False)
+    async def graph_visualization_page() -> _FileResponse:
+        """Serve the D3 dependency-graph visualization."""
+        return _FileResponse(str(_graph_html), media_type="text/html")
+
+    # SPA fallback — serve frontend static files (registered LAST so it
+    # doesn't shadow /api/*, /docs, /redoc, /openapi.json).
+
+    static_dir = os.environ.get("ATTOCODE_STATIC_DIR", "/app/static")
+    if os.path.isdir(static_dir):
+        from starlette.responses import FileResponse
+
+        @app.get("/{full_path:path}", include_in_schema=False)
+        async def spa_fallback(full_path: str) -> FileResponse:
+            from pathlib import Path
+
+            file_path = (Path(static_dir) / full_path).resolve()
+            if file_path.is_relative_to(Path(static_dir).resolve()) and file_path.is_file():
+                return FileResponse(file_path)
+            return FileResponse(os.path.join(static_dir, "index.html"))
+
+        logger.info("SPA fallback enabled from %s", static_dir)
+
+    logger.info(
+        "FastAPI app created for %s (service_mode=%s)",
+        config.project_dir or "(no project)",
+        config.is_service_mode,
+    )
+    return app