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

attocode_intel/redis.py

@@ -0,0 +1,51 @@
+"""Redis connection management."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from redis.asyncio import Redis
+
+logger = logging.getLogger(__name__)
+
+_redis: Redis | None = None
+
+
+async def get_redis() -> Redis:
+    """Get or create the Redis connection singleton."""
+    global _redis
+    if _redis is not None:
+        return _redis
+
+    from attocode_intel.api.deps import get_config
+
+    config = get_config()
+    if not config.redis_url:
+        raise RuntimeError("REDIS_URL not configured")
+
+    from redis.asyncio import Redis as AsyncRedis
+
+    _redis = AsyncRedis.from_url(config.redis_url, decode_responses=True)
+    logger.info("Redis connection initialized")
+    return _redis
+
+
+async def close_redis() -> None:
+    """Close the Redis connection."""
+    global _redis
+    if _redis is not None:
+        await _redis.aclose()
+        _redis = None
+        logger.info("Redis connection closed")
+
+
+async def health_check() -> bool:
+    """Check if Redis is reachable."""
+    try:
+        r = await get_redis()
+        await r.ping()
+        return True
+    except Exception:
+        return False

attocode_intel/reference_pages.py

@@ -0,0 +1,60 @@
+"""Workspace-scoped reference continuations over immutable result snapshots."""
+from __future__ import annotations
+
+import json
+import secrets
+from collections import OrderedDict
+from copy import deepcopy
+
+from attocode_intel.output import bounded_compact, compact_result
+
+
+def scope(context, args):
+    tracker = context.stores.get("freshness")
+    return (context.workspace, context.source, context.revision, getattr(tracker, "generation", 0),
+            args["symbol_name"], args.get("file_path"), args.get("line"))
+
+
+def continuation(context, args):
+    cursor = args.get("cursor")
+    if not cursor:
+        return None
+    pages = context.stores.get("reference_pages", {})
+    record = pages.get(cursor)
+    if record is None or record["scope"] != scope(context, args):
+        raise ValueError("Reference cursor expired or belongs to another query; restart without cursor")
+    return record
+
+
+def paginate(context, args, payload, metadata, budget, compact):
+    size = args.get("page_size") if args.get("page_size") is not None else 20
+    if not 1 <= size <= 100:
+        raise ValueError("page_size must be between 1 and 100")
+    record = continuation(context, args)
+    offset = record["offset"] if record else 0
+    if record:
+        payload, metadata = record["payload"], record["metadata"]
+    rows = payload["references"]
+    token = secrets.token_hex(16)
+    page = {**payload, "references": rows[offset:offset + size],
+            "next_cursor": token, "total_references": len(rows)}
+    metadata = {**metadata, "truncated": offset + size < len(rows)}
+    if compact:
+        rendered = json.loads(bounded_compact(metadata, page, budget).content[0].text)
+        page = rendered["data"]
+        compact_meta = rendered["metadata"]
+    count = len(page["references"])
+    if count == 0 and offset < len(rows):
+        raise ValueError("max_tokens is too small for one reference and provenance; increase it")
+    more = offset + count < len(rows)
+    page["next_cursor"] = token if more else None
+    if more:
+        pages = context.stores.setdefault("reference_pages", OrderedDict())
+        pages[token] = {"scope": scope(context, args), "offset": offset + count,
+                        "payload": payload, "metadata": metadata}
+        while len(pages) > 64:
+            pages.popitem(last=False)
+    if compact:
+        compact_meta["truncated"] = compact_meta.get("truncated", False) or more
+        return compact_result(compact_meta, page)
+    return deepcopy(page), metadata

attocode_intel/remote.py

@@ -0,0 +1,131 @@
+"""Authenticated repository selection and immutable Git snapshots."""
+
+from __future__ import annotations
+
+import asyncio
+import subprocess
+import uuid
+from contextvars import ContextVar
+from pathlib import Path
+
+from filelock import FileLock
+
+from attocode_intel.catalog import is_write, remote_available
+from attocode_intel.request_context import RequestContext
+
+remote_workspace: ContextVar[str] = ContextVar("remote_workspace", default="")
+remote_profile: ContextVar[str] = ContextVar("remote_profile", default="full")
+
+remote_identity: ContextVar[object | None] = ContextVar("intelligence_identity", default=None)
+
+
+async def authorized_repo(repo_id: str, auth, *, write: bool = False):
+    from fastapi import HTTPException
+    from sqlalchemy import select
+
+    from attocode_intel.db.engine import get_session
+    from attocode_intel.db.models import OrgMembership, Repository
+
+    try:
+        rid = uuid.UUID(repo_id)
+    except ValueError as exc:
+        raise HTTPException(
+            404, "Repository not found; supply workspace as a repository ID"
+        ) from exc
+    if auth is None or auth.auth_method == "legacy":
+        raise HTTPException(401, "Authentication required")
+    required = "write" if write else "read"
+    if (
+        auth.auth_method == "api_key"
+        and required not in auth.scopes
+        and f"intelligence:{required}" not in auth.scopes
+    ):
+        raise HTTPException(403, f"API key requires intelligence:{required} scope")
+    async for session in get_session():
+        repo = (
+            await session.execute(select(Repository).where(Repository.id == rid))
+        ).scalar_one_or_none()
+        if repo is None or (auth.org_id and auth.org_id != repo.org_id):
+            raise HTTPException(404, "Repository not found")
+        if auth.user_id:
+            membership = (
+                await session.execute(
+                    select(OrgMembership).where(
+                        OrgMembership.org_id == repo.org_id,
+                        OrgMembership.user_id == auth.user_id,
+                        OrgMembership.accepted_at.is_not(None),
+                    )
+                )
+            ).scalar_one_or_none()
+            if membership is None:
+                raise HTTPException(404, "Repository not found")
+        elif auth.auth_method != "api_key" or auth.org_id != repo.org_id:
+            raise HTTPException(404, "Repository not found")
+        return repo
+    raise HTTPException(503, "Repository database unavailable")
+
+
+def committed_snapshot(
+    repo_path: str, cache_root: str, repo_id: str, revision: str
+) -> tuple[str, str]:
+    """Create a detached worktree; never change the source checkout or upload edits."""
+
+    def git(*args):
+        result = subprocess.run(
+            [
+                "git",
+                "-c",
+                "core.hooksPath=/dev/null",
+                "-c",
+                "core.fsmonitor=false",
+                "-C",
+                repo_path,
+                *args,
+            ],
+            capture_output=True,
+            text=True,
+            timeout=90,
+            check=True,
+        )
+        return result.stdout.strip()
+
+    commit = git("rev-parse", "--verify", "--end-of-options", f"{revision}^{{commit}}")
+    base = Path(cache_root) / ".intelligence-snapshots" / repo_id
+    base.mkdir(parents=True, exist_ok=True)
+    target = base / commit
+    with FileLock(str(base / "snapshots.lock"), timeout=90):
+        if not (target / ".git").exists():
+            git("worktree", "add", "--detach", str(target), commit)
+        # Prevent repository symlinks from exposing files outside the snapshot.
+        for path in target.rglob("*"):
+            if path.is_symlink() and not path.resolve().is_relative_to(target.resolve()):
+                raise ValueError(
+                    f"Snapshot contains an external symlink: {path.relative_to(target)}"
+                )
+    return str(target.resolve()), commit
+
+
+class RemoteResolver:
+    def __init__(self, config):
+        self.config = config
+
+    async def __call__(self, workspace, revision, name):
+        workspace = workspace or remote_workspace.get()
+        auth = remote_identity.get()
+        write = is_write(name)
+        repo = await authorized_repo(workspace, auth, write=write)
+        if not remote_available(name):
+            raise ValueError(
+                "This operation is local-only; remote source snapshots cannot be modified."
+            )
+        path = repo.clone_path or repo.local_path
+        if not path:
+            raise ValueError("Repository has not been cloned or indexed yet")
+        path, commit = await asyncio.to_thread(
+            committed_snapshot,
+            path,
+            self.config.git_clone_dir,
+            str(repo.id),
+            revision or repo.default_branch,
+        )
+        return RequestContext(path, str(repo.id), commit, "remote", auth)

attocode_intel/repo_ranker.py

@@ -0,0 +1,246 @@
+"""Graph-ranked repo map using PageRank.
+
+Ranks files and symbols by their connectivity in the
+dependency graph, weighted by task relevance. Produces
+a token-budgeted summary of the most important code.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from attocode_intel.focused_evidence import task_terms
+
+
+@dataclass(slots=True)
+class RankedEntry:
+    """A ranked file or symbol in the repo map."""
+    path: str
+    score: float
+    symbols: list[str] = field(default_factory=list)
+    line_count: int = 0
+    category: str = ""  # "core", "util", "test", etc.
+
+
+@dataclass(slots=True)
+class RepoMapResult:
+    """Result of repo map ranking."""
+    entries: list[RankedEntry]
+    total_files: int
+    token_budget: int
+    tokens_used: int
+    truncated: bool = False
+
+
+def pagerank(
+    adjacency: dict[str, list[str]],
+    *,
+    damping: float = 0.85,
+    iterations: int = 30,
+    tolerance: float = 1e-6,
+) -> dict[str, float]:
+    """Compute PageRank scores for nodes in a directed graph.
+
+    Args:
+        adjacency: Maps each node to its outgoing edges (dependencies).
+        damping: Damping factor (probability of following a link).
+        iterations: Maximum iterations.
+        tolerance: Convergence threshold.
+
+    Returns:
+        Dict mapping node -> PageRank score.
+    """
+    nodes = set(adjacency.keys())
+    for targets in adjacency.values():
+        nodes.update(targets)
+
+    if not nodes:
+        return {}
+
+    n = len(nodes)
+    node_list = sorted(nodes)
+    node_idx = {node: i for i, node in enumerate(node_list)}
+
+    # Build reverse adjacency (who points to me?)
+    in_links: dict[int, list[int]] = {i: [] for i in range(n)}
+    out_degree: dict[int, int] = {i: 0 for i in range(n)}
+
+    for source, targets in adjacency.items():
+        src_idx = node_idx[source]
+        valid_targets = [t for t in targets if t in node_idx]
+        out_degree[src_idx] = len(valid_targets)
+        for target in valid_targets:
+            in_links[node_idx[target]].append(src_idx)
+
+    # Initialize uniform
+    scores = [1.0 / n] * n
+    base = (1.0 - damping) / n
+
+    # Identify dangling nodes (no outgoing edges)
+    dangling = [i for i in range(n) if out_degree[i] == 0]
+
+    for _ in range(iterations):
+        # Redistribute dangling node rank uniformly
+        dangling_sum = sum(scores[i] for i in dangling)
+        new_scores = [0.0] * n
+        for i in range(n):
+            rank_sum = sum(
+                scores[j] / out_degree[j]
+                for j in in_links[i]
+                if out_degree[j] > 0
+            )
+            new_scores[i] = base + damping * (rank_sum + dangling_sum / n)
+
+        # Check convergence
+        diff = sum(abs(new_scores[i] - scores[i]) for i in range(n))
+        scores = new_scores
+        if diff < tolerance:
+            break
+
+    return {node_list[i]: scores[i] for i in range(n)}
+
+
+def _task_relevance(path: str, task_keywords: set[str], excluded_keywords: set[str]) -> float:
+    """Compute task relevance score for a file path."""
+    if not task_keywords:
+        return 1.0
+    path_lower = path.lower()
+    matches = sum(1 for kw in task_keywords if kw.lower() in path_lower)
+    relevance = (0.1 if matches == 0
+                 else min(1.0, 0.3 + 0.7 * (matches / len(task_keywords))))
+    if any(kw in path_lower for kw in excluded_keywords):
+        relevance *= 0.2  # An explicit exclusion is a hint, not a hard filter.
+    return relevance
+
+
+def _estimate_entry_tokens(entry: RankedEntry) -> int:
+    """Estimate tokens for a ranked entry in the output."""
+    # path + symbols list
+    tokens = len(entry.path.split("/")) + 2
+    tokens += sum(len(s.split()) + 1 for s in entry.symbols)
+    return max(tokens, 3)
+
+
+def _categorize_path(path: str) -> str:
+    """Categorize a file path."""
+    parts = path.lower().split("/")
+    if any(p in ("test", "tests", "spec", "specs") for p in parts):
+        return "test"
+    if any(p in ("util", "utils", "helpers", "lib") for p in parts):
+        return "util"
+    if any(p in ("core", "engine", "kernel") for p in parts):
+        return "core"
+    if any(p in ("api", "routes", "handlers", "views") for p in parts):
+        return "api"
+    if any(p in ("config", "settings", "conf") for p in parts):
+        return "config"
+    return "module"
+
+
+def rank_repo_files(
+    adjacency: dict[str, list[str]],
+    *,
+    task_context: str = "",
+    token_budget: int = 1024,
+    symbols_by_file: dict[str, list[str]] | None = None,
+    line_counts: dict[str, int] | None = None,
+    exclude_tests: bool = True,
+    relevance_by_file: dict[str, float] | None = None,
+) -> RepoMapResult:
+    """Rank repository files by graph importance and task relevance.
+
+    Combines PageRank connectivity score with task-context keyword
+    relevance to produce a token-budgeted list of the most important
+    files and their key symbols.
+
+    Args:
+        adjacency: File dependency graph (file -> [imported files]).
+        task_context: Description of the current task for relevance scoring.
+        token_budget: Maximum tokens for the output.
+        symbols_by_file: Optional mapping of file -> symbol names.
+        line_counts: Optional mapping of file -> line count.
+        exclude_tests: Whether to exclude test files from ranking.
+
+    Returns:
+        RepoMapResult with ranked entries within token budget.
+    """
+    symbols_by_file = symbols_by_file or {}
+    line_counts = line_counts or {}
+
+    # Compute PageRank
+    pr_scores = pagerank(adjacency)
+
+    # Query-conditioned source evidence is stronger than path words, but graph
+    # importance still supplies a useful fallback for files outside the pool.
+    task_keywords, excluded_keywords = task_terms(task_context)
+    relevance_by_file = relevance_by_file or {}
+    max_pr = max(pr_scores.values(), default=1.0) or 1.0
+    max_relevance = max(relevance_by_file.values(), default=1.0) or 1.0
+
+    # Score each file
+    scored: list[tuple[str, float]] = []
+    for path, pr_score in pr_scores.items():
+        if exclude_tests and _categorize_path(path) == "test":
+            continue
+        relevance = _task_relevance(path, task_keywords, excluded_keywords)
+        if task_context and relevance_by_file:
+            source_relevance = relevance_by_file.get(path, 0.0) / max_relevance
+            combined = 0.70 * source_relevance + 0.30 * (pr_score / max_pr) * relevance
+        else:
+            combined = pr_score * relevance
+        scored.append((path, combined))
+
+    # Sort by combined score descending
+    scored.sort(key=lambda x: x[1], reverse=True)
+
+    # Build entries within token budget
+    entries: list[RankedEntry] = []
+    tokens_used = 0
+    truncated = False
+
+    for path, score in scored:
+        entry = RankedEntry(
+            path=path,
+            score=score,
+            symbols=symbols_by_file.get(path, [])[:10],  # Cap symbols per file
+            line_count=line_counts.get(path, 0),
+            category=_categorize_path(path),
+        )
+        entry_tokens = _estimate_entry_tokens(entry)
+        if tokens_used + entry_tokens > token_budget:
+            truncated = True
+            break
+        entries.append(entry)
+        tokens_used += entry_tokens
+
+    return RepoMapResult(
+        entries=entries,
+        total_files=len(pr_scores),
+        token_budget=token_budget,
+        tokens_used=tokens_used,
+        truncated=truncated,
+    )
+
+
+def format_repo_map(result: RepoMapResult) -> str:
+    """Format a RepoMapResult as a human-readable string."""
+    if not result.entries:
+        return "No files ranked."
+
+    lines = [f"Repo map ({len(result.entries)}/{result.total_files} files, ~{result.tokens_used} tokens):"]
+    lines.append("")
+
+    for entry in result.entries:
+        score_pct = entry.score * 100
+        prefix = f"  [{entry.category:>6}] {entry.path}"
+        if entry.symbols:
+            syms = ", ".join(entry.symbols[:5])
+            if len(entry.symbols) > 5:
+                syms += f" (+{len(entry.symbols) - 5})"
+            prefix += f"  ({syms})"
+        lines.append(f"{prefix}  [{score_pct:.1f}%]")
+
+    if result.truncated:
+        lines.append(f"\n  ... {result.total_files - len(result.entries)} more files omitted (token budget)")
+
+    return "\n".join(lines)

attocode_intel/request_context.py

@@ -0,0 +1,82 @@
+"""Identity and workspace selection for one intelligence operation."""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from contextvars import ContextVar
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class RequestContext:
+    project_dir: str
+    workspace: str
+    revision: str = "working-tree"
+    source: str = "local"
+    identity: Any = None
+    stores: dict[str, Any] = field(default_factory=dict, compare=False)
+
+    @property
+    def service(self):
+        from attocode_intel.service import CodeIntelService
+
+        if "service" not in self.stores:
+            self.stores["service"] = CodeIntelService(self.project_dir)
+        return self.stores["service"]
+
+
+current_request: ContextVar[RequestContext | None] = ContextVar(
+    "intelligence_request", default=None
+)
+
+
+@contextmanager
+def bind_request(context: RequestContext):
+    token = current_request.set(context)
+    try:
+        yield context
+    finally:
+        current_request.reset(token)
+
+
+def scoped_store(name, factory):
+    context = current_request.get()
+    if context is None:
+        return None
+    if name not in context.stores:
+        context.stores[name] = factory(context.project_dir)
+    return context.stores[name]
+
+
+def resolve_workspace(workspace: str = "", default: str = "") -> str:
+    """Explicit roots win; discovery recognizes .git files in worktrees.
+
+    Discovery never selects the home directory. ``~/.attocode`` holds
+    user-wide settings, and a server that took it as a project marker
+    indexed all of home. Use ``--project ~`` to select home on purpose.
+    """
+    if workspace or default:
+        path = Path(workspace or default).expanduser().resolve()
+        if not path.is_dir():
+            raise ValueError(f"Workspace directory does not exist: {path}")
+        return str(path)
+    cwd = Path.cwd().resolve()
+    home = Path.home().resolve()
+    for path in (cwd, *cwd.parents):
+        if path != home and any(
+            (path / marker).exists()
+            for marker in (
+                ".git",
+                ".attocode",
+                "pyproject.toml",
+                "package.json",
+                "Cargo.toml",
+                "go.mod",
+            )
+        ):
+            return str(path)
+    raise ValueError(
+        "No repository selected. Supply workspace or start with --project /path/to/repo."
+    )

attocode_intel/rules/__init__.py

@@ -0,0 +1,28 @@
+"""Pluggable rule-based analysis engine.
+
+Provides a unified rule model, registry, loader, executor, enricher,
+and formatter for multi-language static analysis with language packs,
+user plugins, and deterministic pre-filtering.
+"""
+
+from attocode_intel.rules.model import (
+    AutoFix,
+    EnrichedFinding,
+    FewShotExample,
+    RuleCategory,
+    RuleSeverity,
+    RuleSource,
+    RuleTier,
+    UnifiedRule,
+)
+
+__all__ = [
+    "AutoFix",
+    "EnrichedFinding",
+    "FewShotExample",
+    "RuleCategory",
+    "RuleSeverity",
+    "RuleSource",
+    "RuleTier",
+    "UnifiedRule",
+]