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

attocode_intel/presence.py

@@ -0,0 +1,160 @@
+"""Redis-backed presence tracking for collaboration."""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+# Presence entries expire after 120 seconds without heartbeat
+_PRESENCE_TTL = 120
+
+
+@dataclass(slots=True)
+class PresenceEntry:
+    user_id: str
+    user_name: str
+    file: str
+    session_id: str
+    timestamp: float
+
+
+async def set_presence(
+    repo_id: str,
+    user_id: str,
+    user_name: str,
+    file_path: str,
+    session_id: str,
+) -> None:
+    """Set or update presence for a user in a repo."""
+    from attocode_intel.redis import get_redis
+
+    redis = await get_redis()
+    key = f"presence:{repo_id}"
+    field = f"{user_id}:{session_id}"
+
+    # Check for file change to publish event
+    old_raw = await redis.hget(key, field)
+    old_file = ""
+    if old_raw:
+        try:
+            old_data = json.loads(old_raw)
+            old_file = old_data.get("file", "")
+        except (json.JSONDecodeError, TypeError):
+            pass
+
+    value = json.dumps({
+        "user_id": user_id,
+        "user_name": user_name,
+        "file": file_path,
+        "session_id": session_id,
+        "timestamp": time.time(),
+    })
+    await redis.hset(key, field, value)
+
+    # Set TTL on the hash key (renews on each update)
+    await redis.expire(key, _PRESENCE_TTL)
+
+    # Publish presence events
+    from attocode_intel.pubsub import publish_event
+
+    if not old_raw:
+        await publish_event(repo_id, "presence.joined", {
+            "user_id": user_id, "user_name": user_name, "file": file_path,
+        })
+    elif old_file != file_path:
+        await publish_event(repo_id, "presence.file_changed", {
+            "user_id": user_id, "user_name": user_name,
+            "from_file": old_file, "to_file": file_path,
+        })
+
+
+async def remove_presence(
+    repo_id: str,
+    user_id: str,
+    session_id: str,
+) -> None:
+    """Remove presence for a user session."""
+    from attocode_intel.redis import get_redis
+
+    redis = await get_redis()
+    key = f"presence:{repo_id}"
+    field = f"{user_id}:{session_id}"
+
+    # Get user name before removing
+    raw = await redis.hget(key, field)
+    user_name = ""
+    if raw:
+        try:
+            data = json.loads(raw)
+            user_name = data.get("user_name", "")
+        except (json.JSONDecodeError, TypeError):
+            pass
+
+    await redis.hdel(key, field)
+
+    from attocode_intel.pubsub import publish_event
+
+    await publish_event(repo_id, "presence.left", {
+        "user_id": user_id, "user_name": user_name,
+    })
+
+
+async def get_presence(repo_id: str) -> list[PresenceEntry]:
+    """Get all active presence entries for a repo."""
+    from attocode_intel.redis import get_redis
+
+    redis = await get_redis()
+    key = f"presence:{repo_id}"
+
+    all_entries = await redis.hgetall(key)
+    now = time.time()
+    result = []
+
+    for field, raw in all_entries.items():
+        try:
+            data = json.loads(raw)
+        except (json.JSONDecodeError, TypeError):
+            continue
+
+        # Filter out stale entries
+        ts = data.get("timestamp", 0)
+        if now - ts > _PRESENCE_TTL:
+            await redis.hdel(key, field)
+            continue
+
+        result.append(PresenceEntry(
+            user_id=data["user_id"],
+            user_name=data.get("user_name", ""),
+            file=data.get("file", ""),
+            session_id=data.get("session_id", ""),
+            timestamp=ts,
+        ))
+
+    return result
+
+
+async def heartbeat(
+    repo_id: str,
+    user_id: str,
+    session_id: str,
+) -> None:
+    """Renew presence TTL via heartbeat."""
+    from attocode_intel.redis import get_redis
+
+    redis = await get_redis()
+    key = f"presence:{repo_id}"
+    field = f"{user_id}:{session_id}"
+
+    raw = await redis.hget(key, field)
+    if raw:
+        try:
+            data = json.loads(raw)
+            data["timestamp"] = time.time()
+            await redis.hset(key, field, json.dumps(data))
+            await redis.expire(key, _PRESENCE_TTL)
+        except (json.JSONDecodeError, TypeError):
+            pass

attocode_intel/probe.py

@@ -0,0 +1,110 @@
+"""Runtime MCP install probing for file-based assistant configurations."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+from dataclasses import replace
+
+from attocode_intel.installer import ResolvedInstallSpec, resolve_install_spec
+from attocode_intel._internal.integrations.mcp.client import MCPClient
+
+
+def _substitute_workspace_folder(value: str, project_dir: str) -> str:
+    return value.replace("${workspaceFolder}", project_dir)
+
+
+def _materialize_spec(spec: ResolvedInstallSpec, project_dir: str) -> ResolvedInstallSpec:
+    """Resolve runtime placeholders before spawning the stdio process."""
+    env = {
+        key: _substitute_workspace_folder(value, project_dir)
+        for key, value in spec.env.items()
+    }
+    return replace(
+        spec,
+        command=_substitute_workspace_folder(spec.command, project_dir),
+        args=[_substitute_workspace_folder(arg, project_dir) for arg in spec.args],
+        env=env,
+    )
+
+
+def _has_concrete_project_arg(args: list[str]) -> bool:
+    for idx, arg in enumerate(args):
+        if arg == "--project" and idx + 1 < len(args):
+            return True
+        if arg.startswith("--project="):
+            return True
+    return False
+
+
+async def _run_probe(
+    spec: ResolvedInstallSpec,
+    *,
+    project_dir: str,
+    should_call_project_summary: bool,
+) -> tuple[int, int]:
+    client = MCPClient(
+        spec.command,
+        server_args=spec.args,
+        server_name=spec.target,
+        env=spec.env,
+        cwd=project_dir,
+    )
+    try:
+        await client.connect()
+        if not client.is_connected:
+            raise RuntimeError("MCP initialize did not complete")
+        if should_call_project_summary:
+            result = await client.call_tool("project_summary", {"max_tokens": 128})
+            if not result.success:
+                raise RuntimeError(result.error or "project_summary probe failed")
+        return len(client.tools), 0
+    finally:
+        await client.disconnect()
+
+
+def probe_install(
+    target: str,
+    project_dir: str = ".",
+    scope: str = "local",
+    *,
+    force_project_probe: bool = False,
+) -> int:
+    """Run a runtime MCP probe for an installed assistant target.
+
+    Exit codes:
+      0: success
+      1: target missing or probe failed
+      2: unsupported target for v1 probing
+    """
+    abs_project = os.path.abspath(project_dir)
+    resolved = resolve_install_spec(target, project_dir=abs_project, scope=scope)
+    if resolved is None:
+        print(f"{target}: attocode-code-intel is not installed for scope={scope}.", file=sys.stderr)
+        return 1
+    if not resolved.is_supported:
+        print(f"{target}: {resolved.unsupported_reason}", file=sys.stderr)
+        return 2
+
+    runtime_spec = _materialize_spec(resolved, abs_project)
+    should_call_project_summary = force_project_probe or _has_concrete_project_arg(runtime_spec.args)
+
+    try:
+        tools_count, _ = asyncio.run(
+            _run_probe(
+                runtime_spec,
+                project_dir=abs_project,
+                should_call_project_summary=should_call_project_summary,
+            )
+        )
+    except Exception as exc:
+        print(f"{target}: probe failed ({type(exc).__name__}: {exc})", file=sys.stderr)
+        return 1
+
+    project_note = " with project_summary probe" if should_call_project_summary else ""
+    print(
+        f"{target}: probe succeeded{project_note} "
+        f"({runtime_spec.command} {' '.join(runtime_spec.args)}; tools={tools_count})"
+    )
+    return 0

attocode_intel/project_dir.py

@@ -0,0 +1,97 @@
+"""Project-directory discovery — MCP-free neutral helpers.
+
+These functions used to live in ``attocode_intel._shared``, but
+``_shared`` unconditionally imports ``mcp.server.fastmcp`` at module
+load time and ``sys.exit(1)`` s if ``mcp`` isn't installed. The HTTP
+API layer (``api/providers/``) needs to discover the current project
+directory without dragging in the MCP runtime, so the logic is hosted
+here.
+
+``_shared`` re-exports both symbols for backward compatibility with
+the 25-odd call sites that already import them via ``_shared``.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+logger = logging.getLogger(__name__)
+
+
+def _walk_up(start: str, max_depth: int = 20) -> Iterator[str]:
+    """Walk upward from start, yielding parent directories up to max_depth.
+
+    Yields each ancestor directory starting from dirname(start) (the immediate
+    parent), then climbing upward until filesystem root.
+    """
+    path = os.path.dirname(start)
+    for _ in range(max_depth):
+        yield path
+        parent = os.path.dirname(path)
+        if parent == path:
+            break  # Reached filesystem root
+        path = parent
+
+
+def _get_project_dir() -> str:
+    """Get the project directory from env var, CLI arg, or auto-discovery.
+
+    Resolution order:
+    1. ATTOCODE_PROJECT_DIR env var (set by --project CLI arg)
+    2. Walk up from CWD looking for .git/ or .attocode/ marker
+    3. Fall back to CWD
+    """
+    from attocode_intel.request_context import current_request
+    if (request := current_request.get()) is not None:
+        return request.project_dir
+    project_dir = os.environ.get("ATTOCODE_PROJECT_DIR", "")
+    if project_dir:
+        return os.path.abspath(project_dir)
+    return find_project_root(os.getcwd())
+
+
+def find_project_root(start: str) -> str:
+    """Return the nearest directory at or above ``start`` with a project marker.
+
+    The markers are ``.git`` (a directory, or a file in a worktree) and
+    ``.attocode``. The search skips the home directory: ``~/.attocode`` holds
+    user-wide settings and caches, so it does not make home a project. Before
+    this rule, a server started in a folder without markers indexed the whole
+    home directory. Without a marker, ``start`` is the root.
+    """
+    home = os.path.realpath(os.path.expanduser("~"))
+    for dir_path in [start, *_walk_up(start)]:
+        if os.path.realpath(dir_path) == home:
+            continue
+        for marker in (".git", ".attocode"):
+            if os.path.exists(os.path.join(dir_path, marker)):
+                logger.debug(
+                    "Auto-discovered project root: %s (marker: %s)",
+                    dir_path, marker,
+                )
+                return dir_path
+
+    logger.debug("No project marker found, falling back to %s", start)
+    return start
+
+
+def cache_folder(project_dir: str | os.PathLike) -> Path:
+    """Return ``<project>/.attocode``, and make it if it does not exist.
+
+    A folder that this function makes gets a ``.gitignore`` with ``*``, so the
+    index stays out of commits. A folder that exists keeps its own rules: some
+    projects commit settings in it.
+    """
+    folder = Path(project_dir) / ".attocode"
+    try:
+        folder.mkdir()
+    except FileExistsError:
+        return folder
+    (folder / ".gitignore").write_text("# Local index data of attocode-code-intel\n*\n", encoding="utf-8")
+    return folder

attocode_intel/pubsub.py

@@ -0,0 +1,113 @@
+"""Redis Streams — persistent event publishing and subscription for real-time updates.
+
+Uses Redis Streams (XADD/XREAD) instead of ephemeral PubSub so that clients
+that disconnect can resume from their last-seen event ID. Stream entries are
+auto-trimmed to keep memory bounded.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import AsyncGenerator
+
+logger = logging.getLogger(__name__)
+
+# Max entries per stream before auto-trimming (MAXLEN ~)
+_MAX_STREAM_LEN = 10_000
+
+
+async def publish_event(repo_id: str, event_type: str, payload: dict) -> str | None:
+    """Publish an event to the repo's stream. Returns the stream entry ID, or None on error.
+
+    Fire-and-forget semantics — never raises.
+    """
+    try:
+        from attocode_intel.redis import get_redis
+
+        redis = await get_redis()
+        stream_key = f"repo:{repo_id}:stream"
+        message = json.dumps({"type": event_type, "payload": payload})
+        entry_id = await redis.xadd(
+            stream_key,
+            {"event": message},
+            maxlen=_MAX_STREAM_LEN,
+            approximate=True,
+        )
+        return entry_id
+    except Exception:
+        logger.warning("Failed to publish event %s for repo %s", event_type, repo_id, exc_info=True)
+        return None
+
+
+async def subscribe(
+    repo_id: str,
+    last_event_id: str = "$",
+    block_ms: int = 5000,
+) -> AsyncGenerator[dict, None]:
+    """Subscribe to events for a repository using Redis Streams.
+
+    Yields event dicts. If last_event_id is provided, replays all events
+    after that ID before switching to live mode.
+
+    Args:
+        repo_id: Repository ID to subscribe to.
+        last_event_id: Resume from this event ID. "$" = new events only.
+            "0" = replay all available events.
+        block_ms: How long to block waiting for new events (milliseconds).
+    """
+    from attocode_intel.redis import get_redis
+
+    redis = await get_redis()
+    stream_key = f"repo:{repo_id}:stream"
+    cursor = last_event_id
+
+    try:
+        while True:
+            # XREAD blocks for up to block_ms waiting for new entries
+            results = await redis.xread(
+                {stream_key: cursor},
+                count=100,
+                block=block_ms,
+            )
+
+            if not results:
+                # Timeout — no new events, yield control and retry
+                continue
+
+            for _stream_name, entries in results:
+                for entry_id, fields in entries:
+                    cursor = entry_id
+                    event_data = fields.get("event") or fields.get(b"event")
+                    if event_data is None:
+                        continue
+                    if isinstance(event_data, bytes):
+                        event_data = event_data.decode("utf-8")
+                    try:
+                        data = json.loads(event_data)
+                        # Include the stream entry ID so clients can resume
+                        data["_stream_id"] = entry_id if isinstance(entry_id, str) else entry_id.decode("utf-8")
+                        yield data
+                    except (json.JSONDecodeError, TypeError):
+                        continue
+    except GeneratorExit:
+        pass
+    except Exception:
+        logger.warning("Stream subscription ended for repo %s", repo_id, exc_info=True)
+
+
+async def get_stream_info(repo_id: str) -> dict:
+    """Get info about the repo's event stream (length, first/last entry IDs)."""
+    try:
+        from attocode_intel.redis import get_redis
+
+        redis = await get_redis()
+        stream_key = f"repo:{repo_id}:stream"
+        info = await redis.xinfo_stream(stream_key)
+        return {
+            "length": info.get("length", 0),
+            "first_entry": info.get("first-entry", [None])[0] if info.get("first-entry") else None,
+            "last_entry": info.get("last-entry", [None])[0] if info.get("last-entry") else None,
+        }
+    except Exception:
+        return {"length": 0, "first_entry": None, "last_entry": None}