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

attocode_intel/api/routes/graph_viz.py

@@ -0,0 +1,160 @@
+"""Graph visualization endpoint — D3-compatible JSON for force-directed graphs."""
+
+from __future__ import annotations
+
+import logging
+from collections import deque
+
+from fastapi import APIRouter, Depends
+
+from attocode_intel.api.auth import verify_auth
+from attocode_intel.api.deps import get_service_or_404
+
+router = APIRouter(
+    prefix="/api/v2/projects/{project_id}/graph-viz",
+    tags=["graph-viz"],
+    dependencies=[Depends(verify_auth)],
+)
+logger = logging.getLogger(__name__)
+
+
+@router.get("")
+async def get_graph_data(
+    project_id: str,
+    root: str = "",
+    depth: int = 3,
+    max_nodes: int = 100,
+) -> dict:
+    """Return graph data in D3 force-directed compatible format.
+
+    If *root* is provided, performs BFS from that file up to *depth* hops.
+    Otherwise returns the top *max_nodes* files ranked by importance.
+    Community detection data is included when available.
+    """
+    depth = min(max(depth, 1), 6)
+    max_nodes = min(max(max_nodes, 10), 500)
+
+    svc = await get_service_or_404(project_id)
+
+    # Get underlying data structures
+    ast_svc = svc._get_ast_service()
+    ctx = svc._get_context_mgr()
+    idx = ast_svc._index
+    files_list = ctx._files  # list[FileInfo]
+
+    # Build lookup: relative_path -> FileInfo
+    file_info: dict[str, object] = {}
+    for fi in files_list:
+        file_info[fi.relative_path] = fi
+
+    # Determine which files to include
+    selected_files: list[str]
+
+    if root:
+        # BFS from root up to depth hops (both directions)
+        rel_root = ast_svc._to_rel(root)
+        visited: set[str] = set()
+        queue: deque[tuple[str, int]] = deque([(rel_root, 0)])
+        order: list[str] = []
+
+        while queue and len(order) < max_nodes:
+            current, d = queue.popleft()
+            if current in visited:
+                continue
+            visited.add(current)
+            order.append(current)
+            if d < depth:
+                # Expand both directions
+                for neighbor in sorted(ast_svc.get_dependencies(current)):
+                    if neighbor not in visited:
+                        queue.append((neighbor, d + 1))
+                for neighbor in sorted(ast_svc.get_dependents(current)):
+                    if neighbor not in visited:
+                        queue.append((neighbor, d + 1))
+
+        selected_files = order
+    else:
+        # Top files by importance
+        ranked = sorted(files_list, key=lambda f: f.importance, reverse=True)
+        # Only include files that participate in the dependency graph
+        graph_files: set[str] = set()
+        graph_files.update(idx.file_dependencies.keys())
+        graph_files.update(idx.file_dependents.keys())
+        for deps in idx.file_dependencies.values():
+            graph_files.update(deps)
+
+        selected_files = []
+        for fi in ranked:
+            if fi.relative_path in graph_files:
+                selected_files.append(fi.relative_path)
+            if len(selected_files) >= max_nodes:
+                break
+
+        # If we still have room, add remaining important files
+        if len(selected_files) < max_nodes:
+            seen = set(selected_files)
+            for fi in ranked:
+                if fi.relative_path not in seen:
+                    selected_files.append(fi.relative_path)
+                    seen.add(fi.relative_path)
+                if len(selected_files) >= max_nodes:
+                    break
+
+    selected_set = set(selected_files)
+
+    # --- Community detection ---
+    # Build file -> community_id mapping
+    file_to_community: dict[str, int] = {}
+    communities_list: list[dict] = []
+    try:
+        cd = svc.community_detection_data(min_community_size=2, max_communities=30)
+        # Handle both standard communities and directory-based fallback modules
+        community_entries = cd.get("communities", [])
+        if not community_entries and "modules" in cd:
+            community_entries = [
+                {"id": m["id"], "files": m["files"]}
+                for m in cd["modules"]
+            ]
+        for comm in community_entries:
+            cid = comm["id"]
+            comm_files_in_view = [f for f in comm["files"] if f in selected_set]
+            if comm_files_in_view:
+                communities_list.append({
+                    "id": cid,
+                    "files": comm_files_in_view,
+                    "size": len(comm_files_in_view),
+                })
+            for f in comm["files"]:
+                file_to_community[f] = cid
+    except Exception:
+        logger.debug("Community detection unavailable, skipping", exc_info=True)
+
+    # --- Build nodes ---
+    nodes: list[dict] = []
+    for path in selected_files:
+        fi = file_info.get(path)
+        node: dict = {
+            "id": path,
+            "language": fi.language if fi else "",
+            "importance": round(fi.importance, 3) if fi else 0.0,
+            "lines": fi.line_count if fi else 0,
+            "group": file_to_community.get(path, -1),
+        }
+        nodes.append(node)
+
+    # --- Build links ---
+    links: list[dict] = []
+    for src in selected_files:
+        for tgt in idx.file_dependencies.get(src, set()):
+            if tgt in selected_set:
+                links.append({
+                    "source": src,
+                    "target": tgt,
+                    "type": "imports",
+                })
+
+    return {
+        "nodes": nodes,
+        "links": links,
+        "communities": communities_list,
+    }

attocode_intel/api/routes/health.py

@@ -0,0 +1,62 @@
+"""Health check and metrics endpoints."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Query
+from starlette.responses import PlainTextResponse
+
+router = APIRouter(tags=["health"])
+
+
+@router.get("/health")
+async def health() -> dict:
+    """Basic health check."""
+    return {"status": "ok"}
+
+
+@router.get("/ready")
+async def ready() -> dict:
+    """Readiness probe — checks that at least one project or repo is registered."""
+    from attocode_intel.api.deps import get_config, list_projects
+
+    # Check v1 local projects
+    projects = list_projects()
+    if projects:
+        return {"status": "ready", "projects": len(projects)}
+
+    # In service mode, also check DB repos
+    config = get_config()
+    if config.is_service_mode:
+        from sqlalchemy import func, select
+
+        from attocode_intel.db.engine import get_session
+        from attocode_intel.db.models import Repository
+
+        async for session in get_session():
+            result = await session.execute(select(func.count()).select_from(Repository))
+            repo_count = result.scalar() or 0
+            if repo_count > 0:
+                return {"status": "ready", "repos": repo_count}
+
+    return {"status": "not_ready", "reason": "no projects registered"}
+
+
+@router.get("/api/v1/metrics")
+async def metrics(
+    format: str = Query("json", description="Response format: 'json' or 'prometheus'"),
+):
+    """Return aggregated query metrics.
+
+    Supports JSON (default) and Prometheus text exposition format.
+    Unauthenticated — intended for monitoring infrastructure.
+    """
+    from attocode_intel.api.middleware import metrics_collector
+
+    if format == "prometheus":
+        text = metrics_collector.get_metrics(fmt="prometheus")
+        return PlainTextResponse(
+            content=text,
+            media_type="text/plain; version=0.0.4; charset=utf-8",
+        )
+
+    return metrics_collector.get_metrics(fmt="json")

attocode_intel/api/routes/history.py

@@ -0,0 +1,175 @@
+"""History endpoints — code evolution and change-history utilities."""
+
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter, Depends, Query
+from pydantic import BaseModel
+
+from attocode_intel.api.auth import verify_auth
+from attocode_intel.api.deps import BranchParam, ensure_branch_supported, get_service_or_404
+from attocode_intel.api.models import ChangeCouplingRequest, MergeRiskRequest, TextResult
+
+router_v1 = APIRouter(
+    prefix="/api/v1/projects/{project_id}/history",
+    tags=["history"],
+    dependencies=[Depends(verify_auth)],
+)
+
+router_v2 = APIRouter(
+    prefix="/api/v2/projects/{project_id}",
+    tags=["history-v2"],
+    dependencies=[Depends(verify_auth)],
+)
+logger = logging.getLogger(__name__)
+
+
+# --- Response models ---
+
+
+class FileStatEntry(BaseModel):
+    path: str
+    added: int = 0
+    removed: int = 0
+
+
+class EvolutionCommit(BaseModel):
+    sha: str
+    author: str
+    email: str
+    date: str
+    subject: str
+    files: list[FileStatEntry] = []
+
+
+class CodeEvolutionResponse(BaseModel):
+    path: str
+    symbol: str = ""
+    since: str = ""
+    commits: list[EvolutionCommit]
+    total: int
+
+
+class RecentFileEntry(BaseModel):
+    path: str
+    commits: int
+    added: int
+    removed: int
+    last_date: str = ""
+
+
+class RecentChangesResponse(BaseModel):
+    days: int
+    path: str = ""
+    commit_count: int
+    total_files_changed: int
+    files: list[RecentFileEntry]
+
+
+# --- Endpoints ---
+
+
+@router_v1.get("/evolution", response_model=TextResult)
+async def code_evolution_v1(
+    project_id: str,
+    path: str = Query(..., description="File path to trace history for"),
+    symbol: str = Query("", description="Optional symbol name filter"),
+    since: str = Query("", description="Date filter (e.g. '2024-01-01', '3 months ago')"),
+    max_results: int = Query(20, ge=1, le=100),
+    branch: BranchParam = "",
+) -> TextResult:
+    """Get change history for a file or symbol."""
+    ensure_branch_supported(branch)
+    svc = await get_service_or_404(project_id)
+    return TextResult(result=svc.code_evolution(
+        path=path,
+        symbol=symbol,
+        since=since,
+        max_results=max_results,
+    ))
+
+
+@router_v1.get("/recent-changes", response_model=TextResult)
+async def recent_changes_v1(
+    project_id: str,
+    days: int = Query(7, ge=1, le=365),
+    path: str = Query("", description="Optional path prefix filter"),
+    top_n: int = Query(20, ge=1, le=200),
+    branch: BranchParam = "",
+) -> TextResult:
+    """Show recently modified files and change frequency."""
+    ensure_branch_supported(branch)
+    svc = await get_service_or_404(project_id)
+    return TextResult(result=svc.recent_changes(days=days, path=path, top_n=top_n))
+
+
+@router_v1.post("/change-coupling", response_model=TextResult)
+async def change_coupling_v1(
+    project_id: str,
+    req: ChangeCouplingRequest,
+    branch: BranchParam = "",
+) -> TextResult:
+    """Find files that frequently change together."""
+    ensure_branch_supported(branch)
+    svc = await get_service_or_404(project_id)
+    return TextResult(result=svc.change_coupling(
+        file=req.file,
+        days=req.days,
+        min_coupling=req.min_coupling,
+        top_k=req.top_k,
+    ))
+
+
+@router_v1.get("/churn-hotspots", response_model=TextResult)
+async def churn_hotspots_v1(
+    project_id: str,
+    days: int = Query(90, ge=1, le=3650),
+    top_n: int = Query(20, ge=1, le=200),
+    branch: BranchParam = "",
+) -> TextResult:
+    """Rank high-churn files."""
+    ensure_branch_supported(branch)
+    svc = await get_service_or_404(project_id)
+    return TextResult(result=svc.churn_hotspots(days=days, top_n=top_n))
+
+
+@router_v1.post("/merge-risk", response_model=TextResult)
+async def merge_risk_v1(
+    project_id: str,
+    req: MergeRiskRequest,
+    branch: BranchParam = "",
+) -> TextResult:
+    """Predict additional files likely to require changes."""
+    ensure_branch_supported(branch)
+    svc = await get_service_or_404(project_id)
+    return TextResult(result=svc.merge_risk(files=req.files, days=req.days))
+
+
+@router_v2.get("/evolution", response_model=CodeEvolutionResponse)
+async def code_evolution(
+    project_id: str,
+    path: str = Query(..., description="File path to trace history for"),
+    symbol: str = Query("", description="Optional symbol name filter"),
+    since: str = Query("", description="Date filter (e.g. '2024-01-01', '3 months ago')"),
+    max_results: int = Query(20, ge=1, le=100),
+) -> CodeEvolutionResponse:
+    """Get change history for a file or symbol."""
+    svc = await get_service_or_404(project_id)
+    data = svc.code_evolution_data(
+        path=path, symbol=symbol, since=since, max_results=max_results,
+    )
+    return CodeEvolutionResponse(**data)
+
+
+@router_v2.get("/recent-changes", response_model=RecentChangesResponse)
+async def recent_changes(
+    project_id: str,
+    days: int = Query(7, ge=1, le=365),
+    path: str = Query("", description="Optional path prefix filter"),
+    top_n: int = Query(20, ge=1, le=200),
+) -> RecentChangesResponse:
+    """Show recently modified files and change frequency."""
+    svc = await get_service_or_404(project_id)
+    data = svc.recent_changes_data(days=days, path=path, top_n=top_n)
+    return RecentChangesResponse(**data)

attocode_intel/api/routes/jobs.py

@@ -0,0 +1,84 @@
+"""Job status API endpoints (service mode only)."""
+
+from __future__ import annotations
+
+import uuid
+
+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
+from attocode_intel.db.models import IndexingJob
+
+router = APIRouter(prefix="/api/v1/jobs", tags=["jobs"])
+
+
+class JobResponse(BaseModel):
+    id: str
+    repo_id: str
+    job_type: str
+    status: str
+    branch_name: str | None = None
+    progress: dict = {}
+    error: str | None = None
+    started_at: str | None = None
+    completed_at: str | None = None
+    created_at: str
+
+
+class JobListResponse(BaseModel):
+    jobs: list[JobResponse]
+
+
+def _job_to_response(job: IndexingJob) -> JobResponse:
+    return JobResponse(
+        id=str(job.id),
+        repo_id=str(job.repo_id),
+        job_type=job.job_type,
+        status=job.status,
+        branch_name=job.branch_name,
+        progress=job.progress or {},
+        error=job.error,
+        started_at=job.started_at.isoformat() if job.started_at else None,
+        completed_at=job.completed_at.isoformat() if job.completed_at else None,
+        created_at=job.created_at.isoformat(),
+    )
+
+
+@router.get("/{job_id}", response_model=JobResponse)
+async def get_job(
+    job_id: uuid.UUID,
+    auth: AuthContext = Depends(resolve_auth),
+    session: AsyncSession = Depends(get_db_session),
+) -> JobResponse:
+    """Get job status by ID."""
+    result = await session.execute(
+        select(IndexingJob).where(IndexingJob.id == job_id)
+    )
+    job = result.scalar_one_or_none()
+    if job is None:
+        raise HTTPException(status_code=404, detail="Job not found")
+    return _job_to_response(job)
+
+
+@router.get("/repo/{repo_id}", response_model=JobListResponse)
+async def list_repo_jobs(
+    repo_id: uuid.UUID,
+    status: str = "",
+    limit: int = 20,
+    auth: AuthContext = Depends(resolve_auth),
+    session: AsyncSession = Depends(get_db_session),
+) -> JobListResponse:
+    """List jobs for a repository."""
+    query = select(IndexingJob).where(IndexingJob.repo_id == repo_id)
+    if status:
+        query = query.where(IndexingJob.status == status)
+    query = query.order_by(IndexingJob.created_at.desc()).limit(limit)
+
+    result = await session.execute(query)
+    jobs = [_job_to_response(j) for j in result.scalars()]
+    return JobListResponse(jobs=jobs)

attocode_intel/api/routes/learning.py

@@ -0,0 +1,205 @@
+"""Learning/memory endpoints."""
+
+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 (
+    LearningFeedbackRequest,
+    LearningItem,
+    LearningListResponse,
+    LearningRecallItem,
+    LearningRecallResponse,
+    RecordLearningRequest,
+    TextResult,
+)
+
+router = APIRouter(
+    prefix="/api/v1",
+    tags=["learning"],
+    dependencies=[Depends(verify_auth)],
+)
+
+router_v2 = APIRouter(
+    prefix="/api/v2",
+    tags=["learning-v2"],
+    dependencies=[Depends(verify_auth)],
+)
+
+
+@router.post("/projects/{project_id}/learnings", response_model=TextResult)
+async def record_learning(
+    request: Request, project_id: str, req: RecordLearningRequest
+) -> TextResult:
+    """Record a new learning."""
+    shared = await shared_operation(request, project_id, "record_learning", req.model_dump())
+    if shared is not None:
+        return TextResult(result=shared["result"])
+    svc = await get_service_or_404(project_id)
+    return TextResult(
+        result=svc.record_learning(
+            type=req.type,
+            description=req.description,
+            details=req.details,
+            scope=req.scope,
+            confidence=req.confidence,
+        )
+    )
+
+
+@router.get("/projects/{project_id}/learnings/recall", response_model=TextResult)
+async def recall(
+    request: Request,
+    project_id: str,
+    query: str = Query(...),
+    branch: BranchParam = "",
+    scope: str = "",
+    max_results: int = 10,
+) -> TextResult:
+    """Recall relevant learnings."""
+    shared = await shared_operation(
+        request, project_id, "recall", {"query": query, "scope": scope, "max_results": max_results}
+    )
+    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.recall(query=query, scope=scope, max_results=max_results))
+
+
+@router.post("/projects/{project_id}/learnings/{learning_id}/feedback", response_model=TextResult)
+async def learning_feedback(
+    request: Request, project_id: str, learning_id: int, req: LearningFeedbackRequest
+) -> TextResult:
+    """Mark a learning as helpful/unhelpful."""
+    shared = await shared_operation(
+        request,
+        project_id,
+        "learning_feedback",
+        {"learning_id": learning_id, "helpful": req.helpful},
+    )
+    if shared is not None:
+        return TextResult(result=shared["result"])
+    svc = await get_service_or_404(project_id)
+    return TextResult(result=svc.learning_feedback(learning_id=learning_id, helpful=req.helpful))
+
+
+@router.get("/projects/{project_id}/learnings", response_model=TextResult)
+async def list_learnings(
+    request: Request,
+    project_id: str,
+    branch: BranchParam = "",
+    status: str = "active",
+    type: str = "",  # noqa: A002
+    scope: str = "",
+) -> TextResult:
+    """List all learnings."""
+    shared = await shared_operation(
+        request, project_id, "list_learnings", {"status": status, "type": type, "scope": scope}
+    )
+    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_learnings(status=status, type=type, scope=scope))
+
+
+# ------------------------------------------------------------------
+# v2 structured endpoints
+# ------------------------------------------------------------------
+
+
+def _store_records_to_items(records: list[dict]) -> list[LearningItem]:
+    """Convert raw store records to LearningItem models."""
+    return [
+        LearningItem(
+            id=r["id"],
+            type=r["type"],
+            description=r["description"],
+            details=r.get("details", ""),
+            scope=r.get("scope", ""),
+            confidence=r.get("confidence", 0.7),
+            status=r.get("status", "active"),
+            helpful_count=r.get("helpful_count", 0),
+            unhelpful_count=r.get("unhelpful_count", 0),
+        )
+        for r in records
+    ]
+
+
+def _store_records_to_recall_items(records: list[dict]) -> list[LearningRecallItem]:
+    """Convert raw store recall records to LearningRecallItem models."""
+    return [
+        LearningRecallItem(
+            id=r["id"],
+            type=r["type"],
+            description=r["description"],
+            scope=r.get("scope", ""),
+            confidence=r.get("confidence", 0.7),
+            relevance_score=r.get("relevance_score", 0.0),
+        )
+        for r in records
+    ]
+
+
+@router_v2.get("/projects/{project_id}/learnings", response_model=LearningListResponse)
+async def list_learnings_v2(
+    request: Request,
+    project_id: str,
+    status: str = "active",
+    type: str = "",  # noqa: A002
+    scope: str = "",
+) -> LearningListResponse:
+    """List all learnings (structured)."""
+    shared = await shared_operation(
+        request, project_id, "list_learnings", {"status": status, "type": type, "scope": scope}
+    )
+    if shared is not None:
+        return LearningListResponse(
+            learnings=_store_records_to_items(shared["data"]), total=len(shared["data"])
+        )
+    from fastapi import HTTPException
+
+    try:
+        svc = await get_service_or_404(project_id)
+        store = svc._get_memory_store()
+        records = store.list_all(status=status, type=type or None)
+        if scope:
+            records = [r for r in records if r["scope"].startswith(scope) or r["scope"] == ""]
+        items = _store_records_to_items(records)
+        return LearningListResponse(learnings=items, total=len(items))
+    except HTTPException:
+        return LearningListResponse(learnings=[], total=0)
+
+
+@router_v2.get("/projects/{project_id}/learnings/recall", response_model=LearningRecallResponse)
+async def recall_v2(
+    request: Request,
+    project_id: str,
+    query: str = Query(...),
+    scope: str = "",
+    max_results: int = 10,
+) -> LearningRecallResponse:
+    """Recall relevant learnings (structured)."""
+    shared = await shared_operation(
+        request, project_id, "recall", {"query": query, "scope": scope, "max_results": max_results}
+    )
+    if shared is not None:
+        return LearningRecallResponse(
+            query=query,
+            results=_store_records_to_recall_items(shared["data"]),
+            total=len(shared["data"]),
+        )
+    from fastapi import HTTPException
+
+    try:
+        svc = await get_service_or_404(project_id)
+        store = svc._get_memory_store()
+        records = store.recall(query=query, scope=scope, max_results=max_results)
+        items = _store_records_to_recall_items(records)
+        return LearningRecallResponse(query=query, results=items, total=len(items))
+    except HTTPException:
+        return LearningRecallResponse(query=query, results=[], total=0)