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

attocode_intel/api/repository_source.py

@@ -0,0 +1,21 @@
+"""Validate remotely supplied repository locations before storing them."""
+from __future__ import annotations
+
+import re
+from urllib.parse import urlsplit
+
+from fastapi import HTTPException
+
+
+def validate_remote_source(clone_url=None, local_path=None):
+    from attocode_intel.api.deps import get_config
+
+    if not get_config().is_service_mode:
+        return
+    if local_path:
+        raise HTTPException(422, "Remote clients cannot select server filesystem paths. Connect a Git URL or use local MCP.")
+    if clone_url:
+        parsed = urlsplit(clone_url)
+        scp_url = re.fullmatch(r"[\w.-]+@[\w.-]+:[^\s]+", clone_url)
+        if not scp_url and not (parsed.scheme in {"https", "http", "ssh"} and parsed.hostname):
+            raise HTTPException(422, "Repository URL must use HTTP(S) or SSH; local paths and file URLs are not accepted.")

attocode_intel/api/routes/__init__.py

@@ -0,0 +1 @@
+"""API route modules."""

attocode_intel/api/routes/_pin_helper.py

@@ -0,0 +1,158 @@
+"""Server-side retrieval pin computation.
+
+HTTP search routes return ``pin_id`` + ``manifest_hash`` so clients can
+track the state they queried against (matching the local stdio MCP
+``_stamp_pin``). Per-store manifest hashes are computed via cheap
+``SELECT COUNT + MAX(updated_at)`` probes; pins are ephemeral and not
+persisted in a pins table.
+"""
+
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import TYPE_CHECKING
+
+from attocode_intel.artifacts import RetrievalPin, compute_store_hash
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+logger = logging.getLogger(__name__)
+
+
+async def compute_server_manifest_hashes(
+    session: AsyncSession,
+    *,
+    repo_id: uuid.UUID | None = None,
+    branch_id: uuid.UUID | None = None,
+) -> dict[str, str]:
+    """Compute cheap per-store content hashes for the server-side stores.
+
+    Returns a ``{store_name: sha256hex}`` dict that matches the shape
+    of :func:`attocode_intel.tools.pin_tools._compute_current_manifest_hashes`
+    (the local-side equivalent). A store's hash changes whenever its
+    row count or latest ``created_at`` / ``updated_at`` timestamp moves.
+
+    ``repo_id`` / ``branch_id`` may scope the hash; the current
+    implementation uses a global view — the returned hash is
+    informational, not a cryptographic commitment to the repo's exact
+    state.
+    """
+    from sqlalchemy import text
+
+    results: dict[str, str] = {}
+
+    # Each store is probed via a single cheap aggregate query. Failures
+    # on any individual store fall through to ``absent`` so a missing
+    # table (e.g. on an older schema) doesn't break the whole response.
+    async def _probe(name: str, sql: str, params: dict) -> None:
+        try:
+            row = (await session.execute(text(sql), params)).fetchone()
+        except Exception as exc:
+            logger.debug("server pin: %s probe failed: %s", name, exc)
+            results[name] = "absent"
+            return
+        if row is None:
+            results[name] = "absent"
+            return
+        row_count = int(row[0] or 0)
+        # Postgres MAX() on timestamptz returns a datetime; coerce to
+        # float epoch for the hash so it matches the local format.
+        ts = row[1]
+        max_updated_at: float | None = None
+        if ts is not None:
+            try:
+                max_updated_at = ts.timestamp()
+            except AttributeError:
+                max_updated_at = float(ts)
+        results[name] = compute_store_hash(
+            schema_version="1",
+            row_count=row_count,
+            max_updated_at=max_updated_at,
+        )
+
+    repo_clause = "" if repo_id is None else " (scoped)"
+    branch_params: dict = {}
+    if branch_id is not None:
+        branch_params["branch_id"] = str(branch_id)
+
+    # file_contents — global; repo scoping would require a join via
+    # branch_files which is overkill here.
+    await _probe(
+        "file_contents",
+        "SELECT COUNT(*), MAX(created_at) FROM file_contents",
+        {},
+    )
+    await _probe(
+        "symbols",
+        "SELECT COUNT(*), MAX(created_at) FROM symbols",
+        {},
+    )
+    await _probe(
+        "embeddings",
+        "SELECT COUNT(*), MAX(created_at) FROM embeddings",
+        {},
+    )
+    await _probe(
+        "dependencies",
+        "SELECT COUNT(*), NULL::timestamptz FROM dependencies",
+        {},
+    )
+    # branch_files scoped per branch if we have one, else global row count.
+    if branch_id is not None:
+        await _probe(
+            "branch_files",
+            "SELECT COUNT(*), NULL::timestamptz FROM branch_files "
+            "WHERE branch_id = CAST(:branch_id AS uuid)",
+            branch_params,
+        )
+    else:
+        await _probe(
+            "branch_files",
+            "SELECT COUNT(*), NULL::timestamptz FROM branch_files",
+            {},
+        )
+
+    logger.debug(
+        "server pin%s: computed %d store hashes",
+        repo_clause, len(results),
+    )
+    return results
+
+
+async def build_retrieval_pin(
+    session: AsyncSession,
+    *,
+    repo_id: uuid.UUID | None = None,
+    branch_id: uuid.UUID | None = None,
+) -> RetrievalPin:
+    """Build a fresh :class:`RetrievalPin` for the current server state.
+
+    Server pins are ephemeral (not persisted in a pins table). The
+    ``pin_id`` is deterministic off the manifest hash so repeat calls
+    on an unchanged state return an identical id, letting clients
+    cheap-compare across requests.
+    """
+    hashes = await compute_server_manifest_hashes(
+        session, repo_id=repo_id, branch_id=branch_id,
+    )
+    pin = RetrievalPin.create(
+        manifest_hashes=hashes,
+        branch_id=str(branch_id) if branch_id else None,
+        ttl_seconds=0,
+    )
+    # Deterministic id — matches the local ``_stamp_pin`` format
+    # (``pin_<hex20>``) so clients don't need to distinguish server
+    # vs. local pins by format.
+    deterministic_id = f"pin_{pin.manifest_hash[:20]}"
+    return RetrievalPin(
+        pin_id=deterministic_id,
+        schema_version=pin.schema_version,
+        manifest_hashes=pin.manifest_hashes,
+        manifest_hash=pin.manifest_hash,
+        overlay_id=pin.overlay_id,
+        branch_id=pin.branch_id,
+        created_at=pin.created_at,
+        expires_at=pin.expires_at,
+    )

attocode_intel/api/routes/activity.py

@@ -0,0 +1,148 @@
+"""Activity feed / audit log endpoints (service mode only)."""
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from attocode_intel.api.auth import resolve_auth
+from attocode_intel.api.auth.context import AuthContext
+from attocode_intel.api.deps import get_db_session
+
+router = APIRouter(tags=["activity"])
+
+
+# --- Response models ---
+
+
+class ActivityEventResponse(BaseModel):
+    id: str
+    event_type: str
+    org_id: str
+    repo_id: str | None = None
+    user_id: str | None = None
+    detail: dict = {}
+    created_at: str
+
+
+class ActivityFeedResponse(BaseModel):
+    events: list[ActivityEventResponse]
+    total: int
+    limit: int
+    offset: int
+    has_more: bool
+
+
+# --- Endpoints ---
+
+
+@router.get("/api/v2/orgs/{org_id}/activity", response_model=ActivityFeedResponse)
+async def get_org_activity(
+    org_id: uuid.UUID,
+    limit: int = Query(50, ge=1, le=100),
+    offset: int = Query(0, ge=0),
+    event_type: str = Query("", description="Filter by event type"),
+    since: str = Query("", description="ISO datetime to filter events after"),
+    auth: AuthContext = Depends(resolve_auth),
+    session: AsyncSession = Depends(get_db_session),
+) -> ActivityFeedResponse:
+    """Get organization activity feed (paginated)."""
+    from attocode_intel.db.models import AuditEvent
+
+    # Build query
+    query = select(AuditEvent).where(AuditEvent.org_id == org_id)
+
+    if event_type:
+        query = query.where(AuditEvent.event_type == event_type)
+    if since:
+        try:
+            since_dt = datetime.fromisoformat(since)
+            query = query.where(AuditEvent.created_at >= since_dt)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid 'since' datetime format")
+
+    # Count total
+    count_result = await session.execute(
+        select(func.count()).select_from(query.subquery())
+    )
+    total = count_result.scalar() or 0
+
+    # Fetch page
+    result = await session.execute(
+        query.order_by(AuditEvent.created_at.desc())
+        .offset(offset).limit(limit)
+    )
+
+    events = []
+    for event in result.scalars():
+        events.append(ActivityEventResponse(
+            id=str(event.id),
+            event_type=event.event_type,
+            org_id=str(event.org_id),
+            repo_id=str(event.repo_id) if event.repo_id else None,
+            user_id=str(event.user_id) if event.user_id else None,
+            detail=event.detail or {},
+            created_at=event.created_at.isoformat(),
+        ))
+
+    return ActivityFeedResponse(
+        events=events, total=total, limit=limit, offset=offset,
+        has_more=(offset + limit < total),
+    )
+
+
+@router.get("/api/v2/repos/{repo_id}/activity", response_model=ActivityFeedResponse)
+async def get_repo_activity(
+    repo_id: uuid.UUID,
+    limit: int = Query(50, ge=1, le=100),
+    offset: int = Query(0, ge=0),
+    event_type: str = Query("", description="Filter by event type"),
+    since: str = Query("", description="ISO datetime to filter events after"),
+    auth: AuthContext = Depends(resolve_auth),
+    session: AsyncSession = Depends(get_db_session),
+) -> ActivityFeedResponse:
+    """Get repository activity feed (paginated)."""
+    from attocode_intel.db.models import AuditEvent
+
+    query = select(AuditEvent).where(AuditEvent.repo_id == repo_id)
+
+    if event_type:
+        query = query.where(AuditEvent.event_type == event_type)
+    if since:
+        try:
+            since_dt = datetime.fromisoformat(since)
+            query = query.where(AuditEvent.created_at >= since_dt)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid 'since' datetime format")
+
+    count_result = await session.execute(
+        select(func.count()).select_from(query.subquery())
+    )
+    total = count_result.scalar() or 0
+
+    result = await session.execute(
+        query.order_by(AuditEvent.created_at.desc())
+        .offset(offset).limit(limit)
+    )
+
+    events = []
+    for event in result.scalars():
+        events.append(ActivityEventResponse(
+            id=str(event.id),
+            event_type=event.event_type,
+            org_id=str(event.org_id),
+            repo_id=str(event.repo_id) if event.repo_id else None,
+            user_id=str(event.user_id) if event.user_id else None,
+            detail=event.detail or {},
+            created_at=event.created_at.isoformat(),
+        ))
+
+    return ActivityFeedResponse(
+        events=events, total=total, limit=limit, offset=offset,
+        has_more=(offset + limit < total),
+    )

attocode_intel/api/routes/adr.py

@@ -0,0 +1,102 @@
+"""ADR endpoints — text-oriented parity for MCP architecture-decision tools."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, Query, Request
+
+from attocode_intel.api.auth import verify_auth
+from attocode_intel.api.knowledge_bridge import shared_operation
+from attocode_intel.api.deps import BranchParam, ensure_branch_supported, get_service_or_404
+from attocode_intel.api.models import RecordADRRequest, TextResult, UpdateADRStatusRequest
+
+router_v1 = APIRouter(
+    prefix="/api/v1/projects/{project_id}/adrs",
+    tags=["adrs"],
+    dependencies=[Depends(verify_auth)],
+)
+
+
+@router_v1.post("", response_model=TextResult)
+async def record_adr_v1(
+    request: Request,
+    project_id: str,
+    req: RecordADRRequest,
+    branch: BranchParam = "",
+) -> TextResult:
+    """Record a new architecture decision."""
+    shared = await shared_operation(request, project_id, "record_adr", req.model_dump())
+    if shared is not None:
+        return TextResult(result=shared["result"])
+    ensure_branch_supported(branch)
+    svc = await get_service_or_404(project_id)
+    return TextResult(
+        result=svc.record_adr(
+            title=req.title,
+            context=req.context,
+            decision=req.decision,
+            consequences=req.consequences,
+            related_files=req.related_files,
+            tags=req.tags,
+        )
+    )
+
+
+@router_v1.get("", response_model=TextResult)
+async def list_adrs_v1(
+    request: Request,
+    project_id: str,
+    branch: BranchParam = "",
+    status: str = "",
+    tag: str = "",
+    search: str = Query("", description="Search title, context, and decision"),
+) -> TextResult:
+    """List ADRs with optional filtering."""
+    shared = await shared_operation(
+        request, project_id, "list_adrs", {"status": status, "tag": tag, "search": search}
+    )
+    if shared is not None:
+        return TextResult(result=shared["result"])
+    ensure_branch_supported(branch)
+    svc = await get_service_or_404(project_id)
+    return TextResult(result=svc.list_adrs(status=status, tag=tag, search=search))
+
+
+@router_v1.get("/{number}", response_model=TextResult)
+async def get_adr_v1(
+    request: Request,
+    project_id: str,
+    number: int,
+    branch: BranchParam = "",
+) -> TextResult:
+    """Fetch a single ADR."""
+    shared = await shared_operation(request, project_id, "get_adr", {"number": number})
+    if shared is not None:
+        return TextResult(result=shared["result"])
+    ensure_branch_supported(branch)
+    svc = await get_service_or_404(project_id)
+    return TextResult(result=svc.get_adr(number))
+
+
+@router_v1.post("/{number}/status", response_model=TextResult)
+async def update_adr_status_v1(
+    request: Request,
+    project_id: str,
+    number: int,
+    req: UpdateADRStatusRequest,
+    branch: BranchParam = "",
+) -> TextResult:
+    """Update ADR lifecycle state."""
+    shared = await shared_operation(
+        request, project_id, "update_adr_status", {"number": number, **req.model_dump()}
+    )
+    if shared is not None:
+        return TextResult(result=shared["result"])
+    ensure_branch_supported(branch)
+    svc = await get_service_or_404(project_id)
+    return TextResult(
+        result=svc.update_adr_status(
+            number=number,
+            status=req.status,
+            superseded_by=req.superseded_by,
+        )
+    )