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

attocode_intel/api/routes/preferences.py

@@ -0,0 +1,100 @@
+"""User preferences endpoints (service mode only)."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from sqlalchemy import 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(prefix="/api/v2/me", tags=["preferences"])
+
+
+class PreferencesResponse(BaseModel):
+    preferences: dict
+
+
+class PreferencesUpdateRequest(BaseModel):
+    preferences: dict
+
+
+# --- Endpoints ---
+
+
+@router.get("/preferences", response_model=PreferencesResponse)
+async def get_preferences(
+    auth: AuthContext = Depends(resolve_auth),
+    session: AsyncSession = Depends(get_db_session),
+) -> PreferencesResponse:
+    """Get current user's preferences."""
+    if not auth.user_id:
+        raise HTTPException(status_code=401, detail="Authentication required")
+
+    from attocode_intel.db.models import UserPreference
+
+    result = await session.execute(
+        select(UserPreference).where(UserPreference.user_id == auth.user_id)
+    )
+    pref = result.scalar_one_or_none()
+    return PreferencesResponse(preferences=pref.preferences if pref else {})
+
+
+@router.put("/preferences", response_model=PreferencesResponse)
+async def replace_preferences(
+    req: PreferencesUpdateRequest,
+    auth: AuthContext = Depends(resolve_auth),
+    session: AsyncSession = Depends(get_db_session),
+) -> PreferencesResponse:
+    """Full replace of user preferences."""
+    if not auth.user_id:
+        raise HTTPException(status_code=401, detail="Authentication required")
+
+    from attocode_intel.db.models import UserPreference
+
+    result = await session.execute(
+        select(UserPreference).where(UserPreference.user_id == auth.user_id)
+    )
+    pref = result.scalar_one_or_none()
+
+    if pref:
+        pref.preferences = req.preferences
+    else:
+        pref = UserPreference(user_id=auth.user_id, preferences=req.preferences)
+        session.add(pref)
+
+    await session.commit()
+    await session.refresh(pref)
+    return PreferencesResponse(preferences=pref.preferences)
+
+
+@router.patch("/preferences", response_model=PreferencesResponse)
+async def merge_preferences(
+    req: PreferencesUpdateRequest,
+    auth: AuthContext = Depends(resolve_auth),
+    session: AsyncSession = Depends(get_db_session),
+) -> PreferencesResponse:
+    """Merge update of user preferences (shallow merge)."""
+    if not auth.user_id:
+        raise HTTPException(status_code=401, detail="Authentication required")
+
+    from attocode_intel.db.models import UserPreference
+
+    result = await session.execute(
+        select(UserPreference).where(UserPreference.user_id == auth.user_id)
+    )
+    pref = result.scalar_one_or_none()
+
+    if pref:
+        merged = {**pref.preferences, **req.preferences}
+        pref.preferences = merged
+    else:
+        pref = UserPreference(user_id=auth.user_id, preferences=req.preferences)
+        session.add(pref)
+
+    await session.commit()
+    await session.refresh(pref)
+    return PreferencesResponse(preferences=pref.preferences)

attocode_intel/api/routes/presence.py

@@ -0,0 +1,42 @@
+"""Presence tracking REST endpoints (service mode only)."""
+
+from __future__ import annotations
+
+import uuid
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+
+from attocode_intel.api.auth import resolve_auth
+from attocode_intel.api.auth.context import AuthContext
+
+router = APIRouter(prefix="/api/v2/repos/{repo_id}", tags=["presence"])
+
+
+class PresenceEntryResponse(BaseModel):
+    user_id: str
+    user_name: str
+    file: str
+    session_id: str
+    timestamp: float
+
+
+@router.get("/presence", response_model=list[PresenceEntryResponse])
+async def get_repo_presence(
+    repo_id: uuid.UUID,
+    auth: AuthContext = Depends(resolve_auth),
+) -> list[PresenceEntryResponse]:
+    """Get current viewers of a repository (REST fallback for non-WebSocket clients)."""
+    from attocode_intel.presence import get_presence
+
+    entries = await get_presence(str(repo_id))
+    return [
+        PresenceEntryResponse(
+            user_id=e.user_id,
+            user_name=e.user_name,
+            file=e.file,
+            session_id=e.session_id,
+            timestamp=e.timestamp,
+        )
+        for e in entries
+    ]

attocode_intel/api/routes/projects.py

@@ -0,0 +1,116 @@
+"""Project management endpoints."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import uuid
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from attocode_intel.api.auth import verify_auth
+from attocode_intel.api.deps import (
+    get_config,
+    get_service_or_404,
+    list_projects,
+    register_project,
+)
+from fastapi import Query as QueryParam
+
+from attocode_intel.api.models import (
+    ProjectInfo,
+    ProjectListResponse,
+    ProjectRegister,
+    TextResult,
+)
+
+router = APIRouter(prefix="/api/v1/projects", tags=["projects"], dependencies=[Depends(verify_auth)])
+
+# Serializes reindex operations so concurrent requests don't corrupt state
+_reindex_lock = asyncio.Lock()
+
+# System directories that should never be registered as projects
+_BLOCKED_PREFIXES = ("/etc", "/var", "/usr", "/sys", "/proc", "/dev")
+
+
+@router.post("", response_model=ProjectInfo)
+async def create_project(req: ProjectRegister) -> ProjectInfo:
+    """Register a project (local path)."""
+    abs_path = os.path.abspath(req.path)
+    if not os.path.isdir(abs_path):
+        raise HTTPException(status_code=400, detail=f"Directory not found: {abs_path}")
+
+    # Block system directories when API key auth is active
+    config = get_config()
+    if config.api_key:
+        for prefix in _BLOCKED_PREFIXES:
+            if abs_path == prefix or abs_path.startswith(prefix + "/"):
+                raise HTTPException(status_code=400, detail=f"Cannot register system directory: {abs_path}")
+
+    # Idempotent: return existing project if same path already registered
+    for pid, svc in list_projects().items():
+        if svc.project_dir == abs_path:
+            return ProjectInfo(
+                id=pid,
+                name=req.name or os.path.basename(abs_path),
+                path=abs_path,
+                status="ready",
+            )
+
+    project_id = str(uuid.uuid4())[:8]
+    name = req.name or os.path.basename(abs_path)
+    register_project(project_id, abs_path, name)
+
+    return ProjectInfo(
+        id=project_id,
+        name=name,
+        path=abs_path,
+        status="ready",
+    )
+
+
+@router.get("", response_model=ProjectListResponse)
+async def get_projects(
+    limit: int = QueryParam(20, ge=1, le=100),
+    offset: int = QueryParam(0, ge=0),
+) -> ProjectListResponse:
+    """List all registered projects."""
+    projects = list_projects()
+    all_items = []
+    for pid, svc in projects.items():
+        all_items.append(ProjectInfo(
+            id=pid,
+            name=os.path.basename(svc.project_dir),
+            path=svc.project_dir,
+            status="ready",
+        ))
+    total = len(all_items)
+    page = all_items[offset:offset + limit]
+    return ProjectListResponse(
+        projects=page, total=total, limit=limit, offset=offset,
+        has_more=(offset + limit < total),
+    )
+
+
+@router.get("/{project_id}", response_model=ProjectInfo)
+async def get_project(project_id: str) -> ProjectInfo:
+    """Get project details."""
+    svc = await get_service_or_404(project_id)
+    return ProjectInfo(
+        id=project_id,
+        name=os.path.basename(svc.project_dir),
+        path=svc.project_dir,
+        status="ready",
+    )
+
+
+@router.post("/{project_id}/reindex", response_model=TextResult)
+async def reindex_project(project_id: str) -> TextResult:
+    """Trigger a full reindex of the project."""
+    svc = await get_service_or_404(project_id)
+    async with _reindex_lock:
+        svc._ast_service = None
+        svc._context_mgr = None
+        svc._get_ast_service()
+        svc._get_context_mgr()
+    return TextResult(result="Reindex complete")

attocode_intel/api/routes/repos.py

@@ -0,0 +1,47 @@
+"""Direct repo lookup endpoint (by repo_id, without org context)."""
+
+from __future__ import annotations
+
+import uuid
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import 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
+from attocode_intel.api.routes.orgs import RepoResponse
+from attocode_intel.db.models import Repository
+
+router = APIRouter(prefix="/api/v1/repos", tags=["repos"])
+
+
+@router.get("/{repo_id}", response_model=RepoResponse)
+async def get_repo_by_id(
+    repo_id: uuid.UUID,
+    auth: AuthContext = Depends(resolve_auth),
+    session: AsyncSession = Depends(get_db_session),
+) -> RepoResponse:
+    """Look up a repository directly by ID (without requiring org context)."""
+    result = await session.execute(
+        select(Repository).where(Repository.id == repo_id)
+    )
+    repo = result.scalar_one_or_none()
+    if repo is None:
+        raise HTTPException(status_code=404, detail="Repository not found")
+
+    # Org isolation: verify the repo belongs to the authenticated user's org
+    if auth.org_id and repo.org_id != auth.org_id:
+        raise HTTPException(status_code=404, detail="Repository not found")
+
+    return RepoResponse(
+        id=str(repo.id),
+        name=repo.name,
+        clone_url=repo.clone_url,
+        default_branch=repo.default_branch,
+        language=repo.language,
+        index_status=repo.index_status,
+        last_indexed_at=repo.last_indexed_at.isoformat() if repo.last_indexed_at else None,
+        created_at=repo.created_at.isoformat(),
+    )

attocode_intel/api/routes/search.py

@@ -0,0 +1,180 @@
+"""Search endpoints — unified v1 (text) + v2 (structured JSON)."""
+
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+
+from attocode_intel.api.auth import verify_auth
+from attocode_intel.api.deps import (
+    BranchParam,
+    ensure_branch_supported,
+    get_search_provider,
+    get_service_or_404,
+)
+from attocode_intel.api.models import (
+    FastSearchRequest,
+    SearchResultsResponse,
+    SecurityScanRequest,
+    SecurityScanResponse,
+    SemanticSearchRequest,
+    TextResult,
+)
+
+logger = logging.getLogger(__name__)
+
+# --- v1 router: text responses ---
+
+router_v1 = APIRouter(
+    prefix="/api/v1/projects/{project_id}",
+    tags=["search"],
+    dependencies=[Depends(verify_auth)],
+)
+
+# --- v2 router: structured JSON ---
+
+router_v2 = APIRouter(
+    prefix="/api/v2/projects/{project_id}",
+    tags=["search-v2"],
+    dependencies=[Depends(verify_auth)],
+)
+
+
+class IndexStatusResponse(BaseModel):
+    provider: str = ""
+    available: bool = False
+    status: str = "idle"
+    total_files: int = 0
+    indexed_files: int = 0
+    failed_files: int = 0
+    coverage: float = 0.0
+    elapsed_seconds: float = 0.0
+    vector_search_active: bool = False
+    health_status: str = "unknown"
+    degraded_reason: str = ""
+    last_error: str = ""
+
+
+# ===================================================================
+# v1 endpoints
+# ===================================================================
+
+
+@router_v1.post("/search", response_model=TextResult)
+async def semantic_search_v1(
+    project_id: str,
+    req: SemanticSearchRequest,
+    branch: BranchParam = "",
+) -> TextResult:
+    """Semantic search (vector + keyword RRF)."""
+    ensure_branch_supported(branch)
+    svc = await get_service_or_404(project_id)
+    return TextResult(result=svc.semantic_search(
+        query=req.query, top_k=req.top_k, file_filter=req.file_filter,
+    ))
+
+
+@router_v1.post("/index", response_model=IndexStatusResponse)
+async def start_indexing(
+    project_id: str,
+    branch: BranchParam = "",
+) -> IndexStatusResponse:
+    """Start background embedding indexing."""
+    ensure_branch_supported(branch)
+    svc = await get_service_or_404(project_id)
+    result = svc.start_indexing()
+    return IndexStatusResponse(**result)
+
+
+@router_v1.get("/index/status", response_model=IndexStatusResponse)
+async def index_status(
+    project_id: str,
+    branch: BranchParam = "",
+) -> IndexStatusResponse:
+    """Get current embedding index status."""
+    ensure_branch_supported(branch)
+    svc = await get_service_or_404(project_id)
+    result = svc.indexing_status()
+    return IndexStatusResponse(**result)
+
+
+@router_v1.get("/semantic-search-status", response_model=TextResult)
+async def semantic_search_status_v1(
+    project_id: str,
+    branch: BranchParam = "",
+) -> TextResult:
+    """Human-readable semantic-search health."""
+    ensure_branch_supported(branch)
+    svc = await get_service_or_404(project_id)
+    return TextResult(result=svc.semantic_search_status())
+
+
+@router_v1.post("/fast-search", response_model=TextResult)
+async def fast_search_v1(
+    project_id: str,
+    req: FastSearchRequest,
+    branch: BranchParam = "",
+) -> TextResult:
+    """Regex search with trigram acceleration when available."""
+    ensure_branch_supported(branch)
+    svc = await get_service_or_404(project_id)
+    return TextResult(result=svc.fast_search(
+        pattern=req.pattern,
+        path=req.path,
+        max_results=req.max_results,
+        case_insensitive=req.case_insensitive,
+        selectivity_threshold=req.selectivity_threshold,
+        explain=req.explain,
+    ))
+
+
+# ===================================================================
+# v2 endpoints
+# ===================================================================
+
+
+@router_v2.post("/search", response_model=SearchResultsResponse)
+async def semantic_search_v2(
+    project_id: str,
+    req: SemanticSearchRequest,
+    branch: BranchParam = "",
+) -> SearchResultsResponse:
+    """Semantic search (structured).
+
+    In service mode with pgvector, embeds the query and runs cosine similarity search.
+    Falls back to the local service's text-based search otherwise.
+    """
+    from fastapi import HTTPException
+
+    try:
+        provider = await get_search_provider(project_id)
+        return await provider.semantic_search(
+            query=req.query, top_k=req.top_k, file_filter=req.file_filter, branch=branch,
+        )
+    except (RuntimeError, ImportError) as exc:
+        logger.warning("Search unavailable for project %s: %s", project_id, exc)
+        raise HTTPException(
+            status_code=503,
+            detail=f"Search is not available: {exc}",
+        ) from exc
+    except HTTPException:
+        raise
+    except Exception as exc:
+        logger.exception("Search failed for project %s", project_id)
+        raise HTTPException(
+            status_code=500,
+            detail=f"Search failed: {exc}",
+        ) from exc
+
+
+@router_v2.post("/security-scan", response_model=SecurityScanResponse)
+async def security_scan_v2(
+    project_id: str,
+    req: SecurityScanRequest,
+    branch: BranchParam = "",
+) -> SecurityScanResponse:
+    """Security analysis (structured)."""
+    provider = await get_search_provider(project_id)
+    return await provider.security_scan(mode=req.mode, path=req.path, branch=branch)