repotoire 0.1.2__cp314-cp314-win_amd64.whl → 0.1.3__cp314-cp314-win_amd64.whl

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/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()

repotoire/cli/__init__.py

@@ -445,23 +445,6 @@ def whoami() -> None:
 
 @cli.command()
 @click.argument("repo_path", type=click.Path(exists=True))
-@click.option(
-    "--db-type",
-    type=click.Choice(["neo4j", "falkordb"], case_sensitive=False),
-    default=None,
-    envvar="REPOTOIRE_DB_TYPE",
-    help="Database type: neo4j or falkordb (default: neo4j, or REPOTOIRE_DB_TYPE env)",
-)
-@click.option(
-    "--neo4j-uri", default=None, help="Neo4j connection URI (overrides config)"
-)
-@click.option("--neo4j-user", default=None, help="Neo4j username (overrides config)")
-@click.option(
-    "--neo4j-password",
-    default=None,
-    envvar="REPOTOIRE_NEO4J_PASSWORD",
-    help="Neo4j password (overrides config, prompts if not provided for neo4j)",
-)
 @click.option(
     "--pattern",
     "-p",
@@ -556,10 +539,6 @@ def whoami() -> None:
 def ingest(
     ctx: click.Context,
     repo_path: str,
-    db_type: str | None,
-    neo4j_uri: str | None,
-    neo4j_user: str | None,
-    neo4j_password: str | None,
     pattern: tuple | None,
     follow_symlinks: bool | None,
     max_file_size: float | None,
@@ -579,11 +558,15 @@ def ingest(
     """Ingest a codebase into the knowledge graph.
 
     \b
-    Parses source code and builds a Neo4j knowledge graph containing:
+    Parses source code and builds a knowledge graph containing:
     - Files, modules, classes, functions, and variables
     - Relationships: IMPORTS, CALLS, CONTAINS, INHERITS, USES
     - Optional: AI-powered semantic clues and vector embeddings
 
+    \b
+    PREREQUISITES:
+      Login first: repotoire login
+
     \b
     EXAMPLES:
       # Basic ingestion
@@ -595,9 +578,6 @@ def ingest(
       # Force full re-ingestion (ignore cache)
       $ repotoire ingest ./my-project --force-full
 
-      # Use FalkorDB instead of Neo4j
-      $ repotoire ingest ./my-project --db-type falkordb
-
     \b
     INCREMENTAL MODE (default):
       Only processes files changed since last ingestion. Uses MD5 hashes
@@ -611,11 +591,6 @@ def ingest(
       - File size limits (10MB default)
       - Secrets detection with configurable policy
 
-    \b
-    DATABASE BACKENDS:
-      neo4j     Full-featured graph database (recommended)
-      falkordb  Lightweight Redis-based alternative (faster startup)
-
     \b
     EMBEDDING BACKENDS:
       auto      Auto-select best available (default)
@@ -626,9 +601,7 @@ def ingest(
 
     \b
     ENVIRONMENT VARIABLES:
-      REPOTOIRE_NEO4J_URI       Neo4j connection URI
-      REPOTOIRE_NEO4J_PASSWORD  Neo4j password
-      REPOTOIRE_DB_TYPE         Database type (neo4j/falkordb)
+      REPOTOIRE_API_KEY         API key (or use 'repotoire login')
       OPENAI_API_KEY            For OpenAI embeddings
       VOYAGE_API_KEY            For Voyage embeddings
       DEEPINFRA_API_KEY         For DeepInfra embeddings
@@ -636,24 +609,12 @@ def ingest(
     # Get config from context
     config: FalkorConfig = ctx.obj['config']
 
-    # Determine database type
-    if db_type:
-        final_db_type = db_type
-    elif hasattr(config.neo4j, 'db_type') and config.neo4j.db_type:
-        final_db_type = config.neo4j.db_type
-    else:
-        final_db_type = "neo4j"
-    use_falkordb = final_db_type.lower() == "falkordb"
-
     # Validate inputs before execution
     try:
         # Validate repository path
         validated_repo_path = validate_repository_path(repo_path)
 
         # Apply config defaults (CLI options override config)
-        final_neo4j_uri = neo4j_uri or config.neo4j.uri
-        final_neo4j_user = neo4j_user or config.neo4j.user
-        final_neo4j_password = neo4j_password or config.neo4j.password
         final_patterns = list(pattern) if pattern else config.ingestion.patterns
         final_follow_symlinks = follow_symlinks if follow_symlinks is not None else config.ingestion.follow_symlinks
         final_max_file_size = max_file_size if max_file_size is not None else config.ingestion.max_file_size_mb
@@ -667,43 +628,12 @@ def ingest(
         # Convert secrets policy string to enum
         final_secrets_policy = SecretsPolicy(final_secrets_policy_str)
 
-        if use_falkordb:
-            # FalkorDB validation - simpler, no auth required
-            console.print("[dim]Checking FalkorDB connectivity...[/dim]")
-            # FalkorDB uses Redis protocol, not bolt
-            # Password is optional for FalkorDB
-        else:
-            # Neo4j validation
-            # Validate Neo4j URI
-            final_neo4j_uri = validate_neo4j_uri(final_neo4j_uri)
-
-            # Prompt for password if not provided
-            if not final_neo4j_password:
-                final_neo4j_password = click.prompt("Neo4j password", hide_input=True)
-
-            # Validate credentials
-            final_neo4j_user, final_neo4j_password = validate_neo4j_credentials(
-                final_neo4j_user, final_neo4j_password
-            )
-
-            # Test Neo4j connection is reachable
-            console.print("[dim]Checking Neo4j connectivity...[/dim]")
-            validate_neo4j_connection(final_neo4j_uri, final_neo4j_user, final_neo4j_password)
-            console.print("[green]✓[/green] Neo4j connection validated\n")
-
         # Validate file size limit
         final_max_file_size = validate_file_size_limit(final_max_file_size)
 
         # Validate batch size
         validated_batch_size = validate_batch_size(final_batch_size)
 
-        # Validate retry configuration
-        validated_retries = validate_retry_config(
-            config.neo4j.max_retries,
-            config.neo4j.retry_backoff_factor,
-            config.neo4j.retry_base_delay
-        )
-
     except ValidationError as e:
         console.print(f"\n[red]❌ Validation Error:[/red] {e.message}")
         if e.suggestion:
@@ -712,7 +642,6 @@ def ingest(
 
     console.print(f"\n[bold cyan]🎼 Repotoire Ingestion[/bold cyan]\n")
     console.print(f"Repository: {repo_path}")
-    console.print(f"Database: {final_db_type}")
     console.print(f"Patterns: {', '.join(final_patterns)}")
     console.print(f"Follow symlinks: {final_follow_symlinks}")
     console.print(f"Max file size: {final_max_file_size}MB")
@@ -741,19 +670,8 @@ def ingest(
         with LogContext(operation="ingest", repo_path=repo_path):
             logger.info("Starting ingestion")
 
-            # Create database client using factory
-            if use_falkordb:
-                db = create_client(db_type="falkordb")
-            else:
-                db = create_client(
-                    uri=final_neo4j_uri,
-                    db_type="neo4j",
-                    username=final_neo4j_user,
-                    password=final_neo4j_password,
-                    max_retries=validated_retries[0],
-                    retry_backoff_factor=validated_retries[1],
-                    retry_base_delay=validated_retries[2],
-                )
+            # Create database client (connects to Repotoire Cloud)
+            db = _get_db_client(quiet=quiet)
 
             try:
                 # Clear database if force-full is requested

repotoire/cli/auth.py

@@ -39,6 +39,22 @@ class AuthenticationError(Exception):
     pass
 
 
+@dataclass
+class CLICredentials:
+    """Credentials for CLI authentication.
+
+    Contains the access token (API key) and optional metadata
+    for making authenticated API requests.
+    """
+
+    access_token: str
+    org_id: Optional[str] = None
+    org_slug: Optional[str] = None
+    plan: Optional[str] = None
+    user_email: Optional[str] = None
+    user_id: Optional[str] = None
+
+
 @dataclass
 class OAuthCallbackResult:
     """Result from OAuth callback."""
@@ -310,6 +326,23 @@ class CLIAuth:
         if source:
             console.print(f"[bold]Stored in:[/] {source}")
 
+    def get_current_user(self) -> Optional[CLICredentials]:
+        """Get current user credentials if authenticated.
+
+        Returns:
+            CLICredentials if logged in, None otherwise
+        """
+        api_key = self.get_api_key()
+        if not api_key:
+            return None
+
+        return CLICredentials(access_token=api_key)
+
+    @property
+    def api_url(self) -> str:
+        """Get API URL for tier limit checks."""
+        return os.environ.get("REPOTOIRE_API_URL", "https://repotoire-api.fly.dev")
+
 
 def is_offline_mode() -> bool:
     """Check if running in offline mode.

repotoire/detectors/async_antipattern.py

@@ -90,7 +90,7 @@ class AsyncAntipatternDetector(CodeSmellDetector):
         """
         super().__init__(neo4j_client)
         self.enricher = enricher
-        self.is_falkordb = type(neo4j_client).__name__ == "FalkorDBClient"
+        self.is_falkordb = getattr(neo4j_client, "is_falkordb", False) or type(neo4j_client).__name__ == "FalkorDBClient"
 
         # Allow config to override thresholds
         config = detector_config or {}

repotoire/detectors/circular_dependency.py

@@ -42,7 +42,7 @@ class CircularDependencyDetector(CodeSmellDetector):
         super().__init__(neo4j_client)
         self.enricher = enricher
         # FalkorDB uses id() while Neo4j uses elementId()
-        self.is_falkordb = type(neo4j_client).__name__ == "FalkorDBClient"
+        self.is_falkordb = getattr(neo4j_client, "is_falkordb", False) or type(neo4j_client).__name__ == "FalkorDBClient"
         self.id_func = "id" if self.is_falkordb else "elementId"
 
     def detect(self) -> List[Finding]:

repotoire/detectors/data_clumps.py

@@ -75,7 +75,7 @@ class DataClumpsDetector(CodeSmellDetector):
         super().__init__(neo4j_client)
         self.enricher = enricher
         # FalkorDB uses id() while Neo4j uses elementId()
-        self.is_falkordb = type(neo4j_client).__name__ == "FalkorDBClient"
+        self.is_falkordb = getattr(neo4j_client, "is_falkordb", False) or type(neo4j_client).__name__ == "FalkorDBClient"
 
         # Allow config to override thresholds
         config = detector_config or {}

repotoire/detectors/dead_code.py

@@ -36,7 +36,7 @@ class DeadCodeDetector(CodeSmellDetector):
         self.validated_confidence = 0.95  # When Vulture confirms
 
         # FalkorDB doesn't support EXISTS {} subqueries
-        self.is_falkordb = type(neo4j_client).__name__ == "FalkorDBClient"
+        self.is_falkordb = getattr(neo4j_client, "is_falkordb", False) or type(neo4j_client).__name__ == "FalkorDBClient"
 
     @property
     def needs_previous_findings(self) -> bool:

repotoire/detectors/engine.py

@@ -132,7 +132,7 @@ class AnalysisEngine:
         self.parallel = parallel
         self.max_workers = max_workers
         # Check if using FalkorDB (no GDS support)
-        self.is_falkordb = type(neo4j_client).__name__ == "FalkorDBClient"
+        self.is_falkordb = getattr(neo4j_client, "is_falkordb", False) or type(neo4j_client).__name__ == "FalkorDBClient"
         config = detector_config or {}
 
         # Initialize GraphEnricher for cross-detector collaboration (REPO-151 Phase 2)

repotoire/detectors/generator_misuse.py

@@ -65,7 +65,7 @@ class GeneratorMisuseDetector(CodeSmellDetector):
         """
         super().__init__(neo4j_client)
         self.enricher = enricher
-        self.is_falkordb = type(neo4j_client).__name__ == "FalkorDBClient"
+        self.is_falkordb = getattr(neo4j_client, "is_falkordb", False) or type(neo4j_client).__name__ == "FalkorDBClient"
 
         # Allow config to override thresholds
         config = detector_config or {}

repotoire/detectors/graph_algorithms.py

@@ -150,7 +150,7 @@ class GraphAlgorithms:
             True if GDS is available, False otherwise
         """
         # FalkorDB doesn't have GDS - skip immediately without retry
-        if type(self.client).__name__ == "FalkorDBClient":
+        if getattr(self.client, "is_falkordb", False) or type(self.client).__name__ == "FalkorDBClient":
             logger.info("FalkorDB detected - GDS not available (using Rust algorithms)")
             return False
 

repotoire/detectors/inappropriate_intimacy.py

@@ -31,7 +31,7 @@ class InappropriateIntimacyDetector(CodeSmellDetector):
         self.min_mutual_access = config.get("min_mutual_access", 5)
         self.logger = get_logger(__name__)
         # FalkorDB uses id() while Neo4j uses elementId()
-        self.is_falkordb = type(neo4j_client).__name__ == "FalkorDBClient"
+        self.is_falkordb = getattr(neo4j_client, "is_falkordb", False) or type(neo4j_client).__name__ == "FalkorDBClient"
         self.id_func = "id" if self.is_falkordb else "elementId"
 
     def detect(self) -> List[Finding]:

repotoire/detectors/long_parameter_list.py

@@ -58,7 +58,7 @@ class LongParameterListDetector(CodeSmellDetector):
         """
         super().__init__(neo4j_client)
         self.enricher = enricher
-        self.is_falkordb = type(neo4j_client).__name__ == "FalkorDBClient"
+        self.is_falkordb = getattr(neo4j_client, "is_falkordb", False) or type(neo4j_client).__name__ == "FalkorDBClient"
 
         # Allow config to override thresholds
         config = detector_config or {}

repotoire/detectors/message_chain.py

@@ -68,7 +68,7 @@ class MessageChainDetector(CodeSmellDetector):
         """
         super().__init__(neo4j_client)
         self.enricher = enricher
-        self.is_falkordb = type(neo4j_client).__name__ == "FalkorDBClient"
+        self.is_falkordb = getattr(neo4j_client, "is_falkordb", False) or type(neo4j_client).__name__ == "FalkorDBClient"
 
         # Allow config to override thresholds
         config = detector_config or {}

repotoire/detectors/test_smell.py

@@ -125,7 +125,7 @@ class TestSmellDetector(CodeSmellDetector):
         """
         super().__init__(neo4j_client)
         self.enricher = enricher
-        self.is_falkordb = type(neo4j_client).__name__ == "FalkorDBClient"
+        self.is_falkordb = getattr(neo4j_client, "is_falkordb", False) or type(neo4j_client).__name__ == "FalkorDBClient"
 
         # Allow config to override thresholds
         config = detector_config or {}

repotoire/detectors/type_hint_coverage.py

@@ -70,7 +70,7 @@ class TypeHintCoverageDetector(CodeSmellDetector):
         """
         super().__init__(neo4j_client)
         self.enricher = enricher
-        self.is_falkordb = type(neo4j_client).__name__ == "FalkorDBClient"
+        self.is_falkordb = getattr(neo4j_client, "is_falkordb", False) or type(neo4j_client).__name__ == "FalkorDBClient"
 
         # Allow config to override thresholds
         config = detector_config or {}

repotoire/graph/cloud_client.py

@@ -0,0 +1,215 @@
+"""Cloud proxy client for graph database operations.
+
+This client proxies all graph operations through the Repotoire API,
+allowing the CLI to work without direct database access.
+"""
+
+import os
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+from repotoire.graph.base import DatabaseClient
+from repotoire.logging_config import get_logger
+from repotoire.models import Entity, Relationship
+
+logger = get_logger(__name__)
+
+DEFAULT_API_URL = "https://repotoire-api.fly.dev"
+
+
+class CloudProxyClient(DatabaseClient):
+    """Graph database client that proxies through the Repotoire API.
+
+    All operations are sent to the API which executes them on the
+    internal FalkorDB instance. This allows the CLI to work without
+    direct database connectivity.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        api_url: Optional[str] = None,
+        timeout: float = 60.0,
+    ):
+        """Initialize the cloud proxy client.
+
+        Args:
+            api_key: Repotoire API key for authentication
+            api_url: API base URL (defaults to production)
+            timeout: Request timeout in seconds
+        """
+        self.api_key = api_key
+        self.api_url = api_url or os.environ.get("REPOTOIRE_API_URL", DEFAULT_API_URL)
+        self.timeout = timeout
+        self._client = httpx.Client(
+            base_url=f"{self.api_url}/api/v1/graph",
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=timeout,
+        )
+
+    @property
+    def is_falkordb(self) -> bool:
+        """Cloud backend uses FalkorDB."""
+        return True
+
+    def close(self) -> None:
+        """Close the HTTP client."""
+        self._client.close()
+
+    def _request(
+        self,
+        method: str,
+        endpoint: str,
+        json: Optional[Dict] = None,
+        params: Optional[Dict] = None,
+    ) -> Dict:
+        """Make an API request.
+
+        Args:
+            method: HTTP method
+            endpoint: API endpoint (relative to /api/v1/graph)
+            json: JSON body
+            params: Query parameters
+
+        Returns:
+            Response JSON
+
+        Raises:
+            Exception: On API error
+        """
+        response = self._client.request(
+            method=method,
+            url=endpoint,
+            json=json,
+            params=params,
+        )
+
+        if response.status_code >= 400:
+            try:
+                error = response.json()
+                detail = error.get("detail", str(error))
+            except Exception:
+                detail = response.text
+            raise Exception(f"API error ({response.status_code}): {detail}")
+
+        return response.json()
+
+    def execute_query(
+        self,
+        query: str,
+        parameters: Optional[Dict] = None,
+        timeout: Optional[float] = None,
+    ) -> List[Dict]:
+        """Execute a Cypher query via the API."""
+        response = self._request(
+            "POST",
+            "/query",
+            json={
+                "query": query,
+                "parameters": parameters,
+                "timeout": timeout,
+            },
+        )
+        return response.get("results", [])
+
+    def create_node(self, entity: Entity) -> str:
+        """Create a single node."""
+        result = self.batch_create_nodes([entity])
+        return result.get(entity.qualified_name, "")
+
+    def create_relationship(self, rel: Relationship) -> None:
+        """Create a single relationship."""
+        self.batch_create_relationships([rel])
+
+    def batch_create_nodes(self, entities: List[Entity]) -> Dict[str, str]:
+        """Create multiple nodes via the API."""
+        entity_dicts = []
+        for e in entities:
+            entity_dict = {
+                "entity_type": e.node_type.value if e.node_type else "Unknown",
+                "name": e.name,
+                "qualified_name": e.qualified_name,
+                "file_path": e.file_path,
+                "line_start": e.line_start,
+                "line_end": e.line_end,
+                "docstring": e.docstring,
+            }
+
+            # Add repo_id and repo_slug for multi-tenant isolation
+            if e.repo_id:
+                entity_dict["repo_id"] = e.repo_id
+            if e.repo_slug:
+                entity_dict["repo_slug"] = e.repo_slug
+
+            # Add type-specific fields (matching FalkorDB client)
+            for attr in ["is_external", "package", "loc", "hash", "language",
+                         "exports", "is_abstract", "complexity", "parameters",
+                         "return_type", "is_async", "decorators", "is_method",
+                         "is_static", "is_classmethod", "is_property"]:
+                if hasattr(e, attr):
+                    val = getattr(e, attr)
+                    if val is not None:
+                        entity_dict[attr] = val
+
+            entity_dicts.append(entity_dict)
+
+        response = self._request(
+            "POST",
+            "/batch/nodes",
+            json={"entities": entity_dicts},
+        )
+        return response.get("created", {})
+
+    def batch_create_relationships(self, relationships: List[Relationship]) -> int:
+        """Create multiple relationships via the API."""
+        rel_dicts = []
+        for r in relationships:
+            rel_dict = {
+                "source_id": r.source_id,
+                "target_id": r.target_id,
+                "rel_type": r.rel_type.value if hasattr(r.rel_type, 'value') else str(r.rel_type),
+                "properties": r.properties or {},
+            }
+            rel_dicts.append(rel_dict)
+
+        response = self._request(
+            "POST",
+            "/batch/relationships",
+            json={"relationships": rel_dicts},
+        )
+        return response.get("count", 0)
+
+    def clear_graph(self) -> None:
+        """Clear all nodes and relationships."""
+        self._request("DELETE", "/clear")
+
+    def create_indexes(self) -> None:
+        """Create indexes for better performance."""
+        self._request("POST", "/indexes")
+
+    def get_stats(self) -> Dict[str, int]:
+        """Get graph statistics."""
+        response = self._request("GET", "/stats")
+        return response.get("stats", {})
+
+    def get_all_file_paths(self) -> List[str]:
+        """Get all file paths in the graph."""
+        response = self._request("GET", "/files")
+        return response.get("paths", [])
+
+    def get_file_metadata(self, file_path: str) -> Optional[Dict[str, Any]]:
+        """Get metadata for a specific file."""
+        try:
+            response = self._request(
+                "GET",
+                f"/files/{file_path}/metadata",
+            )
+            return response.get("metadata")
+        except Exception:
+            return None
+
+    def delete_file_entities(self, file_path: str) -> int:
+        """Delete a file and its related entities."""
+        response = self._request("DELETE", f"/files/{file_path}")
+        return response.get("deleted", 0)

repotoire/graph/factory.py

@@ -354,10 +354,11 @@ def create_cloud_client(
     show_indicator: bool = True,
     command: Optional[str] = None,
 ) -> DatabaseClient:
-    """Create a cloud-connected FalkorDB client.
+    """Create a cloud proxy client.
 
-    Validates the API key against the Repotoire Cloud API and returns
-    a FalkorDB client configured for the user's organization.
+    Returns a client that proxies all graph operations through the
+    Repotoire API. This allows the CLI to work without direct database
+    connectivity.
 
     Args:
         api_key: Repotoire API key (starts with 'ak_' or 'rp_')
@@ -365,13 +366,13 @@ def create_cloud_client(
         command: CLI command being executed (for audit logging)
 
     Returns:
-        FalkorDBClient configured for cloud mode
+        CloudProxyClient that proxies operations through the API
 
     Raises:
         CloudAuthenticationError: If API key is invalid or expired
         CloudConnectionError: If cannot connect to Repotoire Cloud
     """
-    from repotoire.graph.falkordb_client import FalkorDBClient
+    from repotoire.graph.cloud_client import CloudProxyClient
 
     # Check cache first
     auth_info = _get_cached_auth(api_key)
@@ -391,19 +392,8 @@ def create_cloud_client(
     # Log connection to Neon (fire-and-forget, non-blocking)
     _log_cloud_connection(api_key, auth_info, cached=used_cache, command=command)
 
-    # Create FalkorDB client with cloud config
-    db_config = auth_info.db_config
-
-    return FalkorDBClient(
-        host=db_config["host"],
-        port=db_config.get("port", 6379),
-        graph_name=db_config["graph"],
-        # REPO-395: Use derived password from API response
-        # The password is derived from the API key using HMAC-SHA256,
-        # so users never see the master FalkorDB password
-        password=db_config.get("password"),
-        ssl=db_config.get("ssl", False),
-    )
+    # Create cloud proxy client
+    return CloudProxyClient(api_key=api_key)
 
 
 def _validate_api_key(api_key: str) -> CloudAuthInfo:

repotoire/graph/schema.py

@@ -201,8 +201,8 @@ class GraphSchema:
             client: Neo4j or FalkorDB client instance
         """
         self.client = client
-        # Detect if we're using FalkorDB
-        self.is_falkordb = type(client).__name__ == "FalkorDBClient"
+        # Detect if we're using FalkorDB (check property first, then class name)
+        self.is_falkordb = getattr(client, "is_falkordb", False) or type(client).__name__ == "FalkorDBClient"
 
     def create_constraints(self) -> None:
         """Create all uniqueness constraints."""

{repotoire-0.1.2.dist-info → repotoire-0.1.3.dist-info}/METADATA

@@ -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.dist-info → repotoire-0.1.3.dist-info}/RECORD

@@ -1,8 +1,8 @@
 LICENSE,sha256=kZQMuoI-6QQZH9KFUiVK5u_tDmT9SO-Z4QFp0hE-cfg,1105
-repotoire-0.1.2.dist-info/METADATA,sha256=d7QSJUtm9KN10MGBz2p0GSvjIxGOV2pOFFx5Gw2zrgg,23958
-repotoire-0.1.2.dist-info/WHEEL,sha256=ZrAiv7lKoKZh206bhSq4g-n3q3ySUOJQmQ4WXAA7TE8,97
-repotoire-0.1.2.dist-info/entry_points.txt,sha256=qDZ_wx7dF6GDyrQJ70OXdRPBMJF6hEZIOxEZqX8jfdw,299
-repotoire-0.1.2.dist-info/licenses/LICENSE,sha256=kZQMuoI-6QQZH9KFUiVK5u_tDmT9SO-Z4QFp0hE-cfg,1105
+repotoire-0.1.3.dist-info/METADATA,sha256=gMjG0KQAcg2E9VfA6hM86xrg8eaFfM4e52-_bNl4r4E,23796
+repotoire-0.1.3.dist-info/WHEEL,sha256=ZrAiv7lKoKZh206bhSq4g-n3q3ySUOJQmQ4WXAA7TE8,97
+repotoire-0.1.3.dist-info/entry_points.txt,sha256=qDZ_wx7dF6GDyrQJ70OXdRPBMJF6hEZIOxEZqX8jfdw,299
+repotoire-0.1.3.dist-info/licenses/LICENSE,sha256=kZQMuoI-6QQZH9KFUiVK5u_tDmT9SO-Z4QFp0hE-cfg,1105
 repotoire/__init__.py,sha256=hgmEsSDh0eG73leeSicWDGAb_BDdff9ItMpKw51veHg,515
 repotoire/ai/__init__.py,sha256=LYHXLUjXF9hcXangbWNhrUg8fbGyDrdxj7DvpwBtJIA,1955
 repotoire/ai/contextual.py,sha256=CBepfMFUwESqrQf1GgfDuxdfOKojPVj_JDKLot_9tP4,15667
@@ -80,7 +80,7 @@ repotoire/api/shared/services/encryption.py,sha256=o3DQmQv1ZfcSnN61NVP03Mec4DctW
 repotoire/api/shared/services/gdpr.py,sha256=mEGokakr5WjXyqgFiiSDu-UfBooDm5Bw99wspwur4KY,18282
 repotoire/api/shared/services/github.py,sha256=BKGaPMsgmHE0hnabTaPsK_wuGWSF0Q6Ph5Vfv-rFHEw,11094
 repotoire/api/shared/services/stripe_service.py,sha256=WnZmUee3K6YpBk3GfWrpXnX1UrZJ7ZoM73coFb9E_wE,24363
-repotoire/api/v1/__init__.py,sha256=hhl-ddaqBiEp4kQFOlNp39EnCu2gENw-RJ9TPwvsspE,8373
+repotoire/api/v1/__init__.py,sha256=xO7jwYU3Nhdo4qtVb6m1g4GL6XkTAT1ov6nFbuE2ztM,8422
 repotoire/api/v1/routes/__init__.py,sha256=EJAQ63XgFtFap2RS3tIZxP14huFo1y7jndA8mKIcJb4,793
 repotoire/api/v1/routes/account.py,sha256=L2C3dkmym9IdrgSgsSKU8lwg3oGeukrLiAIQqvfzEck,19505
 repotoire/api/v1/routes/admin/__init__.py,sha256=YUEAmdX1vuhVVpTuXuTahxXHM7iUa0Kl_e3GuGyYhK8,179
@@ -100,6 +100,7 @@ repotoire/api/v1/routes/customer_webhooks.py,sha256=lgYLZQ1F6H1UI7WR1HMkdUTcLxXC
 repotoire/api/v1/routes/findings.py,sha256=mmWrWY0HMNOs8AWaCrKjNHm6NciC7JBveeiUBfGKDJk,24686
 repotoire/api/v1/routes/fixes.py,sha256=egdOH0_jPPCg3kL4tTZR5TdHOzsjnDdQPui7PkLkgK0,47019
 repotoire/api/v1/routes/github.py,sha256=0XPFcaXPDANUYGFfKxx3Pn0L4SP43t6609Xe7CI9k58,53089
+repotoire/api/v1/routes/graph.py,sha256=bTnNVUhbL3kxTvsOxTmzyl9TaxKhGaub1d22o1Oyy5Q,16312
 repotoire/api/v1/routes/historical.py,sha256=NqAzG_KnBDVd5LYGM3uFRe3WXyK9skZFevM18yP_MW0,11470
 repotoire/api/v1/routes/marketplace.py,sha256=tPTWE463KFowU3JZZib-Qm3rObjltZvEfBgfuYnPm20,89371
 repotoire/api/v1/routes/notifications.py,sha256=e_geSoFAagN2Beo5o7e9VRPH462W1EPgMKdydY-Prtc,6473
@@ -145,9 +146,9 @@ repotoire/cache/base.py,sha256=8Yr1Y4onn2ns3F-GlBoRX6u6O4jzeDl-whJ9-4frlaQ,12040
 repotoire/cache/preview.py,sha256=hzGk0xlE6CwYWeABkF0SvP26W4xeAURLKUCQ5CwfIRo,5261
 repotoire/cache/scan.py,sha256=vwmMtC17ea8tO_GyqcWGf9FwoXWZIP53jvPVxwxhSHY,7581
 repotoire/cache/skill.py,sha256=TZ7RRRd2NAxsZjivcLu9iO7S_OC6L4WMm8ilqnS7y0s,10672
-repotoire/cli/__init__.py,sha256=PLnq2mqiqTyDfkMnLVIkJZ3msLdhpQpUde-Ed3o3zYg,229966
+repotoire/cli/__init__.py,sha256=EmH_jDFYS2AmUEKeL57kAEejPZMHkB_VL8Mmb1tnCnQ,226612
 repotoire/cli/api_keys.py,sha256=H5wJZXJFDWacKEp9lvkFDLeOXCKRYDYShBPsXMCDOZQ,6777
-repotoire/cli/auth.py,sha256=vs4YyX3PbktXyWovn3R0up53Stneu9MV-yfO8RPM8QA,10576
+repotoire/cli/auth.py,sha256=zU0EB9tfuGmiDkchuFa6qKnLYR7tEKO92LwLeQLv9AQ,11515
 repotoire/cli/auth_commands.py,sha256=tfKpovH_xqbdFkcmupN2ga_WvEEYEu4qPxd4O443dw4,2297
 repotoire/cli/credentials.py,sha256=ZTt-yp326xn5Mm-HQKXtcom4jPHkQM9T0E02IGqSXQ4,8991
 repotoire/cli/graph.py,sha256=FYtKZGzKwbOGcsU19Z7JfM57Z9SkRR7gs6Dh4ZbyyNw,13895
@@ -188,28 +189,28 @@ repotoire/db/repositories/quota_override.py,sha256=TYdYc07GXxfcF_acmUDiprPDHI4pL
 repotoire/db/session.py,sha256=SISDlr5JJQAAmh5kXXqHG9faUc7NsntpmHONvl1qY0o,6793
 repotoire/detectors/__init__.py,sha256=SfUgFV8BlIqkjye5VgYBr9Yr1hvQLRGaCn3atTFFj3Q,3099
 repotoire/detectors/architectural_bottleneck.py,sha256=7WFmV4QLsou6-_wuVdG-znkPmjKF8t7RZTlvTjqox9g,14555
-repotoire/detectors/async_antipattern.py,sha256=LRgzFdlILFIqCAMwJNI-y8nDuQVXN06iA8G5VHA7x6Y,19309
+repotoire/detectors/async_antipattern.py,sha256=zZOVixe_4I6lJ_7eIcJD7PYOreo4SSbkaWsVTFWb7Kg,19356
 repotoire/detectors/bandit_detector.py,sha256=DVXw7v10RO4lO9baQTEhPjyE3pp4B6uYbj89UJh4xz0,17057
 repotoire/detectors/base.py,sha256=-9KWUvn0f3l9VALUfeuK8MLiG_oVhixE60b4ah4N2J4,1633
-repotoire/detectors/circular_dependency.py,sha256=abhWCxgyglFVDpGJKL3JrFfJotfsmK4pHhfrzhnVuys,13232
+repotoire/detectors/circular_dependency.py,sha256=54LfQpjLzivjfxpSLqMPvGJaFt-zkyWrsGIbp_Ub5PE,13279
 repotoire/detectors/core_utility.py,sha256=ovp5QTt0Kv5qKYg_hLImmRK4W8zLZF4VZuBFLs4aW6o,12136
-repotoire/detectors/data_clumps.py,sha256=Zk1ta7hAJtrZjj9dseWh_AQLS-WCT_8V0BopKAAPyZE,16631
-repotoire/detectors/dead_code.py,sha256=GHycS1HXLkNcHo5m8yrlbNKpE4lfRAukBf1EztetGoU,30247
+repotoire/detectors/data_clumps.py,sha256=5csvR7JTY45CqwZos4LyLQXK5BPIGJQcS715-P45x00,16678
+repotoire/detectors/dead_code.py,sha256=So8EHoaKJgBBfeNx4miwYaWSgQ9zmg5Bh0-nhZ5VbsU,30294
 repotoire/detectors/deduplicator.py,sha256=_lqtJ8-Us0s-sHxmbg9999_edq5s5xV6IVcrcpJnbA0,14678
 repotoire/detectors/degree_centrality.py,sha256=Q7qQHLvdm-uIx6GWZWyYaWRrGvuun4_VSAAXdt5ysUg,16580
 repotoire/detectors/duplicate_rust.py,sha256=A7R60RKh9AsLL0nQNd6M_aPRqySbl7MpUxE9m6_jaaY,18280
-repotoire/detectors/engine.py,sha256=qcJba-9RO5NYGxXxRMXMZ4eg4mZ6tRb48wr59opno8Y,40254
+repotoire/detectors/engine.py,sha256=1LNObA0dvDWWftn5mbaiCgG1vhZEUQEowpFcua5ioZo,40301
 repotoire/detectors/feature_envy.py,sha256=Ci1PP7zL4SH7tLrX4xyWhq1Y7pjMtQeZp5visWS8t_U,11672
-repotoire/detectors/generator_misuse.py,sha256=ia6OnAaXo9Wap56wK21ZFJpN6Z3Mvvo2GEO-YvfHqyc,28926
+repotoire/detectors/generator_misuse.py,sha256=Z4eoYza4m6ClN2nr1v7qa74esKHVQ6X9NJau17GflSI,28973
 repotoire/detectors/god_class.py,sha256=qsyPyhhnPMjvjpz_grwq2oK8iwl7zj2nV9oF23AVFOY,38078
-repotoire/detectors/graph_algorithms.py,sha256=J_3tOfiYBjWtglo3eUD3TBhB_A5YVULHcoS93BqjLh8,58563
+repotoire/detectors/graph_algorithms.py,sha256=UAySR9IvaRAWrXDn0IiB9B-N5Q6yQ1Dp54IXF1h6fQs,58609
 repotoire/detectors/graphsage_detector.py,sha256=FN-2Y1AUDQYxA93BckZ_sOUfPp6rJoZxDCaF_kV3F_c,10303
-repotoire/detectors/inappropriate_intimacy.py,sha256=bc_TxvSWbrM3ER8lug9ZV9E-JBVWCJ3CLrv1EPbOkSs,8519
+repotoire/detectors/inappropriate_intimacy.py,sha256=OsPLNo1bEzQMVxpox0foYphjR84l98QuchDAzL1KI7I,8566
 repotoire/detectors/influential_code.py,sha256=3bunilaxP6K5ShwSeLln1-iToQoiYGGQn-oM7ZuVTEo,16064
 repotoire/detectors/jscpd_detector.py,sha256=bolku-5QKr2FftpIyGrOTdbSgFyqTF2y42NFWyEIl8U,16637
 repotoire/detectors/lazy_class.py,sha256=ciO4E2s9I4OCkhT8PD_wNMqc3AXMW19cwzIl68c3US8,8951
-repotoire/detectors/long_parameter_list.py,sha256=TyKfGxVaK6JCRG_VDcEU7NXnqkHNRTRe779Aoigmgro,15545
-repotoire/detectors/message_chain.py,sha256=7YYrcP_58DVZeXQMRsbpHBZ1VSy6oxN9Rw_qW_tH2zY,18832
+repotoire/detectors/long_parameter_list.py,sha256=MOsJL8emMb4eHMslpdgS1IKij6SXBOgIynHACF9hlK8,15592
+repotoire/detectors/message_chain.py,sha256=84o0gXg2t2K800kIge9WHAK8CbngbeYTi6Mg6umtWcQ,18879
 repotoire/detectors/middle_man.py,sha256=HEpZILxxk7YV3Mu4gh9oP0LxdTnM8ZwyvMXuT8xWTNQ,8181
 repotoire/detectors/ml_bug_detector.py,sha256=PbHSNwqRA-8PDaLsnVmjr617PpHJDwe9fJfB2bg4Hlw,9954
 repotoire/detectors/module_cohesion.py,sha256=lnOrwC20YilFKVnPLhInIw998QXzlX1jjc52j3GYEC4,15803
@@ -227,9 +228,9 @@ repotoire/detectors/semgrep_detector.py,sha256=taYuIjkda8N6WiyvbyLgPHVAIUVX-cV2P
 repotoire/detectors/shotgun_surgery.py,sha256=uKVYCWO-TnECx6wG2W-SgrlDtM6pbsp4o0SAXH2kA7Y,7552
 repotoire/detectors/taint_detector.py,sha256=Ol7jU1gyKY9AFbyHqssiJecLlwf_oy3M1f0FFD1q8a4,23273
 repotoire/detectors/temporal_metrics.py,sha256=YTU7-ud9YyFVXew1tToCYe7AX4Asjq0St30s74Bm3dg,16551
-repotoire/detectors/test_smell.py,sha256=re36RlIWbPiHb1toguFFvwEOeINSL2fkuK2X5ynIqns,27071
+repotoire/detectors/test_smell.py,sha256=KR6ITF4CaPCL2UeX-hAfqZikfCq-8nT_vxLvb9hUW6o,27118
 repotoire/detectors/truly_unused_imports.py,sha256=M2JFFEBPOPIQs1aqwW44XBOpVaGji3Ftcbdm57kx9LY,8622
-repotoire/detectors/type_hint_coverage.py,sha256=fUGsUYjqhHOLFrkf-AAJCaoSAna9Pdl9A4tSYFPADO4,20362
+repotoire/detectors/type_hint_coverage.py,sha256=sF_Nj6oZ3kT8Ssd9A2HkvMcmwqB7_fLUE831xku7Wck,20409
 repotoire/detectors/voting_engine.py,sha256=wjo3rpMh5gg8KcWDBGmXj4hrChDQUbDxApmyUBAHHP4,22204
 repotoire/detectors/vulture_detector.py,sha256=M8QEEIaSFIyrKAkpcsUoMNpAgN1aGKoCZZdWHRbQd4I,23507
 repotoire/github/__init__.py,sha256=MQ1cwg-UPYRXR8-nahSkFRfKSVGwdxr4_4_u2jqMrDQ,112
@@ -238,9 +239,10 @@ repotoire/github/pr_commenter.py,sha256=-MyUb3tlDzC_iW9Sm1sB2Z9aPD-o8KzpLPmMbLTI
 repotoire/graph/__init__.py,sha256=jgChDzW_7iE_ATIIH5qMQZELCK1T9jYfrM9MG1nOWVg,1362
 repotoire/graph/base.py,sha256=9jEcqhVnZLlFCTs1PM0RNu0CB3OvKIgxgAFH3UnjmkM,5714
 repotoire/graph/client.py,sha256=eryWMuuGgDoUGnui-dTJWtYD_PWUvpmz4HtmuPJbKhU,39988
+repotoire/graph/cloud_client.py,sha256=MfHUa0MkTIIq1xnb_i__fTZGa2unfthkCmnS541Ifys,7147
 repotoire/graph/enricher.py,sha256=5IOITHRSVsZhKNJdl_YMFJjYH2Nog5hUHDcJWJYEAFU,17441
 repotoire/graph/external_labels.py,sha256=eMdDaG11wTP1_mmgr-cUCFZl8Trs3XUh8vath7E3IB4,5446
-repotoire/graph/factory.py,sha256=ODvUGJNqc7HHNW694QxkocFfmnC5bi84zo5nuQNaR8s,18758
+repotoire/graph/factory.py,sha256=cFBE6TQHntmTk0vCEMWthcect9OYlQVqpAgW9NiMgDs,18349
 repotoire/graph/falkordb_client.py,sha256=4Yv6BPkzeZE8RB123MUvk6GRlOrkRABMRfO9Qs1VPhw,21190
 repotoire/graph/incremental_scc.py,sha256=MbYsGzPah5_0VzJhU5OFYcyO9DK3z9iCTeJfjUM3yeY,14387
 repotoire/graph/migration.py,sha256=Ya8O8yRT7CNJzqm9N6GkVUjycNiMKV6Kl4qjdVhyl_Q,14813
@@ -249,7 +251,7 @@ repotoire/graph/queries/__init__.py,sha256=iErJN8jB13njO73rnuJpnSzZarbcGjKs4pNp2
 repotoire/graph/queries/builders.py,sha256=ng1BLfE4s4MEkcKB47ZQcT2l_T4yzLWRkninQCmSmyI,11333
 repotoire/graph/queries/patterns.py,sha256=Wdg1DYHHOCalhiLcBsk1ODHAxVF04eIPiGaadymy83M,15662
 repotoire/graph/queries/traversal.py,sha256=MkeE-GSS6xkjgGf74ziaWNfdqwegkplwiu8Av-wMff0,12405
-repotoire/graph/schema.py,sha256=vXctqYYKJ04mmjySMdST11tWFAwPvSXHU6M7jBtD8JY,17254
+repotoire/graph/schema.py,sha256=SeTJRT7oDvyFco0ObuNWjXah6Ymc5tCGnDUwC6gP4ac,17335
 repotoire/graph/tenant_factory.py,sha256=kREcK-AFdLo_GH-RoEkIK6iIEioomTobV0YGNA7uCYs,19457
 repotoire/historical/__init__.py,sha256=wpaf5LQfeIXcV6V-hdUwWDpPPjt7hB4N46c2uWQjnRU,709
 repotoire/historical/git_graphiti.py,sha256=9RuMMhZ9_o14sfTlkXJfrHNGYRtdT0qMje_ai-6RGoE,12066
@@ -372,5 +374,5 @@ repotoire/workers/tasks.py,sha256=uqyIWg6JSEQGRBQnpDVLauja0gG7Hw9hqJ5HuVxjGLY,32
 repotoire/workers/webhook_delivery.py,sha256=RrOGyGIQakGvYKiQgAD9-eOfG1QXGQpx2ouPCZnGMJQ,17932
 repotoire/workers/webhooks.py,sha256=gpG-2N2Ik_oD1YFiPiXCysOcZY7jem3wg-o_jSgQyeo,17717
 repotoire_fast/__init__.py,sha256=kauI9ONyuAO3Opp6qD63Xkqxin9RXvZRkYRPyoLnlQU,11709
-repotoire_fast/repotoire_fast.cp314-win_amd64.pyd,sha256=KHx35WHv1dtRqiUXAoD6Li2_H7rU3UqM0ZiUZ262Is0,9132032
-repotoire-0.1.2.dist-info/RECORD,,
+repotoire_fast/repotoire_fast.cp314-win_amd64.pyd,sha256=jTI7Zj3_RZe8Yt7gkwItnCvM8RFdJBkLVlQyHyba6xU,9132032
+repotoire-0.1.3.dist-info/RECORD,,