repotoire 0.1.2__tar.gz → 0.1.3__tar.gz

{repotoire-0.1.2 → repotoire-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repotoire
-Version: 0.1.2
+Version: 0.1.3
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -9,7 +9,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Quality Assurance
-Requires-Dist: neo4j>=5.14.0
+Requires-Dist: falkordb>=1.0.0
 Requires-Dist: openai>=1.0.0
 Requires-Dist: spacy>=3.7.0
 Requires-Dist: click>=8.1.0
@@ -49,6 +49,12 @@ Requires-Dist: uv-secure>=0.15.0
 Requires-Dist: datasets>=2.14.0
 Requires-Dist: sentence-transformers>=2.2.0
 Requires-Dist: accelerate>=0.26.0
+Requires-Dist: mypy>=1.7.0
+Requires-Dist: pylint>=3.0.0
+Requires-Dist: bandit>=1.7.0
+Requires-Dist: radon>=6.0.0
+Requires-Dist: vulture>=2.0.0
+Requires-Dist: semgrep>=1.0.0
 Requires-Dist: pytest>=7.4.0 ; extra == 'dev'
 Requires-Dist: pytest-cov>=4.1.0 ; extra == 'dev'
 Requires-Dist: pytest-xdist>=3.5.0 ; extra == 'dev'
@@ -81,12 +87,6 @@ Requires-Dist: opentelemetry-api>=1.20.0 ; extra == 'observability'
 Requires-Dist: opentelemetry-sdk>=1.20.0 ; extra == 'observability'
 Requires-Dist: opentelemetry-exporter-otlp>=1.20.0 ; extra == 'observability'
 Requires-Dist: sentry-sdk[fastapi,celery,sqlalchemy]>=2.0.0 ; extra == 'observability'
-Requires-Dist: mypy>=1.7.0 ; extra == 'detectors'
-Requires-Dist: pylint>=3.0.0 ; extra == 'detectors'
-Requires-Dist: bandit>=1.7.0 ; extra == 'detectors'
-Requires-Dist: radon>=6.0.0 ; extra == 'detectors'
-Requires-Dist: vulture>=2.0.0 ; extra == 'detectors'
-Requires-Dist: semgrep>=1.0.0 ; extra == 'detectors'
 Requires-Dist: questionary>=2.0.0 ; extra == 'ml'
 Requires-Dist: scikit-learn>=1.3.0 ; extra == 'ml'
 Requires-Dist: joblib>=1.3.0 ; extra == 'ml'
@@ -105,7 +105,6 @@ Provides-Extra: graphiti
 Provides-Extra: security
 Provides-Extra: local-embeddings
 Provides-Extra: observability
-Provides-Extra: detectors
 Provides-Extra: ml
 Provides-Extra: sandbox
 Provides-Extra: voyage

{repotoire-0.1.2 → repotoire-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "repotoire"
-version = "0.1.2"
+version = "0.1.3"
 description = "Graph-Powered Code Health Platform"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -25,7 +25,7 @@ classifiers = [
 ]
 
 dependencies = [
-    "neo4j>=5.14.0",
+    "falkordb>=1.0.0",  # Cloud graph database client
     "openai>=1.0.0",
     "spacy>=3.7.0",
     "click>=8.1.0",
@@ -68,6 +68,13 @@ dependencies = [
     "datasets>=2.14.0",  # Required for sentence-transformers fine-tuning
     "sentence-transformers>=2.2.0",  # Local embedding models + contrastive learning
     "accelerate>=0.26.0",  # Required for PyTorch Trainer
+    # Hybrid detector dependencies (core feature)
+    "mypy>=1.7.0",  # Type checking detector
+    "pylint>=3.0.0",  # Advanced linting detector
+    "bandit>=1.7.0",  # Security vulnerability detector
+    "radon>=6.0.0",  # Complexity metrics detector
+    "vulture>=2.0.0",  # Dead code detector
+    "semgrep>=1.0.0",  # Advanced security pattern detector
 ]
 
 [project.optional-dependencies]
@@ -131,15 +138,6 @@ observability = [
     "sentry-sdk[fastapi,celery,sqlalchemy]>=2.0.0",  # Error tracking and performance monitoring (REPO-271)
 ]
 
-detectors = [
-    "mypy>=1.7.0",  # Type checking detector
-    "pylint>=3.0.0",  # Advanced linting detector
-    "bandit>=1.7.0",  # Security vulnerability detector
-    "radon>=6.0.0",  # Complexity metrics detector
-    "vulture>=2.0.0",  # Dead code detector
-    "semgrep>=1.0.0",  # Advanced security pattern detector
-]
-
 ml = [
     "questionary>=2.0.0",  # Interactive CLI prompts for active learning
     "scikit-learn>=1.3.0",  # ML models for bug prediction and uncertainty sampling

{repotoire-0.1.2 → repotoire-0.1.3}/repotoire/api/v1/__init__.py

@@ -19,6 +19,7 @@ from repotoire.api.v1.routes import (
     findings,
     fixes,
     github,
+    graph,
     historical,
     marketplace,
     notifications,
@@ -223,6 +224,7 @@ v1_app.include_router(customer_webhooks.router)
 v1_app.include_router(findings.router)
 v1_app.include_router(fixes.router)
 v1_app.include_router(github.router)
+v1_app.include_router(graph.router)
 v1_app.include_router(historical.router)
 v1_app.include_router(marketplace.router)
 v1_app.include_router(notifications.router)

repotoire-0.1.3/repotoire/api/v1/routes/graph.py

@@ -0,0 +1,476 @@
+"""Graph proxy API routes for CLI operations.
+
+This module provides API endpoints that proxy graph database operations
+to the internal FalkorDB instance. This allows the CLI to perform graph
+operations without direct database access.
+
+All operations are authenticated via API key and scoped to the user's
+organization graph.
+"""
+
+import asyncio
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, Header, HTTPException, status
+from pydantic import BaseModel, Field
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from repotoire.api.shared.auth.clerk import get_clerk_client
+from repotoire.db.models import Organization, OrganizationMembership, User
+from repotoire.db.session import get_db
+from repotoire.graph.tenant_factory import get_factory
+from repotoire.logging_config import get_logger
+from repotoire.models import (
+    Entity,
+    FileEntity,
+    ClassEntity,
+    FunctionEntity,
+    ModuleEntity,
+    NodeType,
+    Relationship,
+    RelationshipType,
+)
+
+logger = get_logger(__name__)
+
+router = APIRouter(prefix="/graph", tags=["graph"])
+
+
+# =============================================================================
+# API Key Authentication
+# =============================================================================
+
+
+@dataclass
+class APIKeyUser:
+    """Authenticated user from API key."""
+
+    org_id: str  # Our internal org UUID
+    org_slug: str
+    user_id: Optional[str] = None
+
+
+async def get_current_api_key_user(
+    db: AsyncSession = Depends(get_db),
+    authorization: Optional[str] = Header(None, alias="Authorization"),
+) -> APIKeyUser:
+    """Validate API key and return authenticated user with org info."""
+    if not authorization:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Missing Authorization header",
+        )
+
+    parts = authorization.split(" ", 1)
+    if len(parts) != 2 or parts[0].lower() != "bearer":
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid Authorization format. Use: Bearer <api_key>",
+        )
+
+    api_key = parts[1]
+
+    try:
+        clerk = get_clerk_client()
+        api_key_data = await asyncio.to_thread(
+            clerk.api_keys.verify_api_key, secret=api_key
+        )
+
+        subject = api_key_data.subject
+        clerk_org_id = None
+        org = None
+
+        if subject.startswith("org_"):
+            clerk_org_id = subject
+        elif hasattr(api_key_data, "org_id") and api_key_data.org_id:
+            clerk_org_id = api_key_data.org_id
+        elif subject.startswith("user_"):
+            # User-scoped key - look up user's organization
+            result = await db.execute(
+                select(User).where(User.clerk_user_id == subject)
+            )
+            db_user = result.scalar_one_or_none()
+            if not db_user:
+                raise HTTPException(
+                    status_code=status.HTTP_401_UNAUTHORIZED,
+                    detail="User not found",
+                )
+
+            result = await db.execute(
+                select(OrganizationMembership).where(
+                    OrganizationMembership.user_id == db_user.id
+                )
+            )
+            membership = result.scalar_one_or_none()
+            if membership:
+                result = await db.execute(
+                    select(Organization).where(
+                        Organization.id == membership.organization_id
+                    )
+                )
+                org = result.scalar_one_or_none()
+                if org:
+                    clerk_org_id = org.clerk_org_id
+
+        # Look up org by Clerk ID
+        if not org and clerk_org_id:
+            result = await db.execute(
+                select(Organization).where(Organization.clerk_org_id == clerk_org_id)
+            )
+            org = result.scalar_one_or_none()
+
+        if not org:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Organization not found",
+            )
+
+        return APIKeyUser(
+            org_id=str(org.id),
+            org_slug=org.slug,
+            user_id=subject if subject.startswith("user_") else None,
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"API key validation failed: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or expired API key",
+        )
+
+
+# =============================================================================
+# Request/Response Models
+# =============================================================================
+
+
+class QueryRequest(BaseModel):
+    """Request to execute a Cypher query."""
+
+    query: str = Field(..., description="Cypher query to execute")
+    parameters: Optional[Dict[str, Any]] = Field(
+        default=None, description="Query parameters"
+    )
+    timeout: Optional[float] = Field(
+        default=None, description="Query timeout in seconds"
+    )
+
+
+class QueryResponse(BaseModel):
+    """Response from a Cypher query."""
+
+    results: List[Dict[str, Any]] = Field(..., description="Query results")
+    count: int = Field(..., description="Number of results")
+
+
+class StatsResponse(BaseModel):
+    """Graph statistics response."""
+
+    stats: Dict[str, int] = Field(..., description="Node/relationship counts")
+
+
+class BatchNodesRequest(BaseModel):
+    """Request to batch create nodes."""
+
+    entities: List[Dict[str, Any]] = Field(..., description="Entities to create")
+
+
+class BatchNodesResponse(BaseModel):
+    """Response from batch node creation."""
+
+    created: Dict[str, str] = Field(
+        ..., description="Map of qualified_name to node ID"
+    )
+    count: int = Field(..., description="Number of nodes created")
+
+
+class BatchRelationshipsRequest(BaseModel):
+    """Request to batch create relationships."""
+
+    relationships: List[Dict[str, Any]] = Field(
+        ..., description="Relationships to create"
+    )
+
+
+class BatchRelationshipsResponse(BaseModel):
+    """Response from batch relationship creation."""
+
+    count: int = Field(..., description="Number of relationships created")
+
+
+class FileMetadataResponse(BaseModel):
+    """File metadata for incremental ingestion."""
+
+    metadata: Optional[Dict[str, Any]] = Field(
+        None, description="File metadata or None if not found"
+    )
+
+
+class FilePathsResponse(BaseModel):
+    """List of file paths in the graph."""
+
+    paths: List[str] = Field(..., description="File paths")
+    count: int = Field(..., description="Number of files")
+
+
+class DeleteResponse(BaseModel):
+    """Response from delete operation."""
+
+    deleted: int = Field(..., description="Number of items deleted")
+
+
+# =============================================================================
+# Helper Functions
+# =============================================================================
+
+
+def _get_client_for_user(user: APIKeyUser):
+    """Get graph client scoped to user's organization."""
+    factory = get_factory()
+    return factory.get_client(org_id=UUID(user.org_id), org_slug=user.org_slug)
+
+
+# =============================================================================
+# Endpoints
+# =============================================================================
+
+
+@router.post("/query", response_model=QueryResponse)
+async def execute_query(
+    request: QueryRequest,
+    user: APIKeyUser = Depends(get_current_api_key_user),
+) -> QueryResponse:
+    """Execute a Cypher query on the organization's graph."""
+    client = _get_client_for_user(user)
+    try:
+        results = client.execute_query(
+            request.query,
+            parameters=request.parameters,
+            timeout=request.timeout,
+        )
+        return QueryResponse(results=results, count=len(results))
+    except Exception as e:
+        logger.error(f"Query failed: {e}", org_id=user.org_id)
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Query failed: {str(e)}",
+        )
+    finally:
+        client.close()
+
+
+@router.get("/stats", response_model=StatsResponse)
+async def get_stats(
+    user: APIKeyUser = Depends(get_current_api_key_user),
+) -> StatsResponse:
+    """Get graph statistics."""
+    client = _get_client_for_user(user)
+    try:
+        stats = client.get_stats()
+        return StatsResponse(stats=stats)
+    finally:
+        client.close()
+
+
+@router.delete("/clear", response_model=DeleteResponse)
+async def clear_graph(
+    user: APIKeyUser = Depends(get_current_api_key_user),
+) -> DeleteResponse:
+    """Clear all nodes and relationships from the graph."""
+    client = _get_client_for_user(user)
+    try:
+        # Get count before clearing for response
+        stats = client.get_stats()
+        total = sum(stats.values())
+        client.clear_graph()
+        logger.info(f"Graph cleared", org_id=user.org_id, deleted=total)
+        return DeleteResponse(deleted=total)
+    finally:
+        client.close()
+
+
+@router.post("/batch/nodes", response_model=BatchNodesResponse)
+async def batch_create_nodes(
+    request: BatchNodesRequest,
+    user: APIKeyUser = Depends(get_current_api_key_user),
+) -> BatchNodesResponse:
+    """Batch create nodes in the graph."""
+    client = _get_client_for_user(user)
+    try:
+        # Convert dicts to appropriate Entity subclass
+        entities = []
+        for e in request.entities:
+            entity_type = e.get("entity_type", "Unknown")
+            node_type = NodeType(entity_type) if entity_type in [t.value for t in NodeType] else None
+
+            # Common fields for all entities
+            base_fields = {
+                "name": e["name"],
+                "qualified_name": e["qualified_name"],
+                "file_path": e.get("file_path", ""),
+                "line_start": e.get("line_start", 0),
+                "line_end": e.get("line_end", 0),
+                "docstring": e.get("docstring"),
+            }
+
+            # Create appropriate entity type
+            if entity_type == "File":
+                entity = FileEntity(
+                    **base_fields,
+                    node_type=NodeType.FILE,
+                    language=e.get("language", "python"),
+                    loc=e.get("loc", 0),
+                    hash=e.get("hash"),
+                    exports=e.get("exports", []),
+                )
+            elif entity_type == "Class":
+                entity = ClassEntity(
+                    **base_fields,
+                    node_type=NodeType.CLASS,
+                    is_abstract=e.get("is_abstract", False),
+                    complexity=e.get("complexity", 0),
+                    decorators=e.get("decorators", []),
+                )
+            elif entity_type == "Function":
+                entity = FunctionEntity(
+                    **base_fields,
+                    node_type=NodeType.FUNCTION,
+                    parameters=e.get("parameters", []),
+                    return_type=e.get("return_type"),
+                    is_async=e.get("is_async", False),
+                    decorators=e.get("decorators", []),
+                    complexity=e.get("complexity", 0),
+                    is_method=e.get("is_method", False),
+                    is_static=e.get("is_static", False),
+                    is_classmethod=e.get("is_classmethod", False),
+                    is_property=e.get("is_property", False),
+                )
+            elif entity_type == "Module":
+                entity = ModuleEntity(
+                    **base_fields,
+                    node_type=NodeType.MODULE,
+                    is_external=e.get("is_external", False),
+                    package=e.get("package"),
+                )
+            else:
+                # Fall back to base Entity for unknown types
+                entity = Entity(
+                    **base_fields,
+                    node_type=node_type,
+                )
+
+            # Set repo_id and repo_slug for multi-tenant isolation
+            if e.get("repo_id"):
+                entity.repo_id = e["repo_id"]
+            if e.get("repo_slug"):
+                entity.repo_slug = e["repo_slug"]
+
+            entities.append(entity)
+
+        created = client.batch_create_nodes(entities)
+        return BatchNodesResponse(created=created, count=len(created))
+    except Exception as e:
+        logger.error(f"Batch create nodes failed: {e}", org_id=user.org_id)
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Batch create failed: {str(e)}",
+        )
+    finally:
+        client.close()
+
+
+@router.post("/batch/relationships", response_model=BatchRelationshipsResponse)
+async def batch_create_relationships(
+    request: BatchRelationshipsRequest,
+    user: APIKeyUser = Depends(get_current_api_key_user),
+) -> BatchRelationshipsResponse:
+    """Batch create relationships in the graph."""
+    client = _get_client_for_user(user)
+    try:
+        # Convert dicts to Relationship objects
+        relationships = []
+        for r in request.relationships:
+            # Parse rel_type from string to enum
+            rel_type_str = r.get("rel_type", "CALLS")
+            try:
+                rel_type = RelationshipType(rel_type_str)
+            except ValueError:
+                rel_type = RelationshipType.CALLS  # Default fallback
+
+            rel = Relationship(
+                source_id=r["source_id"],
+                target_id=r["target_id"],
+                rel_type=rel_type,
+                properties=r.get("properties", {}),
+            )
+            relationships.append(rel)
+
+        count = client.batch_create_relationships(relationships)
+        return BatchRelationshipsResponse(count=count)
+    except Exception as e:
+        logger.error(f"Batch create relationships failed: {e}", org_id=user.org_id)
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Batch create failed: {str(e)}",
+        )
+    finally:
+        client.close()
+
+
+@router.get("/files", response_model=FilePathsResponse)
+async def get_file_paths(
+    user: APIKeyUser = Depends(get_current_api_key_user),
+) -> FilePathsResponse:
+    """Get all file paths in the graph."""
+    client = _get_client_for_user(user)
+    try:
+        paths = client.get_all_file_paths()
+        return FilePathsResponse(paths=paths, count=len(paths))
+    finally:
+        client.close()
+
+
+@router.get("/files/{file_path:path}/metadata", response_model=FileMetadataResponse)
+async def get_file_metadata(
+    file_path: str,
+    user: APIKeyUser = Depends(get_current_api_key_user),
+) -> FileMetadataResponse:
+    """Get metadata for a specific file (for incremental ingestion)."""
+    client = _get_client_for_user(user)
+    try:
+        metadata = client.get_file_metadata(file_path)
+        return FileMetadataResponse(metadata=metadata)
+    finally:
+        client.close()
+
+
+@router.delete("/files/{file_path:path}", response_model=DeleteResponse)
+async def delete_file(
+    file_path: str,
+    user: APIKeyUser = Depends(get_current_api_key_user),
+) -> DeleteResponse:
+    """Delete a file and its related entities from the graph."""
+    client = _get_client_for_user(user)
+    try:
+        deleted = client.delete_file_entities(file_path)
+        return DeleteResponse(deleted=deleted)
+    finally:
+        client.close()
+
+
+@router.post("/indexes")
+async def create_indexes(
+    user: APIKeyUser = Depends(get_current_api_key_user),
+) -> Dict[str, str]:
+    """Create indexes for better query performance."""
+    client = _get_client_for_user(user)
+    try:
+        client.create_indexes()
+        return {"status": "ok", "message": "Indexes created"}
+    finally:
+        client.close()