superlocalmemory 2.8.6 → 3.0.0

package/src/superlocalmemory/server/routes/memories.py

@@ -0,0 +1,399 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under the MIT License - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+"""SuperLocalMemory V3 - Memory Routes (MIT License).
+Routes: /api/memories, /api/graph, /api/search, /api/clusters, /api/clusters/{id}
+Uses V3 MemoryEngine for store/recall. Falls back to direct DB for list/graph.
+"""
+import json
+import logging
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException, Query, Request
+
+from .helpers import (
+    get_db_connection, dict_factory, get_active_profile,
+    SearchRequest, DB_PATH, MEMORY_DIR,
+)
+
+logger = logging.getLogger("superlocalmemory.routes.memories")
+router = APIRouter()
+
+
+def _get_engine(request: Request):
+    """Get V3 engine from app state, or None."""
+    return getattr(request.app.state, "engine", None)
+
+
+def _preview(content: str | None) -> str:
+    """Truncate content for preview display."""
+    if not content:
+        return ""
+    return content[:100] + "..." if len(content) > 100 else content
+
+
+def _has_table(cursor, name: str) -> bool:
+    """Check if a table exists in the database."""
+    try:
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name=?", (name,))
+        return cursor.fetchone() is not None
+    except Exception:
+        return False
+
+
+def _fetch_graph_data(
+    cursor, profile: str, use_v3: bool, min_importance: int, max_nodes: int,
+) -> tuple[list, list, list]:
+    """Fetch graph nodes, links, clusters from V3 or V2 schema."""
+    if use_v3:
+        cursor.execute("""
+            SELECT f.fact_id as id, f.content, f.fact_type as category,
+                   f.confidence as importance, f.session_id as project_name,
+                   f.created_at
+            FROM atomic_facts f WHERE f.profile_id = ? AND f.confidence >= ?
+            ORDER BY f.confidence DESC, f.created_at DESC LIMIT ?
+        """, (profile, min_importance / 10.0, max_nodes))
+        nodes = cursor.fetchall()
+        for n in nodes:
+            n['entities'] = []
+            n['content_preview'] = _preview(n.get('content'))
+        ids = [n['id'] for n in nodes]
+        links = _fetch_edges_v3(cursor, profile, ids)
+        return nodes, links, []
+
+    # V2 fallback
+    try:
+        cursor.execute("""
+            SELECT m.id, m.content, m.summary, m.category, m.cluster_id,
+                   m.importance, m.project_name, m.created_at, m.tags, gn.entities
+            FROM memories m LEFT JOIN graph_nodes gn ON m.id = gn.memory_id
+            WHERE m.importance >= ? AND m.profile = ?
+            ORDER BY m.importance DESC, m.updated_at DESC LIMIT ?
+        """, (min_importance, profile, max_nodes))
+    except Exception:
+        cursor.execute("""
+            SELECT id, content, summary, category, cluster_id, importance,
+                   project_name, created_at, tags, NULL as entities
+            FROM memories WHERE importance >= ? AND profile = ?
+            ORDER BY importance DESC, updated_at DESC LIMIT ?
+        """, (min_importance, profile, max_nodes))
+    nodes = cursor.fetchall()
+    for n in nodes:
+        ent = n.get('entities')
+        n['entities'] = json.loads(ent) if ent else []
+        n['content_preview'] = _preview(n.get('content'))
+    ids = [n['id'] for n in nodes]
+    links = _fetch_edges_v2(cursor, ids)
+    try:
+        cursor.execute("""
+            SELECT cluster_id, COUNT(*) as size, AVG(importance) as avg_importance
+            FROM memories WHERE cluster_id IS NOT NULL AND profile = ?
+            GROUP BY cluster_id
+        """, (profile,))
+        clusters = cursor.fetchall()
+    except Exception:
+        clusters = []
+    return nodes, links, clusters
+
+
+def _fetch_edges_v3(cursor, profile: str, fact_ids: list) -> list:
+    if not fact_ids:
+        return []
+    ph = ','.join('?' * len(fact_ids))
+    try:
+        cursor.execute(f"""
+            SELECT source_id as source, target_id as target,
+                   weight, edge_type as relationship_type
+            FROM kg_edges WHERE profile_id = ?
+              AND source_id IN ({ph}) AND target_id IN ({ph})
+            ORDER BY weight DESC
+        """, [profile] + fact_ids + fact_ids)
+        return cursor.fetchall()
+    except Exception:
+        return []
+
+
+def _fetch_edges_v2(cursor, memory_ids: list) -> list:
+    if not memory_ids:
+        return []
+    ph = ','.join('?' * len(memory_ids))
+    try:
+        cursor.execute(f"""
+            SELECT source_memory_id as source, target_memory_id as target,
+                   weight, relationship_type, shared_entities
+            FROM graph_edges
+            WHERE source_memory_id IN ({ph}) AND target_memory_id IN ({ph})
+            ORDER BY weight DESC
+        """, memory_ids + memory_ids)
+        links = cursor.fetchall()
+        for lk in links:
+            se = lk.get('shared_entities')
+            if se:
+                try:
+                    lk['shared_entities'] = json.loads(se)
+                except Exception:
+                    lk['shared_entities'] = []
+        return links
+    except Exception:
+        return []
+
+
+@router.get("/api/memories")
+async def get_memories(
+    request: Request,
+    category: Optional[str] = None,
+    project_name: Optional[str] = None,
+    cluster_id: Optional[int] = None,
+    min_importance: Optional[int] = None,
+    tags: Optional[str] = None,
+    limit: int = Query(50, ge=1, le=200),
+    offset: int = Query(0, ge=0),
+):
+    """List memories with optional filtering and pagination."""
+    try:
+        conn = get_db_connection()
+        conn.row_factory = dict_factory
+        cursor = conn.cursor()
+        active_profile = get_active_profile()
+
+        use_v3 = _has_table(cursor, 'atomic_facts')
+
+        if use_v3:
+            query = """
+                SELECT fact_id as id, content, fact_type as category,
+                       confidence as importance, access_count,
+                       created_at, created_at as updated_at,
+                       session_id as project_name
+                FROM atomic_facts WHERE profile_id = ?
+            """
+            params = [active_profile]
+            count_base = "SELECT COUNT(*) as total FROM atomic_facts WHERE profile_id = ?"
+        else:
+            query = """
+                SELECT id, content, summary, category, project_name, project_path,
+                       importance, cluster_id, depth, access_count, parent_id,
+                       created_at, updated_at, last_accessed, tags, memory_type
+                FROM memories WHERE profile = ?
+            """
+            params = [active_profile]
+            count_base = "SELECT COUNT(*) as total FROM memories WHERE profile = ?"
+
+        count_params = [active_profile]
+
+        if category:
+            if use_v3:
+                query += " AND fact_type = ?"
+            else:
+                query += " AND category = ?"
+            params.append(category)
+            count_base += " AND category = ?" if not use_v3 else " AND fact_type = ?"
+            count_params.append(category)
+        if project_name:
+            if use_v3:
+                query += " AND session_id = ?"
+            else:
+                query += " AND project_name = ?"
+            params.append(project_name)
+            count_base += " AND project_name = ?" if not use_v3 else " AND session_id = ?"
+            count_params.append(project_name)
+        if cluster_id is not None and not use_v3:
+            query += " AND cluster_id = ?"
+            params.append(cluster_id)
+            count_base += " AND cluster_id = ?"
+            count_params.append(cluster_id)
+        if min_importance:
+            if use_v3:
+                query += " AND confidence >= ?"
+                params.append(min_importance / 10.0)
+            else:
+                query += " AND importance >= ?"
+                params.append(min_importance)
+        if tags and not use_v3:
+            tag_list = [t.strip() for t in tags.split(',')]
+            for tag in tag_list:
+                query += " AND tags LIKE ?"
+                params.append(f'%{tag}%')
+
+        query += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
+        params.extend([limit, offset])
+
+        cursor.execute(query, params)
+        memories = cursor.fetchall()
+
+        cursor.execute(count_base, count_params)
+        total = cursor.fetchone()['total']
+
+        conn.close()
+
+        return {
+            "memories": memories, "total": total,
+            "limit": limit, "offset": offset,
+            "has_more": (offset + limit) < total,
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
+
+
+@router.get("/api/graph")
+async def get_graph(
+    request: Request,
+    max_nodes: int = Query(100, ge=10, le=500),
+    min_importance: int = Query(1, ge=1, le=10),
+):
+    """Get knowledge graph data for D3.js force-directed visualization."""
+    try:
+        conn = get_db_connection()
+        conn.row_factory = dict_factory
+        cursor = conn.cursor()
+        active_profile = get_active_profile()
+
+        use_v3 = _has_table(cursor, 'kg_edges')
+
+        nodes, links, clusters = _fetch_graph_data(
+            cursor, active_profile, use_v3, min_importance, max_nodes,
+        )
+
+        conn.close()
+
+        return {
+            "nodes": nodes, "links": links, "clusters": clusters,
+            "metadata": {
+                "node_count": len(nodes), "edge_count": len(links),
+                "cluster_count": len(clusters) if clusters else 0,
+                "filters_applied": {"max_nodes": max_nodes, "min_importance": min_importance},
+            },
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Graph error: {str(e)}")
+
+
+@router.post("/api/search")
+async def search_memories(request: Request, body: SearchRequest):
+    """Semantic search using V3 engine recall or fallback."""
+    try:
+        engine = _get_engine(request)
+
+        if engine:
+            response = engine.recall(body.query, limit=body.limit)
+            results = []
+            for r in response.results:
+                score = r.score
+                if score < body.min_score:
+                    continue
+                if body.category and getattr(r.fact, 'fact_type', None) != body.category:
+                    continue
+                results.append({
+                    "id": r.fact.fact_id,
+                    "content": r.fact.content,
+                    "score": round(score, 4),
+                    "confidence": round(r.confidence, 4),
+                    "trust_score": round(r.trust_score, 4) if r.trust_score else None,
+                    "channel_scores": r.channel_scores,
+                    "fact_type": getattr(r.fact, 'fact_type', None),
+                    "created_at": getattr(r.fact, 'created_at', None),
+                })
+                if len(results) >= body.limit:
+                    break
+
+            return {
+                "query": body.query, "results": results, "total": len(results),
+                "query_type": response.query_type,
+                "retrieval_time_ms": response.retrieval_time_ms,
+            }
+
+        # Fallback: direct DB search (no V3 engine)
+        conn = get_db_connection()
+        conn.row_factory = dict_factory
+        cursor = conn.cursor()
+        active_profile = get_active_profile()
+        cursor.execute("""
+            SELECT fact_id as id, content, confidence as score,
+                   fact_type as category, created_at
+            FROM atomic_facts
+            WHERE profile_id = ? AND content LIKE ?
+            ORDER BY confidence DESC LIMIT ?
+        """, (active_profile, f'%{body.query}%', body.limit))
+        results = cursor.fetchall()
+        conn.close()
+
+        return {
+            "query": body.query, "results": results, "total": len(results),
+            "query_type": "text_search", "retrieval_time_ms": 0,
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Search error: {str(e)}")
+
+
+@router.get("/api/clusters")
+async def get_clusters(request: Request):
+    """Get cluster information with member counts and statistics."""
+    try:
+        conn = get_db_connection()
+        conn.row_factory = dict_factory
+        cursor = conn.cursor()
+        profile = get_active_profile()
+        unclustered = 0
+
+        if _has_table(cursor, 'scene_facts'):
+            cursor.execute("""
+                SELECT s.scene_id as cluster_id, COUNT(sf.fact_id) as member_count,
+                       s.summary, s.created_at as first_memory
+                FROM scenes s JOIN scene_facts sf ON s.scene_id = sf.scene_id
+                WHERE s.profile_id = ? GROUP BY s.scene_id ORDER BY member_count DESC
+            """, (profile,))
+            clusters = [dict(r, top_entities=[]) for r in cursor.fetchall()]
+        else:
+            try:
+                cursor.execute("""
+                    SELECT cluster_id, COUNT(*) as member_count,
+                           AVG(importance) as avg_importance,
+                           GROUP_CONCAT(DISTINCT category) as categories
+                    FROM memories WHERE cluster_id IS NOT NULL AND profile = ?
+                    GROUP BY cluster_id ORDER BY member_count DESC
+                """, (profile,))
+                clusters = [dict(r, top_entities=[]) for r in cursor.fetchall()]
+            except Exception:
+                clusters = []
+            cursor.execute("SELECT COUNT(*) as c FROM memories WHERE cluster_id IS NULL AND profile = ?", (profile,))
+            unclustered = cursor.fetchone()['c']
+
+        conn.close()
+        return {"clusters": clusters, "total_clusters": len(clusters), "unclustered_count": unclustered}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Cluster error: {str(e)}")
+
+
+@router.get("/api/clusters/{cluster_id}")
+async def get_cluster_detail(request: Request, cluster_id: int, limit: int = Query(50, ge=1, le=200)):
+    """Get detailed view of a specific cluster."""
+    try:
+        conn = get_db_connection()
+        conn.row_factory = dict_factory
+        cursor = conn.cursor()
+        profile = get_active_profile()
+
+        if _has_table(cursor, 'scene_facts'):
+            cursor.execute("""
+                SELECT f.fact_id as id, f.content, f.fact_type as category,
+                       f.confidence as importance, f.created_at
+                FROM atomic_facts f JOIN scene_facts sf ON f.fact_id = sf.fact_id
+                WHERE sf.scene_id = ? AND f.profile_id = ? ORDER BY f.confidence DESC LIMIT ?
+            """, (str(cluster_id), profile, limit))
+        else:
+            cursor.execute("""
+                SELECT id, content, summary, category, project_name, importance, created_at, tags
+                FROM memories WHERE cluster_id = ? AND profile = ?
+                ORDER BY importance DESC, created_at DESC LIMIT ?
+            """, (cluster_id, profile, limit))
+        members = cursor.fetchall()
+        conn.close()
+        if not members:
+            raise HTTPException(status_code=404, detail="Cluster not found")
+        return {"cluster_info": {"cluster_id": cluster_id, "total_members": len(members)}, "members": members, "connections": []}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Cluster detail error: {str(e)}")

package/src/superlocalmemory/server/routes/profiles.py

@@ -0,0 +1,219 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under the MIT License - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+"""SuperLocalMemory V3 - Profile Routes
+ - MIT License
+
+Routes: /api/profiles, /api/profiles/{name}/switch,
+        /api/profiles/create, DELETE /api/profiles/{name}
+"""
+import json
+import logging
+from datetime import datetime
+
+from fastapi import APIRouter, HTTPException
+
+from .helpers import (
+    get_db_connection, get_active_profile, validate_profile_name,
+    ProfileSwitch, MEMORY_DIR, DB_PATH,
+)
+
+logger = logging.getLogger("superlocalmemory.routes.profiles")
+router = APIRouter()
+
+# WebSocket manager reference (set by ui_server.py at startup)
+ws_manager = None
+
+
+def _load_profiles_config() -> dict:
+    """Load profiles.json config."""
+    config_file = MEMORY_DIR / "profiles.json"
+    if config_file.exists():
+        try:
+            with open(config_file, 'r') as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            pass
+    return {
+        'profiles': {'default': {'name': 'default', 'description': 'Default memory profile'}},
+        'active_profile': 'default',
+    }
+
+
+def _save_profiles_config(config: dict) -> None:
+    """Save profiles.json config."""
+    MEMORY_DIR.mkdir(parents=True, exist_ok=True)
+    config_file = MEMORY_DIR / "profiles.json"
+    with open(config_file, 'w') as f:
+        json.dump(config, f, indent=2)
+
+
+def _get_memory_count(profile: str) -> int:
+    """Get memory count for a profile (V3 atomic_facts or V2 memories)."""
+    try:
+        conn = get_db_connection()
+        cursor = conn.cursor()
+        # Try V3 table first
+        try:
+            cursor.execute(
+                "SELECT COUNT(*) FROM atomic_facts WHERE profile_id = ?", (profile,),
+            )
+            count = cursor.fetchone()[0]
+        except Exception:
+            cursor.execute(
+                "SELECT COUNT(*) FROM memories WHERE profile = ?", (profile,),
+            )
+            count = cursor.fetchone()[0]
+        conn.close()
+        return count
+    except Exception:
+        return 0
+
+
+@router.get("/api/profiles")
+async def list_profiles():
+    """List available memory profiles."""
+    try:
+        config = _load_profiles_config()
+        active = config.get('active_profile', 'default')
+        profiles = []
+
+        for name, info in config.get('profiles', {}).items():
+            count = _get_memory_count(name)
+            profiles.append({
+                "name": name,
+                "description": info.get('description', ''),
+                "memory_count": count,
+                "created_at": info.get('created_at', ''),
+                "last_used": info.get('last_used', ''),
+                "is_active": name == active,
+            })
+
+        return {
+            "profiles": profiles,
+            "active_profile": active,
+            "total_profiles": len(profiles),
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Profile list error: {str(e)}")
+
+
+@router.post("/api/profiles/{name}/switch")
+async def switch_profile(name: str):
+    """Switch active memory profile."""
+    try:
+        if not validate_profile_name(name):
+            raise HTTPException(status_code=400, detail="Invalid profile name.")
+
+        config = _load_profiles_config()
+
+        if name not in config.get('profiles', {}):
+            available = ', '.join(config.get('profiles', {}).keys())
+            raise HTTPException(
+                status_code=404,
+                detail=f"Profile '{name}' not found. Available: {available}",
+            )
+
+        previous = config.get('active_profile', 'default')
+        config['active_profile'] = name
+        config['profiles'][name]['last_used'] = datetime.now().isoformat()
+        _save_profiles_config(config)
+
+        count = _get_memory_count(name)
+
+        if ws_manager:
+            await ws_manager.broadcast({
+                "type": "profile_switched", "profile": name,
+                "previous": previous, "memory_count": count,
+                "timestamp": datetime.now().isoformat(),
+            })
+
+        return {
+            "success": True, "active_profile": name,
+            "previous_profile": previous, "memory_count": count,
+            "message": f"Switched to profile '{name}' ({count} memories).",
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Profile switch error: {str(e)}")
+
+
+@router.post("/api/profiles/create")
+async def create_profile(body: ProfileSwitch):
+    """Create a new memory profile."""
+    try:
+        name = body.profile_name
+        if not validate_profile_name(name):
+            raise HTTPException(status_code=400, detail="Invalid profile name")
+
+        config = _load_profiles_config()
+
+        if name in config.get('profiles', {}):
+            raise HTTPException(status_code=409, detail=f"Profile '{name}' already exists")
+
+        config['profiles'][name] = {
+            'name': name, 'description': f'Memory profile: {name}',
+            'created_at': datetime.now().isoformat(), 'last_used': None,
+        }
+        _save_profiles_config(config)
+
+        return {"success": True, "profile": name, "message": f"Profile '{name}' created"}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Profile create error: {str(e)}")
+
+
+@router.delete("/api/profiles/{name}")
+async def delete_profile(name: str):
+    """Delete a profile. Moves its memories to 'default'."""
+    try:
+        if name == 'default':
+            raise HTTPException(status_code=400, detail="Cannot delete 'default' profile")
+
+        config = _load_profiles_config()
+
+        if name not in config.get('profiles', {}):
+            raise HTTPException(status_code=404, detail=f"Profile '{name}' not found")
+        if config.get('active_profile') == name:
+            raise HTTPException(status_code=400, detail="Cannot delete active profile.")
+
+        conn = get_db_connection()
+        cursor = conn.cursor()
+        # Move memories to default (try V3 first, then V2)
+        moved = 0
+        try:
+            cursor.execute(
+                "UPDATE atomic_facts SET profile_id = 'default' WHERE profile_id = ?",
+                (name,),
+            )
+            moved = cursor.rowcount
+        except Exception:
+            pass
+        try:
+            cursor.execute(
+                "UPDATE memories SET profile = 'default' WHERE profile = ?",
+                (name,),
+            )
+            moved += cursor.rowcount
+        except Exception:
+            pass
+        conn.commit()
+        conn.close()
+
+        del config['profiles'][name]
+        _save_profiles_config(config)
+
+        return {
+            "success": True,
+            "message": f"Profile '{name}' deleted. {moved} memories moved to 'default'.",
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Profile delete error: {str(e)}")