superlocalmemory 2.7.6 → 2.8.0

package/src/graph_engine.py

@@ -1,1458 +1,52 @@
 #!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""GraphEngine - Knowledge Graph Clustering for SuperLocalMemory V2
+
+BACKWARD-COMPATIBILITY SHIM
+----------------------------
+This file re-exports every public symbol from the ``graph`` package so that
+existing code using ``from graph_engine import GraphEngine`` (or any other
+name) continues to work without modification.
+
+The actual implementation now lives in:
+    src/graph/constants.py        - Shared imports, constants, logger
+    src/graph/entity_extractor.py - EntityExtractor, ClusterNamer
+    src/graph/edge_builder.py     - EdgeBuilder
+    src/graph/cluster_builder.py  - ClusterBuilder
+    src/graph/graph_core.py       - GraphEngine, main()
 """
-GraphEngine - Knowledge Graph Clustering for SuperLocalMemory V2
-
-Copyright (c) 2026 Varun Pratap Bhardwaj
-Licensed under MIT License
-Repository: https://github.com/varun369/SuperLocalMemoryV2
-
-Implements GraphRAG with Leiden community detection to:
-- Extract entities from memories (TF-IDF keyword extraction)
-- Build similarity-based edges between memories
-- Detect thematic clusters using Leiden algorithm
-- Enable graph traversal for related memory discovery
-
-All processing is local - no external APIs.
-
-LIMITS:
-- MAX_MEMORIES_FOR_GRAPH: 10000 (prevents O(n²) explosion)
-- For larger datasets, use incremental updates
-"""
-
-# SECURITY: Graph build limits to prevent resource exhaustion
-MAX_MEMORIES_FOR_GRAPH = 10000
-
-import sqlite3
-import json
-import time
-import logging
-from datetime import datetime
-from pathlib import Path
-from typing import List, Dict, Optional, Tuple, Set
-from collections import Counter
-
-# Core dependencies
-try:
-    from sklearn.feature_extraction.text import TfidfVectorizer
-    from sklearn.metrics.pairwise import cosine_similarity
-    import numpy as np
-    SKLEARN_AVAILABLE = True
-except ImportError:
-    SKLEARN_AVAILABLE = False
-    raise ImportError("scikit-learn is required. Install: pip install scikit-learn")
-
-# Graph dependencies - lazy import to avoid conflicts with compression module
-IGRAPH_AVAILABLE = False
-try:
-    # Import only when needed to avoid module conflicts
-    import importlib
-    ig_module = importlib.import_module('igraph')
-    leiden_module = importlib.import_module('leidenalg')
-    IGRAPH_AVAILABLE = True
-except ImportError:
-    pass  # Will raise error when building clusters if not available
-
-# Setup logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+# Re-export everything from the graph package
+from graph import (
+    # Constants
+    MAX_MEMORIES_FOR_GRAPH,
+    SKLEARN_AVAILABLE,
+    IGRAPH_AVAILABLE,
+    MEMORY_DIR,
+    DB_PATH,
+    # Classes
+    EntityExtractor,
+    ClusterNamer,
+    EdgeBuilder,
+    ClusterBuilder,
+    GraphEngine,
+    # Functions
+    main,
 )
-logger = logging.getLogger(__name__)
-
-MEMORY_DIR = Path.home() / ".claude-memory"
-DB_PATH = MEMORY_DIR / "memory.db"
-
-
-class EntityExtractor:
-    """Extract key entities/concepts from memory content using TF-IDF."""
-
-    def __init__(self, max_features: int = 20, min_df: int = 1):
-        """
-        Initialize entity extractor.
-
-        Args:
-            max_features: Top N keywords to extract per memory
-            min_df: Minimum document frequency (ignore very rare terms)
-        """
-        self.max_features = max_features
-        self.vectorizer = TfidfVectorizer(
-            max_features=max_features,
-            stop_words='english',
-            ngram_range=(1, 2),  # Unigrams + bigrams
-            min_df=min_df,
-            lowercase=True,
-            token_pattern=r'(?u)\b[a-zA-Z][a-zA-Z0-9_-]*\b'  # Alphanumeric tokens
-        )
-
-    def extract_entities(self, contents: List[str]) -> Tuple[List[List[str]], np.ndarray]:
-        """
-        Extract entities from multiple contents.
-
-        Args:
-            contents: List of memory content strings
-
-        Returns:
-            Tuple of (entities_per_content, tfidf_vectors)
-        """
-        if not contents:
-            return [], np.array([])
-
-        try:
-            # Fit and transform all contents
-            vectors = self.vectorizer.fit_transform(contents)
-            feature_names = self.vectorizer.get_feature_names_out()
-
-            # Extract top entities for each content
-            all_entities = []
-            for idx in range(len(contents)):
-                scores = vectors[idx].toarray()[0]
-
-                # Get indices of top features
-                top_indices = np.argsort(scores)[::-1]
-
-                # Extract entities with score > 0
-                entities = [
-                    feature_names[i]
-                    for i in top_indices
-                    if scores[i] > 0.05  # Minimum threshold
-                ][:self.max_features]
-
-                all_entities.append(entities)
-
-            return all_entities, vectors.toarray()
-
-        except Exception as e:
-            logger.error(f"Entity extraction failed: {e}")
-            return [[] for _ in contents], np.zeros((len(contents), 1))
-
-
-class EdgeBuilder:
-    """Build similarity edges between memories based on entity overlap."""
-
-    def __init__(self, db_path: Path, min_similarity: float = 0.3):
-        """
-        Initialize edge builder.
-
-        Args:
-            db_path: Path to SQLite database
-            min_similarity: Minimum cosine similarity to create edge
-        """
-        self.db_path = db_path
-        self.min_similarity = min_similarity
-
-    def build_edges(self, memory_ids: List[int], vectors: np.ndarray,
-                   entities_list: List[List[str]]) -> int:
-        """
-        Build edges between similar memories.
-
-        Args:
-            memory_ids: List of memory IDs
-            vectors: TF-IDF vectors (n x features)
-            entities_list: List of entity lists per memory
-
-        Returns:
-            Number of edges created
-        """
-        if len(memory_ids) < 2:
-            logger.warning("Need at least 2 memories to build edges")
-            return 0
-
-        # Try HNSW-accelerated edge building first (O(n log n))
-        use_hnsw = False
-        try:
-            from hnsw_index import HNSWIndex
-            if len(memory_ids) >= 50:  # HNSW overhead not worth it for small sets
-                use_hnsw = True
-        except ImportError:
-            pass
-
-        edges_added = 0
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        try:
-            if use_hnsw:
-                logger.info("Using HNSW-accelerated edge building for %d memories", len(memory_ids))
-                try:
-                    dim = vectors.shape[1]
-                    hnsw = HNSWIndex(dimension=dim, max_elements=len(memory_ids))
-                    hnsw.build(vectors, memory_ids)
-
-                    for i in range(len(memory_ids)):
-                        neighbors = hnsw.search(vectors[i], k=min(20, len(memory_ids) - 1))
-                        for neighbor_id, similarity in neighbors:
-                            if neighbor_id == memory_ids[i]:
-                                continue  # Skip self
-                            # Only process each pair once (lower ID first)
-                            if memory_ids[i] > neighbor_id:
-                                continue
-                            if similarity >= self.min_similarity:
-                                # Find indices for entity lookup
-                                j = memory_ids.index(neighbor_id)
-                                entities_i = set(entities_list[i])
-                                entities_j = set(entities_list[j])
-                                shared = list(entities_i & entities_j)
-                                rel_type = self._classify_relationship(similarity, shared)
-
-                                cursor.execute('''
-                                    INSERT OR REPLACE INTO graph_edges
-                                    (source_memory_id, target_memory_id, relationship_type,
-                                     weight, shared_entities, similarity_score)
-                                    VALUES (?, ?, ?, ?, ?, ?)
-                                ''', (
-                                    memory_ids[i], neighbor_id, rel_type,
-                                    float(similarity), json.dumps(shared), float(similarity)
-                                ))
-                                edges_added += 1
-
-                except Exception as e:
-                    logger.warning("HNSW edge building failed, falling back to O(n²): %s", e)
-                    use_hnsw = False  # Fall through to O(n²) below
-
-            if not use_hnsw:
-                # Fallback: O(n²) pairwise cosine similarity
-                similarity_matrix = cosine_similarity(vectors)
-
-                for i in range(len(memory_ids)):
-                    for j in range(i + 1, len(memory_ids)):
-                        sim = similarity_matrix[i, j]
-
-                        if sim >= self.min_similarity:
-                            entities_i = set(entities_list[i])
-                            entities_j = set(entities_list[j])
-                            shared = list(entities_i & entities_j)
-                            rel_type = self._classify_relationship(sim, shared)
-
-                            cursor.execute('''
-                                INSERT OR REPLACE INTO graph_edges
-                                (source_memory_id, target_memory_id, relationship_type,
-                                 weight, shared_entities, similarity_score)
-                                VALUES (?, ?, ?, ?, ?, ?)
-                            ''', (
-                                memory_ids[i], memory_ids[j], rel_type,
-                                float(sim), json.dumps(shared), float(sim)
-                            ))
-                            edges_added += 1
-
-            conn.commit()
-            logger.info(f"Created {edges_added} edges")
-            return edges_added
-
-        except Exception as e:
-            logger.error(f"Edge building failed: {e}")
-            conn.rollback()
-            return 0
-        finally:
-            conn.close()
-
-    def _classify_relationship(self, similarity: float, shared_entities: List[str]) -> str:
-        """
-        Classify edge type based on similarity and shared entities.
-
-        Args:
-            similarity: Cosine similarity score
-            shared_entities: List of shared entity strings
-
-        Returns:
-            Relationship type: 'similar', 'depends_on', or 'related_to'
-        """
-        # Check for dependency keywords
-        dependency_keywords = {'dependency', 'require', 'import', 'use', 'need'}
-        has_dependency = any(
-            any(kw in entity.lower() for kw in dependency_keywords)
-            for entity in shared_entities
-        )
-
-        if similarity > 0.7:
-            return 'similar'
-        elif has_dependency:
-            return 'depends_on'
-        else:
-            return 'related_to'
-
-
-class ClusterBuilder:
-    """Detect memory communities using Leiden algorithm."""
-
-    def __init__(self, db_path: Path):
-        """Initialize cluster builder."""
-        self.db_path = db_path
-
-    def _get_active_profile(self) -> str:
-        """Get the currently active profile name from config."""
-        config_file = MEMORY_DIR / "profiles.json"
-        if config_file.exists():
-            try:
-                with open(config_file, 'r') as f:
-                    config = json.load(f)
-                return config.get('active_profile', 'default')
-            except (json.JSONDecodeError, IOError):
-                pass
-        return 'default'
-
-    def detect_communities(self) -> int:
-        """
-        Run Leiden algorithm to find memory clusters (active profile only).
-
-        Returns:
-            Number of clusters created
-        """
-        if not IGRAPH_AVAILABLE:
-            logger.warning("igraph/leidenalg not installed. Graph clustering disabled. Install with: pip3 install python-igraph leidenalg")
-            return 0
-        import igraph as ig
-        import leidenalg
-
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        active_profile = self._get_active_profile()
-
-        try:
-            # Load edges for active profile's memories only
-            edges = cursor.execute('''
-                SELECT ge.source_memory_id, ge.target_memory_id, ge.weight
-                FROM graph_edges ge
-                WHERE ge.source_memory_id IN (SELECT id FROM memories WHERE profile = ?)
-                  AND ge.target_memory_id IN (SELECT id FROM memories WHERE profile = ?)
-            ''', (active_profile, active_profile)).fetchall()
-
-            if not edges:
-                logger.warning("No edges found - cannot build clusters")
-                return 0
-
-            # Build memory ID mapping
-            memory_ids = set()
-            for source, target, _ in edges:
-                memory_ids.add(source)
-                memory_ids.add(target)
-
-            memory_ids = sorted(list(memory_ids))
-            memory_id_to_vertex = {mid: idx for idx, mid in enumerate(memory_ids)}
-            vertex_to_memory_id = {idx: mid for mid, idx in memory_id_to_vertex.items()}
-
-            # Create igraph graph
-            g = ig.Graph()
-            g.add_vertices(len(memory_ids))
-
-            # Add edges with weights
-            edge_list = []
-            edge_weights = []
-
-            for source, target, weight in edges:
-                edge_list.append((
-                    memory_id_to_vertex[source],
-                    memory_id_to_vertex[target]
-                ))
-                edge_weights.append(weight)
-
-            g.add_edges(edge_list)
-
-            # Run Leiden algorithm
-            logger.info(f"Running Leiden on {len(memory_ids)} nodes, {len(edges)} edges")
-            partition = leidenalg.find_partition(
-                g,
-                leidenalg.ModularityVertexPartition,
-                weights=edge_weights,
-                n_iterations=100,
-                seed=42  # Reproducible
-            )
-
-            # Process communities
-            clusters_created = 0
-
-            for cluster_idx, community in enumerate(partition):
-                if len(community) < 2:  # Skip singleton clusters
-                    continue
-
-                # Get memory IDs in this cluster
-                cluster_memory_ids = [vertex_to_memory_id[v] for v in community]
-
-                # Calculate cluster stats
-                avg_importance = self._get_avg_importance(cursor, cluster_memory_ids)
-
-                # Auto-generate cluster name
-                cluster_name = self._generate_cluster_name(cursor, cluster_memory_ids)
-
-                # Insert cluster
-                result = cursor.execute('''
-                    INSERT INTO graph_clusters (name, member_count, avg_importance)
-                    VALUES (?, ?, ?)
-                ''', (cluster_name, len(cluster_memory_ids), avg_importance))
-
-                cluster_id = result.lastrowid
-
-                # Update memories with cluster_id
-                cursor.executemany('''
-                    UPDATE memories SET cluster_id = ? WHERE id = ?
-                ''', [(cluster_id, mid) for mid in cluster_memory_ids])
-
-                clusters_created += 1
-                logger.info(f"Cluster {cluster_id}: '{cluster_name}' ({len(cluster_memory_ids)} members)")
-
-            conn.commit()
-            logger.info(f"Created {clusters_created} clusters")
-            return clusters_created
-
-        except Exception as e:
-            logger.error(f"Community detection failed: {e}")
-            conn.rollback()
-            return 0
-        finally:
-            conn.close()
-
-    def _get_avg_importance(self, cursor, memory_ids: List[int]) -> float:
-        """Calculate average importance for cluster."""
-        placeholders = ','.join('?' * len(memory_ids))
-        result = cursor.execute(f'''
-            SELECT AVG(importance) FROM memories WHERE id IN ({placeholders})
-        ''', memory_ids).fetchone()
-
-        return result[0] if result and result[0] else 5.0
-
-    def _generate_cluster_name(self, cursor, memory_ids: List[int]) -> str:
-        """Generate cluster name from member entities (TF-IDF approach)."""
-        # Get all entities from cluster members
-        placeholders = ','.join('?' * len(memory_ids))
-        nodes = cursor.execute(f'''
-            SELECT entities FROM graph_nodes WHERE memory_id IN ({placeholders})
-        ''', memory_ids).fetchall()
-
-        all_entities = []
-        for node in nodes:
-            if node[0]:
-                all_entities.extend(json.loads(node[0]))
-
-        if not all_entities:
-            return f"Cluster (ID auto-assigned)"
-
-        # Count entity frequencies
-        entity_counts = Counter(all_entities)
-
-        # Top 2-3 most common entities
-        top_entities = [e for e, _ in entity_counts.most_common(3)]
-
-        # Build name
-        if len(top_entities) >= 2:
-            name = f"{top_entities[0].title()} & {top_entities[1].title()}"
-        elif len(top_entities) == 1:
-            name = f"{top_entities[0].title()} Contexts"
-        else:
-            name = "Mixed Contexts"
-
-        return name[:100]  # Limit length
-
-
-    def hierarchical_cluster(self, min_subcluster_size: int = 5, max_depth: int = 3) -> Dict[str, any]:
-        """
-        Run recursive Leiden clustering — cluster the clusters.
-
-        Large communities (>= min_subcluster_size * 2) are recursively sub-clustered
-        to reveal finer-grained thematic structure. E.g., "Python" → "FastAPI" → "Auth".
-
-        Args:
-            min_subcluster_size: Minimum members to attempt sub-clustering (default 5)
-            max_depth: Maximum recursion depth (default 3)
-
-        Returns:
-            Dictionary with hierarchical clustering statistics
-        """
-        if not IGRAPH_AVAILABLE:
-            logger.warning("igraph/leidenalg not installed. Hierarchical clustering disabled. Install with: pip3 install python-igraph leidenalg")
-            return {'subclusters_created': 0, 'depth_reached': 0}
-        import igraph as ig
-        import leidenalg
-
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        active_profile = self._get_active_profile()
-
-        try:
-            # Get top-level clusters for this profile that are large enough to sub-cluster
-            cursor.execute('''
-                SELECT cluster_id, COUNT(*) as cnt
-                FROM memories
-                WHERE cluster_id IS NOT NULL AND profile = ?
-                GROUP BY cluster_id
-                HAVING cnt >= ?
-            ''', (active_profile, min_subcluster_size * 2))
-            large_clusters = cursor.fetchall()
-
-            if not large_clusters:
-                logger.info("No clusters large enough for hierarchical decomposition")
-                return {'subclusters_created': 0, 'depth_reached': 0}
-
-            total_subclusters = 0
-            max_depth_reached = 0
-
-            for parent_cid, member_count in large_clusters:
-                subs, depth = self._recursive_subcluster(
-                    conn, cursor, parent_cid, active_profile,
-                    min_subcluster_size, max_depth, current_depth=1
-                )
-                total_subclusters += subs
-                max_depth_reached = max(max_depth_reached, depth)
-
-            conn.commit()
-            logger.info(f"Hierarchical clustering: {total_subclusters} sub-clusters, depth {max_depth_reached}")
-            return {
-                'subclusters_created': total_subclusters,
-                'depth_reached': max_depth_reached,
-                'parent_clusters_processed': len(large_clusters)
-            }
-
-        except Exception as e:
-            logger.error(f"Hierarchical clustering failed: {e}")
-            conn.rollback()
-            return {'subclusters_created': 0, 'error': str(e)}
-        finally:
-            conn.close()
-
-    def _recursive_subcluster(self, conn, cursor, parent_cluster_id: int,
-                               profile: str, min_size: int, max_depth: int,
-                               current_depth: int) -> Tuple[int, int]:
-        """Recursively sub-cluster a community using Leiden."""
-        if not IGRAPH_AVAILABLE:
-            return 0, current_depth - 1
-        import igraph as ig
-        import leidenalg
-
-        if current_depth > max_depth:
-            return 0, current_depth - 1
-
-        # Get memory IDs in this cluster
-        cursor.execute('''
-            SELECT id FROM memories
-            WHERE cluster_id = ? AND profile = ?
-        ''', (parent_cluster_id, profile))
-        member_ids = [row[0] for row in cursor.fetchall()]
-
-        if len(member_ids) < min_size * 2:
-            return 0, current_depth - 1
-
-        # Get edges between members of this cluster
-        placeholders = ','.join('?' * len(member_ids))
-        edges = cursor.execute(f'''
-            SELECT source_memory_id, target_memory_id, weight
-            FROM graph_edges
-            WHERE source_memory_id IN ({placeholders})
-              AND target_memory_id IN ({placeholders})
-        ''', member_ids + member_ids).fetchall()
-
-        if len(edges) < 2:
-            return 0, current_depth - 1
-
-        # Build sub-graph
-        id_to_vertex = {mid: idx for idx, mid in enumerate(member_ids)}
-        vertex_to_id = {idx: mid for mid, idx in id_to_vertex.items()}
-
-        g = ig.Graph()
-        g.add_vertices(len(member_ids))
-        edge_list, edge_weights = [], []
-        for src, tgt, w in edges:
-            if src in id_to_vertex and tgt in id_to_vertex:
-                edge_list.append((id_to_vertex[src], id_to_vertex[tgt]))
-                edge_weights.append(w)
-
-        if not edge_list:
-            return 0, current_depth - 1
-
-        g.add_edges(edge_list)
-
-        # Run Leiden with higher resolution for finer communities
-        partition = leidenalg.find_partition(
-            g, leidenalg.ModularityVertexPartition,
-            weights=edge_weights, n_iterations=100, seed=42
-        )
-
-        # Only proceed if Leiden found > 1 community (actual split)
-        non_singleton = [c for c in partition if len(c) >= 2]
-        if len(non_singleton) <= 1:
-            return 0, current_depth - 1
-
-        subclusters_created = 0
-        deepest = current_depth
-
-        # Get parent depth
-        cursor.execute('SELECT depth FROM graph_clusters WHERE id = ?', (parent_cluster_id,))
-        parent_row = cursor.fetchone()
-        parent_depth = parent_row[0] if parent_row else 0
-
-        for community in non_singleton:
-            sub_member_ids = [vertex_to_id[v] for v in community]
-
-            if len(sub_member_ids) < 2:
-                continue
-
-            avg_imp = self._get_avg_importance(cursor, sub_member_ids)
-            cluster_name = self._generate_cluster_name(cursor, sub_member_ids)
-
-            result = cursor.execute('''
-                INSERT INTO graph_clusters (name, member_count, avg_importance, parent_cluster_id, depth)
-                VALUES (?, ?, ?, ?, ?)
-            ''', (cluster_name, len(sub_member_ids), avg_imp, parent_cluster_id, parent_depth + 1))
-
-            sub_cluster_id = result.lastrowid
-
-            # Update memories to point to sub-cluster
-            cursor.executemany('''
-                UPDATE memories SET cluster_id = ? WHERE id = ?
-            ''', [(sub_cluster_id, mid) for mid in sub_member_ids])
-
-            subclusters_created += 1
-            logger.info(f"Sub-cluster {sub_cluster_id} under {parent_cluster_id}: "
-                        f"'{cluster_name}' ({len(sub_member_ids)} members, depth {parent_depth + 1})")
-
-            # Recurse into this sub-cluster if large enough
-            child_subs, child_depth = self._recursive_subcluster(
-                conn, cursor, sub_cluster_id, profile,
-                min_size, max_depth, current_depth + 1
-            )
-            subclusters_created += child_subs
-            deepest = max(deepest, child_depth)
-
-        return subclusters_created, deepest
-
-    def generate_cluster_summaries(self) -> int:
-        """
-        Generate TF-IDF structured summaries for all clusters.
-
-        For each cluster, analyzes member content to produce a human-readable
-        summary describing the cluster's theme, key topics, and scope.
-
-        Returns:
-            Number of clusters with summaries generated
-        """
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        active_profile = self._get_active_profile()
-
-        try:
-            # Get all clusters for this profile
-            cursor.execute('''
-                SELECT DISTINCT gc.id, gc.name, gc.member_count
-                FROM graph_clusters gc
-                JOIN memories m ON m.cluster_id = gc.id
-                WHERE m.profile = ?
-            ''', (active_profile,))
-            clusters = cursor.fetchall()
-
-            if not clusters:
-                return 0
-
-            summaries_generated = 0
-
-            for cluster_id, cluster_name, member_count in clusters:
-                summary = self._build_cluster_summary(cursor, cluster_id, active_profile)
-                if summary:
-                    cursor.execute('''
-                        UPDATE graph_clusters SET summary = ?, updated_at = CURRENT_TIMESTAMP
-                        WHERE id = ?
-                    ''', (summary, cluster_id))
-                    summaries_generated += 1
-                    logger.info(f"Summary for cluster {cluster_id} ({cluster_name}): {summary[:80]}...")
-
-            conn.commit()
-            logger.info(f"Generated {summaries_generated} cluster summaries")
-            return summaries_generated
-
-        except Exception as e:
-            logger.error(f"Summary generation failed: {e}")
-            conn.rollback()
-            return 0
-        finally:
-            conn.close()
-
-    def _build_cluster_summary(self, cursor, cluster_id: int, profile: str) -> str:
-        """Build a TF-IDF structured summary for a single cluster."""
-        # Get member content
-        cursor.execute('''
-            SELECT m.content, m.summary, m.tags, m.category, m.project_name
-            FROM memories m
-            WHERE m.cluster_id = ? AND m.profile = ?
-        ''', (cluster_id, profile))
-        members = cursor.fetchall()
-
-        if not members:
-            return ""
-
-        # Collect entities from graph nodes
-        cursor.execute('''
-            SELECT gn.entities
-            FROM graph_nodes gn
-            JOIN memories m ON gn.memory_id = m.id
-            WHERE m.cluster_id = ? AND m.profile = ?
-        ''', (cluster_id, profile))
-        all_entities = []
-        for row in cursor.fetchall():
-            if row[0]:
-                try:
-                    all_entities.extend(json.loads(row[0]))
-                except (json.JSONDecodeError, TypeError):
-                    pass
-
-        # Top entities by frequency (TF-IDF already extracted these)
-        entity_counts = Counter(all_entities)
-        top_entities = [e for e, _ in entity_counts.most_common(5)]
-
-        # Collect unique projects and categories
-        projects = set()
-        categories = set()
-        for m in members:
-            if m[3]:  # category
-                categories.add(m[3])
-            if m[4]:  # project_name
-                projects.add(m[4])
-
-        # Build structured summary
-        parts = []
-
-        # Theme from top entities
-        if top_entities:
-            parts.append(f"Key topics: {', '.join(top_entities[:5])}")
-
-        # Scope
-        if projects:
-            parts.append(f"Projects: {', '.join(sorted(projects)[:3])}")
-        if categories:
-            parts.append(f"Categories: {', '.join(sorted(categories)[:3])}")
-
-        # Size context
-        parts.append(f"{len(members)} memories")
-
-        # Check for hierarchical context
-        cursor.execute('SELECT parent_cluster_id FROM graph_clusters WHERE id = ?', (cluster_id,))
-        parent_row = cursor.fetchone()
-        if parent_row and parent_row[0]:
-            cursor.execute('SELECT name FROM graph_clusters WHERE id = ?', (parent_row[0],))
-            parent_name_row = cursor.fetchone()
-            if parent_name_row:
-                parts.append(f"Sub-cluster of: {parent_name_row[0]}")
-
-        return " | ".join(parts)
-
-
-class ClusterNamer:
-    """Enhanced cluster naming with optional LLM support (future)."""
-
-    @staticmethod
-    def generate_name_tfidf(entities: List[str]) -> str:
-        """Generate name from entity list (TF-IDF fallback)."""
-        if not entities:
-            return "Unnamed Cluster"
-
-        entity_counts = Counter(entities)
-        top_entities = [e for e, _ in entity_counts.most_common(2)]
-
-        if len(top_entities) >= 2:
-            return f"{top_entities[0].title()} & {top_entities[1].title()}"
-        else:
-            return f"{top_entities[0].title()} Contexts"
-
-
-class GraphEngine:
-    """Main graph engine coordinating all graph operations."""
-
-    def __init__(self, db_path: Path = DB_PATH):
-        """Initialize graph engine."""
-        self.db_path = db_path
-        self.entity_extractor = EntityExtractor(max_features=20)
-        self.edge_builder = EdgeBuilder(db_path)
-        self.cluster_builder = ClusterBuilder(db_path)
-        self._ensure_graph_tables()
-
-    def _get_active_profile(self) -> str:
-        """Get the currently active profile name from config."""
-        config_file = MEMORY_DIR / "profiles.json"
-        if config_file.exists():
-            try:
-                with open(config_file, 'r') as f:
-                    config = json.load(f)
-                return config.get('active_profile', 'default')
-            except (json.JSONDecodeError, IOError):
-                pass
-        return 'default'
-
-    def _ensure_graph_tables(self):
-        """Create graph tables if they don't exist, or recreate if schema is incomplete."""
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        # Check if existing tables have correct schema (not just id column)
-        for table_name, required_cols in [
-            ('graph_nodes', {'memory_id', 'entities'}),
-            ('graph_edges', {'source_memory_id', 'target_memory_id', 'weight'}),
-            ('graph_clusters', {'name', 'member_count'}),
-        ]:
-            cursor.execute(f"PRAGMA table_info({table_name})")
-            existing_cols = {row[1] for row in cursor.fetchall()}
-            if existing_cols and not required_cols.issubset(existing_cols):
-                # Table exists but has incomplete schema — drop and recreate
-                logger.warning(f"Dropping incomplete {table_name} table (missing: {required_cols - existing_cols})")
-                cursor.execute(f'DROP TABLE IF EXISTS {table_name}')
-
-        # Graph nodes table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS graph_nodes (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                memory_id INTEGER UNIQUE NOT NULL,
-                entities TEXT,
-                embedding_vector TEXT,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
-            )
-        ''')
-
-        # Graph edges table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS graph_edges (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                source_memory_id INTEGER NOT NULL,
-                target_memory_id INTEGER NOT NULL,
-                relationship_type TEXT,
-                weight REAL DEFAULT 1.0,
-                shared_entities TEXT,
-                similarity_score REAL,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (source_memory_id) REFERENCES memories(id) ON DELETE CASCADE,
-                FOREIGN KEY (target_memory_id) REFERENCES memories(id) ON DELETE CASCADE,
-                UNIQUE(source_memory_id, target_memory_id)
-            )
-        ''')
-
-        # Graph clusters table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS graph_clusters (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                name TEXT NOT NULL,
-                description TEXT,
-                summary TEXT,
-                member_count INTEGER DEFAULT 0,
-                avg_importance REAL,
-                parent_cluster_id INTEGER,
-                depth INTEGER DEFAULT 0,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (parent_cluster_id) REFERENCES graph_clusters(id) ON DELETE SET NULL
-            )
-        ''')
-
-        # Safe column additions for existing databases
-        for col, col_type in [('summary', 'TEXT'), ('parent_cluster_id', 'INTEGER'), ('depth', 'INTEGER DEFAULT 0')]:
-            try:
-                cursor.execute(f'ALTER TABLE graph_clusters ADD COLUMN {col} {col_type}')
-            except sqlite3.OperationalError:
-                pass
-
-        # Add cluster_id to memories if not exists
-        try:
-            cursor.execute('ALTER TABLE memories ADD COLUMN cluster_id INTEGER')
-        except sqlite3.OperationalError:
-            pass  # Column already exists
-
-        # Create indexes
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_graph_source ON graph_edges(source_memory_id)')
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_graph_target ON graph_edges(target_memory_id)')
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_cluster_members ON memories(cluster_id)')
-
-        conn.commit()
-        conn.close()
-        logger.info("Graph tables initialized")
-
-    def build_graph(self, min_similarity: float = 0.3) -> Dict[str, any]:
-        """
-        Build complete knowledge graph from all memories.
-
-        Args:
-            min_similarity: Minimum cosine similarity for edge creation
-
-        Returns:
-            Dictionary with build statistics
-
-        Raises:
-            ValueError: If too many memories (>10000) for safe processing
-        """
-        start_time = time.time()
-        logger.info("Starting full graph build...")
-
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        try:
-            # First check if required tables exist
-            cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
-            existing_tables = {row[0] for row in cursor.fetchall()}
-
-            required_tables = {'memories', 'graph_edges', 'graph_nodes', 'graph_clusters'}
-            missing_tables = required_tables - existing_tables
-
-            if missing_tables:
-                logger.error(f"Missing required tables: {missing_tables}")
-                return {
-                    'success': False,
-                    'error': 'database_not_initialized',
-                    'message': f"Database not initialized. Missing tables: {', '.join(missing_tables)}",
-                    'fix': "Run 'superlocalmemoryv2:status' first to initialize the database, or add some memories."
-                }
-
-            # Load memories for active profile only
-            active_profile = self._get_active_profile()
-            logger.info(f"Building graph for profile: {active_profile}")
-            memories = cursor.execute('''
-                SELECT id, content, summary FROM memories
-                WHERE profile = ?
-                ORDER BY id
-            ''', (active_profile,)).fetchall()
-
-            if len(memories) == 0:
-                logger.warning("No memories found")
-                return {
-                    'success': False,
-                    'error': 'no_memories',
-                    'message': 'No memories found in database.',
-                    'fix': "Add some memories first: superlocalmemoryv2:remember 'Your content here'"
-                }
-
-            if len(memories) < 2:
-                logger.warning("Need at least 2 memories to build graph")
-                return {
-                    'success': False,
-                    'error': 'insufficient_memories',
-                    'message': 'Need at least 2 memories to build knowledge graph.',
-                    'memories': len(memories),
-                    'fix': "Add more memories: superlocalmemoryv2:remember 'Your content here'"
-                }
-
-            # SCALABILITY: Intelligent sampling for large datasets (v2.6)
-            if len(memories) > MAX_MEMORIES_FOR_GRAPH:
-                logger.warning(
-                    "Memory count (%d) exceeds graph cap (%d). Using intelligent sampling.",
-                    len(memories), MAX_MEMORIES_FOR_GRAPH
-                )
-                # Sample: 60% most recent + 40% highest importance (with overlap dedup)
-                recent_count = int(MAX_MEMORIES_FOR_GRAPH * 0.6)
-                important_count = int(MAX_MEMORIES_FOR_GRAPH * 0.4)
-
-                recent_memories = cursor.execute('''
-                    SELECT id, content, summary FROM memories
-                    WHERE profile = ?
-                    ORDER BY created_at DESC
-                    LIMIT ?
-                ''', (active_profile, recent_count)).fetchall()
-
-                important_memories = cursor.execute('''
-                    SELECT id, content, summary FROM memories
-                    WHERE profile = ?
-                    ORDER BY importance DESC, access_count DESC
-                    LIMIT ?
-                ''', (active_profile, important_count)).fetchall()
-
-                # Deduplicate by ID, preserving order
-                seen_ids = set()
-                memories = []
-                for m in recent_memories + important_memories:
-                    if m[0] not in seen_ids:
-                        seen_ids.add(m[0])
-                        memories.append(m)
-                memories = memories[:MAX_MEMORIES_FOR_GRAPH]
-                logger.info("Sampled %d memories for graph build", len(memories))
-
-            elif len(memories) > MAX_MEMORIES_FOR_GRAPH * 0.8:
-                logger.warning(
-                    "Approaching graph cap: %d/%d memories (%.0f%%). "
-                    "Consider running memory compression.",
-                    len(memories), MAX_MEMORIES_FOR_GRAPH,
-                    len(memories) / MAX_MEMORIES_FOR_GRAPH * 100
-                )
-
-            # Clear existing graph data for this profile's memories
-            profile_memory_ids = [m[0] for m in memories]
-            if profile_memory_ids:
-                placeholders = ','.join('?' * len(profile_memory_ids))
-                cursor.execute(f'''
-                    DELETE FROM graph_edges
-                    WHERE source_memory_id IN ({placeholders})
-                       OR target_memory_id IN ({placeholders})
-                ''', profile_memory_ids + profile_memory_ids)
-                cursor.execute(f'''
-                    DELETE FROM graph_nodes
-                    WHERE memory_id IN ({placeholders})
-                ''', profile_memory_ids)
-            # Remove orphaned clusters (no remaining members)
-            cursor.execute('''
-                DELETE FROM graph_clusters
-                WHERE id NOT IN (
-                    SELECT DISTINCT cluster_id FROM memories
-                    WHERE cluster_id IS NOT NULL
-                )
-            ''')
-            cursor.execute('UPDATE memories SET cluster_id = NULL WHERE profile = ?',
-                          (active_profile,))
-            conn.commit()
-
-            logger.info(f"Processing {len(memories)} memories")
-
-            # Extract entities and vectors
-            memory_ids = [m[0] for m in memories]
-            contents = [f"{m[1]} {m[2] or ''}" for m in memories]  # Combine content + summary
-
-            entities_list, vectors = self.entity_extractor.extract_entities(contents)
-
-            # Store nodes
-            for memory_id, entities, vector in zip(memory_ids, entities_list, vectors):
-                cursor.execute('''
-                    INSERT INTO graph_nodes (memory_id, entities, embedding_vector)
-                    VALUES (?, ?, ?)
-                ''', (
-                    memory_id,
-                    json.dumps(entities),
-                    json.dumps(vector.tolist())
-                ))
-
-            conn.commit()
-            logger.info(f"Stored {len(memory_ids)} graph nodes")
-
-            # Build edges
-            edges_count = self.edge_builder.build_edges(
-                memory_ids, vectors, entities_list
-            )
-
-            # Detect communities (flat Leiden)
-            clusters_count = self.cluster_builder.detect_communities()
-
-            # Hierarchical sub-clustering on large communities
-            hierarchical_stats = self.cluster_builder.hierarchical_cluster()
-            subclusters = hierarchical_stats.get('subclusters_created', 0)
-
-            # Generate TF-IDF structured summaries for all clusters
-            summaries = self.cluster_builder.generate_cluster_summaries()
-
-            elapsed = time.time() - start_time
-
-            stats = {
-                'success': True,
-                'memories': len(memories),
-                'nodes': len(memory_ids),
-                'edges': edges_count,
-                'clusters': clusters_count,
-                'subclusters': subclusters,
-                'max_depth': hierarchical_stats.get('depth_reached', 0),
-                'summaries_generated': summaries,
-                'time_seconds': round(elapsed, 2)
-            }
-            if not IGRAPH_AVAILABLE:
-                stats['warning'] = 'igraph/leidenalg not installed — graph built without clustering. Install with: pip3 install python-igraph leidenalg'
-
-
-            logger.info(f"Graph build complete: {stats}")
-            return stats
-
-        except Exception as e:
-            logger.error(f"Graph build failed: {e}")
-            conn.rollback()
-            return {
-                'success': False,
-                'error': str(e)
-            }
-        finally:
-            conn.close()
-
-    def extract_entities(self, memory_id: int) -> List[str]:
-        """
-        Extract entities for a single memory.
-
-        Args:
-            memory_id: Memory ID
-
-        Returns:
-            List of entity strings
-        """
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        try:
-            # Get memory content
-            memory = cursor.execute('''
-                SELECT content, summary FROM memories WHERE id = ?
-            ''', (memory_id,)).fetchone()
-
-            if not memory:
-                return []
-
-            content = f"{memory[0]} {memory[1] or ''}"
-            entities_list, _ = self.entity_extractor.extract_entities([content])
-
-            return entities_list[0] if entities_list else []
-
-        finally:
-            conn.close()
-
-    def get_related(self, memory_id: int, max_hops: int = 2) -> List[Dict]:
-        """
-        Get memories connected to this memory via graph edges (active profile only).
-
-        Args:
-            memory_id: Source memory ID
-            max_hops: Maximum traversal depth (1 or 2)
-
-        Returns:
-            List of related memory dictionaries
-        """
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        active_profile = self._get_active_profile()
-
-        try:
-            # Get 1-hop neighbors (filtered to active profile)
-            edges = cursor.execute('''
-                SELECT ge.target_memory_id, ge.relationship_type, ge.weight, ge.shared_entities
-                FROM graph_edges ge
-                JOIN memories m ON ge.target_memory_id = m.id
-                WHERE ge.source_memory_id = ? AND m.profile = ?
-                UNION
-                SELECT ge.source_memory_id, ge.relationship_type, ge.weight, ge.shared_entities
-                FROM graph_edges ge
-                JOIN memories m ON ge.source_memory_id = m.id
-                WHERE ge.target_memory_id = ? AND m.profile = ?
-            ''', (memory_id, active_profile, memory_id, active_profile)).fetchall()
-
-            results = []
-            seen_ids = {memory_id}
-
-            for target_id, rel_type, weight, shared_entities in edges:
-                if target_id in seen_ids:
-                    continue
-
-                seen_ids.add(target_id)
-
-                # Get memory details
-                memory = cursor.execute('''
-                    SELECT id, summary, importance, tags
-                    FROM memories WHERE id = ?
-                ''', (target_id,)).fetchone()
-
-                if memory:
-                    results.append({
-                        'id': memory[0],
-                        'summary': memory[1],
-                        'importance': memory[2],
-                        'tags': json.loads(memory[3]) if memory[3] else [],
-                        'relationship': rel_type,
-                        'weight': weight,
-                        'shared_entities': json.loads(shared_entities) if shared_entities else [],
-                        'hops': 1
-                    })
-
-            # If max_hops == 2, get 2-hop neighbors
-            if max_hops >= 2:
-                for result in results[:]:  # Copy to avoid modification during iteration
-                    second_hop = cursor.execute('''
-                        SELECT target_memory_id, relationship_type, weight
-                        FROM graph_edges
-                        WHERE source_memory_id = ?
-                        UNION
-                        SELECT source_memory_id, relationship_type, weight
-                        FROM graph_edges
-                        WHERE target_memory_id = ?
-                    ''', (result['id'], result['id'])).fetchall()
-
-                    for target_id, rel_type, weight in second_hop:
-                        if target_id in seen_ids:
-                            continue
-
-                        seen_ids.add(target_id)
-
-                        memory = cursor.execute('''
-                            SELECT id, summary, importance, tags
-                            FROM memories WHERE id = ?
-                        ''', (target_id,)).fetchone()
-
-                        if memory:
-                            results.append({
-                                'id': memory[0],
-                                'summary': memory[1],
-                                'importance': memory[2],
-                                'tags': json.loads(memory[3]) if memory[3] else [],
-                                'relationship': rel_type,
-                                'weight': weight,
-                                'shared_entities': [],
-                                'hops': 2
-                            })
-
-            # Sort by weight (strongest connections first)
-            results.sort(key=lambda x: (-x['hops'], -x['weight']))
-
-            return results
-
-        finally:
-            conn.close()
-
-    def get_cluster_members(self, cluster_id: int) -> List[Dict]:
-        """
-        Get all memories in a cluster (filtered by active profile).
-
-        Args:
-            cluster_id: Cluster ID
-
-        Returns:
-            List of memory dictionaries
-        """
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        active_profile = self._get_active_profile()
-
-        try:
-            memories = cursor.execute('''
-                SELECT id, summary, importance, tags, created_at
-                FROM memories
-                WHERE cluster_id = ? AND profile = ?
-                ORDER BY importance DESC
-            ''', (cluster_id, active_profile)).fetchall()
-
-            return [
-                {
-                    'id': m[0],
-                    'summary': m[1],
-                    'importance': m[2],
-                    'tags': json.loads(m[3]) if m[3] else [],
-                    'created_at': m[4]
-                }
-                for m in memories
-            ]
-
-        finally:
-            conn.close()
-
-    def add_memory_incremental(self, memory_id: int) -> bool:
-        """
-        Add single memory to existing graph (incremental update).
-
-        Args:
-            memory_id: New memory ID to add
-
-        Returns:
-            Success status
-        """
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        try:
-            # Get new memory content
-            memory = cursor.execute('''
-                SELECT content, summary FROM memories WHERE id = ?
-            ''', (memory_id,)).fetchone()
-
-            if not memory:
-                return False
-
-            # Extract entities for new memory
-            content = f"{memory[0]} {memory[1] or ''}"
-            entities_list, vector = self.entity_extractor.extract_entities([content])
-
-            if not entities_list:
-                return False
-
-            new_entities = entities_list[0]
-            new_vector = vector[0]
-
-            # Store node
-            cursor.execute('''
-                INSERT OR REPLACE INTO graph_nodes (memory_id, entities, embedding_vector)
-                VALUES (?, ?, ?)
-            ''', (memory_id, json.dumps(new_entities), json.dumps(new_vector.tolist())))
-
-            # Compare to existing memories in the same profile
-            active_profile = self._get_active_profile()
-            existing = cursor.execute('''
-                SELECT gn.memory_id, gn.embedding_vector, gn.entities
-                FROM graph_nodes gn
-                JOIN memories m ON gn.memory_id = m.id
-                WHERE gn.memory_id != ? AND m.profile = ?
-            ''', (memory_id, active_profile)).fetchall()
-
-            edges_added = 0
-
-            for existing_id, existing_vector_json, existing_entities_json in existing:
-                existing_vector = np.array(json.loads(existing_vector_json))
-
-                # Compute similarity
-                sim = cosine_similarity([new_vector], [existing_vector])[0][0]
-
-                if sim >= self.edge_builder.min_similarity:
-                    # Find shared entities
-                    existing_entities = json.loads(existing_entities_json)
-                    shared = list(set(new_entities) & set(existing_entities))
-
-                    # Classify relationship
-                    rel_type = self.edge_builder._classify_relationship(sim, shared)
-
-                    # Insert edge
-                    cursor.execute('''
-                        INSERT OR REPLACE INTO graph_edges
-                        (source_memory_id, target_memory_id, relationship_type,
-                         weight, shared_entities, similarity_score)
-                        VALUES (?, ?, ?, ?, ?, ?)
-                    ''', (
-                        memory_id,
-                        existing_id,
-                        rel_type,
-                        float(sim),
-                        json.dumps(shared),
-                        float(sim)
-                    ))
-
-                    edges_added += 1
-
-            conn.commit()
-            logger.info(f"Added memory {memory_id} to graph with {edges_added} edges")
-
-            # Optionally re-cluster if significant change
-            if edges_added > 5:
-                logger.info("Significant graph change - consider re-clustering")
-
-            return True
-
-        except Exception as e:
-            logger.error(f"Incremental add failed: {e}")
-            conn.rollback()
-            return False
-        finally:
-            conn.close()
-
-    def get_stats(self) -> Dict[str, any]:
-        """Get graph statistics for the active profile."""
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        active_profile = self._get_active_profile()
-
-        try:
-            # Count nodes for active profile's memories
-            nodes = cursor.execute('''
-                SELECT COUNT(*) FROM graph_nodes
-                WHERE memory_id IN (SELECT id FROM memories WHERE profile = ?)
-            ''', (active_profile,)).fetchone()[0]
-
-            # Count edges where at least one end is in active profile
-            edges = cursor.execute('''
-                SELECT COUNT(*) FROM graph_edges
-                WHERE source_memory_id IN (SELECT id FROM memories WHERE profile = ?)
-            ''', (active_profile,)).fetchone()[0]
-
-            # Clusters that have members in active profile
-            clusters = cursor.execute('''
-                SELECT COUNT(DISTINCT cluster_id) FROM memories
-                WHERE cluster_id IS NOT NULL AND profile = ?
-            ''', (active_profile,)).fetchone()[0]
-
-            # Cluster breakdown for active profile (including hierarchy)
-            cluster_info = cursor.execute('''
-                SELECT gc.name, gc.member_count, gc.avg_importance,
-                       gc.summary, gc.parent_cluster_id, gc.depth
-                FROM graph_clusters gc
-                WHERE gc.id IN (
-                    SELECT DISTINCT cluster_id FROM memories
-                    WHERE cluster_id IS NOT NULL AND profile = ?
-                )
-                ORDER BY gc.depth ASC, gc.member_count DESC
-                LIMIT 20
-            ''', (active_profile,)).fetchall()
-
-            # Count hierarchical depth
-            max_depth = max((c[5] or 0 for c in cluster_info), default=0) if cluster_info else 0
-
-            return {
-                'profile': active_profile,
-                'nodes': nodes,
-                'edges': edges,
-                'clusters': clusters,
-                'max_depth': max_depth,
-                'top_clusters': [
-                    {
-                        'name': c[0],
-                        'members': c[1],
-                        'avg_importance': round(c[2], 1) if c[2] else 5.0,
-                        'summary': c[3],
-                        'parent_cluster_id': c[4],
-                        'depth': c[5] or 0
-                    }
-                    for c in cluster_info
-                ]
-            }
-
-        finally:
-            conn.close()
-
-
-def main():
-    """CLI interface for manual graph operations."""
-    import argparse
-
-    parser = argparse.ArgumentParser(description='GraphEngine - Knowledge Graph Management')
-    parser.add_argument('command', choices=['build', 'stats', 'related', 'cluster', 'hierarchical', 'summaries'],
-                       help='Command to execute')
-    parser.add_argument('--memory-id', type=int, help='Memory ID for related/add commands')
-    parser.add_argument('--cluster-id', type=int, help='Cluster ID for cluster command')
-    parser.add_argument('--min-similarity', type=float, default=0.3,
-                       help='Minimum similarity for edges (default: 0.3)')
-    parser.add_argument('--hops', type=int, default=2, help='Max hops for related (default: 2)')
-
-    args = parser.parse_args()
-
-    engine = GraphEngine()
-
-    if args.command == 'build':
-        print("Building knowledge graph...")
-        stats = engine.build_graph(min_similarity=args.min_similarity)
-        print(json.dumps(stats, indent=2))
-
-    elif args.command == 'stats':
-        print("Graph Statistics:")
-        stats = engine.get_stats()
-        print(json.dumps(stats, indent=2))
-
-    elif args.command == 'related':
-        if not args.memory_id:
-            print("Error: --memory-id required for 'related' command")
-            return
-
-        print(f"Finding memories related to #{args.memory_id}...")
-        related = engine.get_related(args.memory_id, max_hops=args.hops)
-
-        if not related:
-            print("No related memories found")
-        else:
-            for idx, mem in enumerate(related, 1):
-                print(f"\n{idx}. Memory #{mem['id']} ({mem['hops']}-hop, weight={mem['weight']:.3f})")
-                print(f"   Relationship: {mem['relationship']}")
-                summary = mem['summary'] or '[No summary]'
-                print(f"   Summary: {summary[:100]}...")
-                if mem['shared_entities']:
-                    print(f"   Shared: {', '.join(mem['shared_entities'][:5])}")
-
-    elif args.command == 'cluster':
-        if not args.cluster_id:
-            print("Error: --cluster-id required for 'cluster' command")
-            return
-
-        print(f"Cluster #{args.cluster_id} members:")
-        members = engine.get_cluster_members(args.cluster_id)
-
-        for idx, mem in enumerate(members, 1):
-            print(f"\n{idx}. Memory #{mem['id']} (importance={mem['importance']})")
-            summary = mem['summary'] or '[No summary]'
-            print(f"   {summary[:100]}...")
-
-    elif args.command == 'hierarchical':
-        print("Running hierarchical sub-clustering...")
-        cluster_builder = ClusterBuilder(engine.db_path)
-        stats = cluster_builder.hierarchical_cluster()
-        print(json.dumps(stats, indent=2))
-
-    elif args.command == 'summaries':
-        print("Generating cluster summaries...")
-        cluster_builder = ClusterBuilder(engine.db_path)
-        count = cluster_builder.generate_cluster_summaries()
-        print(f"Generated summaries for {count} clusters")
 
+__all__ = [
+    "MAX_MEMORIES_FOR_GRAPH",
+    "SKLEARN_AVAILABLE",
+    "IGRAPH_AVAILABLE",
+    "MEMORY_DIR",
+    "DB_PATH",
+    "EntityExtractor",
+    "ClusterNamer",
+    "EdgeBuilder",
+    "ClusterBuilder",
+    "GraphEngine",
+    "main",
+]
 
 if __name__ == '__main__':
     main()