omni-cortex 1.17.3__py3-none-any.whl → 1.17.4__py3-none-any.whl

omni_cortex/models/session.py

@@ -1,290 +0,0 @@
-"""Session model and CRUD operations."""
-
-import json
-import sqlite3
-from typing import Optional, Any
-from pydantic import BaseModel, Field, ConfigDict
-
-from ..utils.ids import generate_session_id, generate_summary_id
-from ..utils.timestamps import now_iso
-
-
-class SessionCreate(BaseModel):
-    """Input model for creating a session."""
-
-    model_config = ConfigDict(
-        str_strip_whitespace=True,
-        validate_assignment=True,
-    )
-
-    session_id: Optional[str] = Field(None, description="Custom session ID")
-    project_path: str = Field(..., description="Project directory path")
-    provide_context: bool = Field(True, description="Whether to provide previous context")
-    context_depth: int = Field(3, description="Number of past sessions to summarize", ge=1, le=10)
-
-
-class Session(BaseModel):
-    """Full session model from database."""
-
-    id: str
-    project_path: str
-    started_at: str
-    ended_at: Optional[str] = None
-    summary: Optional[str] = None
-    tags: Optional[list[str]] = None
-    metadata: Optional[dict[str, Any]] = None
-
-
-class SessionSummary(BaseModel):
-    """Session summary model."""
-
-    id: str
-    session_id: str
-    key_learnings: Optional[list[str]] = None
-    key_decisions: Optional[list[str]] = None
-    key_errors: Optional[list[str]] = None
-    files_modified: Optional[list[str]] = None
-    tools_used: Optional[dict[str, int]] = None
-    total_activities: int = 0
-    total_memories_created: int = 0
-    created_at: str
-
-
-def create_session(
-    conn: sqlite3.Connection,
-    data: SessionCreate,
-) -> Session:
-    """Create a new session.
-
-    Args:
-        conn: Database connection
-        data: Session creation data
-
-    Returns:
-        Created session object
-    """
-    session_id = data.session_id or generate_session_id()
-    now = now_iso()
-
-    cursor = conn.cursor()
-    cursor.execute(
-        """
-        INSERT INTO sessions (id, project_path, started_at)
-        VALUES (?, ?, ?)
-        """,
-        (session_id, data.project_path, now),
-    )
-    conn.commit()
-
-    return Session(
-        id=session_id,
-        project_path=data.project_path,
-        started_at=now,
-    )
-
-
-def get_session(conn: sqlite3.Connection, session_id: str) -> Optional[Session]:
-    """Get a session by ID."""
-    cursor = conn.cursor()
-    cursor.execute("SELECT * FROM sessions WHERE id = ?", (session_id,))
-    row = cursor.fetchone()
-    return _row_to_session(row) if row else None
-
-
-def end_session(
-    conn: sqlite3.Connection,
-    session_id: str,
-    summary: Optional[str] = None,
-    key_learnings: Optional[list[str]] = None,
-) -> Optional[Session]:
-    """End a session and create summary.
-
-    Args:
-        conn: Database connection
-        session_id: Session ID to end
-        summary: Optional summary text
-        key_learnings: Optional list of key learnings
-
-    Returns:
-        Updated session or None if not found
-    """
-    session = get_session(conn, session_id)
-    if not session:
-        return None
-
-    now = now_iso()
-    cursor = conn.cursor()
-
-    # Update session
-    cursor.execute(
-        """
-        UPDATE sessions
-        SET ended_at = ?, summary = ?
-        WHERE id = ?
-        """,
-        (now, summary, session_id),
-    )
-
-    # Gather session statistics
-    cursor.execute(
-        "SELECT COUNT(*) FROM activities WHERE session_id = ?",
-        (session_id,),
-    )
-    total_activities = cursor.fetchone()[0]
-
-    cursor.execute(
-        "SELECT COUNT(*) FROM memories WHERE source_session_id = ?",
-        (session_id,),
-    )
-    total_memories = cursor.fetchone()[0]
-
-    # Get tools used
-    cursor.execute(
-        """
-        SELECT tool_name, COUNT(*) as cnt
-        FROM activities
-        WHERE session_id = ? AND tool_name IS NOT NULL
-        GROUP BY tool_name
-        """,
-        (session_id,),
-    )
-    tools_used = {row["tool_name"]: row["cnt"] for row in cursor.fetchall()}
-
-    # Get files modified
-    cursor.execute(
-        """
-        SELECT DISTINCT file_path
-        FROM activities
-        WHERE session_id = ? AND file_path IS NOT NULL
-        """,
-        (session_id,),
-    )
-    files_modified = [row["file_path"] for row in cursor.fetchall()]
-
-    # Get errors
-    cursor.execute(
-        """
-        SELECT error_message
-        FROM activities
-        WHERE session_id = ? AND success = 0 AND error_message IS NOT NULL
-        LIMIT 10
-        """,
-        (session_id,),
-    )
-    key_errors = [row["error_message"] for row in cursor.fetchall()]
-
-    # Create summary record
-    summary_id = generate_summary_id()
-    cursor.execute(
-        """
-        INSERT INTO session_summaries (
-            id, session_id, key_learnings, key_decisions, key_errors,
-            files_modified, tools_used, total_activities,
-            total_memories_created, created_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        """,
-        (
-            summary_id,
-            session_id,
-            json.dumps(key_learnings) if key_learnings else None,
-            None,  # key_decisions - could be extracted from memories
-            json.dumps(key_errors) if key_errors else None,
-            json.dumps(files_modified) if files_modified else None,
-            json.dumps(tools_used) if tools_used else None,
-            total_activities,
-            total_memories,
-            now,
-        ),
-    )
-
-    conn.commit()
-    return get_session(conn, session_id)
-
-
-def get_recent_sessions(
-    conn: sqlite3.Connection,
-    project_path: Optional[str] = None,
-    limit: int = 5,
-) -> list[Session]:
-    """Get recent sessions.
-
-    Args:
-        conn: Database connection
-        project_path: Filter by project path
-        limit: Maximum number of sessions
-
-    Returns:
-        List of recent sessions
-    """
-    cursor = conn.cursor()
-
-    if project_path:
-        cursor.execute(
-            """
-            SELECT * FROM sessions
-            WHERE project_path = ?
-            ORDER BY started_at DESC
-            LIMIT ?
-            """,
-            (project_path, limit),
-        )
-    else:
-        cursor.execute(
-            """
-            SELECT * FROM sessions
-            ORDER BY started_at DESC
-            LIMIT ?
-            """,
-            (limit,),
-        )
-
-    return [_row_to_session(row) for row in cursor.fetchall()]
-
-
-def get_session_summary(
-    conn: sqlite3.Connection,
-    session_id: str,
-) -> Optional[SessionSummary]:
-    """Get session summary."""
-    cursor = conn.cursor()
-    cursor.execute(
-        "SELECT * FROM session_summaries WHERE session_id = ?",
-        (session_id,),
-    )
-    row = cursor.fetchone()
-    if not row:
-        return None
-
-    return SessionSummary(
-        id=row["id"],
-        session_id=row["session_id"],
-        key_learnings=json.loads(row["key_learnings"]) if row["key_learnings"] else None,
-        key_decisions=json.loads(row["key_decisions"]) if row["key_decisions"] else None,
-        key_errors=json.loads(row["key_errors"]) if row["key_errors"] else None,
-        files_modified=json.loads(row["files_modified"]) if row["files_modified"] else None,
-        tools_used=json.loads(row["tools_used"]) if row["tools_used"] else None,
-        total_activities=row["total_activities"],
-        total_memories_created=row["total_memories_created"],
-        created_at=row["created_at"],
-    )
-
-
-def _row_to_session(row: sqlite3.Row) -> Session:
-    """Convert database row to Session object."""
-    tags = row["tags"]
-    if tags and isinstance(tags, str):
-        tags = json.loads(tags)
-
-    metadata = row["metadata"]
-    if metadata and isinstance(metadata, str):
-        metadata = json.loads(metadata)
-
-    return Session(
-        id=row["id"],
-        project_path=row["project_path"],
-        started_at=row["started_at"],
-        ended_at=row["ended_at"],
-        summary=row["summary"],
-        tags=tags,
-        metadata=metadata,
-    )

omni_cortex/resources/__init__.py

@@ -1 +0,0 @@
-"""MCP resources for Omni Cortex."""

omni_cortex/search/__init__.py

@@ -1,22 +0,0 @@
-"""Search functionality for Omni Cortex."""
-
-from .keyword import keyword_search
-from .ranking import calculate_relevance_score, rank_memories, normalize_scores
-from .semantic import semantic_search, find_similar_memories, get_embedding_coverage
-from .hybrid import hybrid_search, search
-
-__all__ = [
-    # Keyword search
-    "keyword_search",
-    # Semantic search
-    "semantic_search",
-    "find_similar_memories",
-    "get_embedding_coverage",
-    # Hybrid search
-    "hybrid_search",
-    "search",
-    # Ranking
-    "calculate_relevance_score",
-    "rank_memories",
-    "normalize_scores",
-]

omni_cortex/search/hybrid.py

@@ -1,197 +0,0 @@
-"""Hybrid search combining keyword and semantic search."""
-
-import logging
-import sqlite3
-from typing import Optional
-
-from ..models.memory import Memory
-from .keyword import keyword_search
-from .semantic import semantic_search
-from .ranking import normalize_scores
-
-logger = logging.getLogger(__name__)
-
-
-def hybrid_search(
-    conn: sqlite3.Connection,
-    query: str,
-    type_filter: Optional[str] = None,
-    tags_filter: Optional[list[str]] = None,
-    status_filter: Optional[str] = None,
-    min_importance: Optional[int] = None,
-    include_archived: bool = False,
-    limit: int = 10,
-    keyword_weight: float = 0.4,
-    semantic_weight: float = 0.6,
-) -> list[tuple[Memory, float, float]]:
-    """Search memories using combined keyword and semantic search.
-
-    The hybrid approach uses both methods and combines their scores:
-    - Keyword search finds exact/fuzzy matches
-    - Semantic search finds conceptually similar content
-    - Results are merged and re-ranked using weighted scores
-
-    Args:
-        conn: Database connection
-        query: Search query string
-        type_filter: Filter by memory type
-        tags_filter: Filter by tags
-        status_filter: Filter by status
-        min_importance: Minimum importance score
-        include_archived: Include archived memories
-        limit: Maximum results
-        keyword_weight: Weight for keyword scores (0-1)
-        semantic_weight: Weight for semantic scores (0-1)
-
-    Returns:
-        List of (Memory, keyword_score, semantic_score) tuples
-    """
-    # Normalize weights
-    total_weight = keyword_weight + semantic_weight
-    if total_weight > 0:
-        keyword_weight = keyword_weight / total_weight
-        semantic_weight = semantic_weight / total_weight
-
-    # Perform keyword search (get more than limit for merging)
-    search_limit = min(limit * 3, 100)
-
-    keyword_results = keyword_search(
-        conn,
-        query=query,
-        type_filter=type_filter,
-        tags_filter=tags_filter,
-        status_filter=status_filter,
-        min_importance=min_importance,
-        include_archived=include_archived,
-        limit=search_limit,
-    )
-
-    # Perform semantic search
-    semantic_results = []
-    try:
-        semantic_results = semantic_search(
-            conn,
-            query=query,
-            type_filter=type_filter,
-            tags_filter=tags_filter,
-            status_filter=status_filter,
-            min_importance=min_importance,
-            include_archived=include_archived,
-            limit=search_limit,
-            similarity_threshold=0.2,  # Lower threshold for hybrid
-        )
-    except Exception as e:
-        logger.warning(f"Semantic search failed, using keyword only: {e}")
-
-    # Build score dictionaries
-    keyword_scores: dict[str, tuple[Memory, float]] = {}
-    for memory, score in keyword_results:
-        keyword_scores[memory.id] = (memory, score)
-
-    semantic_scores: dict[str, tuple[Memory, float]] = {}
-    for memory, score in semantic_results:
-        semantic_scores[memory.id] = (memory, score)
-
-    # Get all unique memory IDs
-    all_ids = set(keyword_scores.keys()) | set(semantic_scores.keys())
-
-    if not all_ids:
-        return []
-
-    # Normalize keyword scores to 0-1 range
-    if keyword_scores:
-        kw_score_values = [s for _, s in keyword_scores.values()]
-        kw_normalized = normalize_scores(kw_score_values)
-        kw_norm_map = dict(zip(keyword_scores.keys(), kw_normalized))
-    else:
-        kw_norm_map = {}
-
-    # Semantic scores are already 0-1 (cosine similarity)
-    sem_norm_map = {mid: score for mid, (_, score) in semantic_scores.items()}
-
-    # Combine scores
-    combined_results: list[tuple[Memory, float, float]] = []
-
-    for memory_id in all_ids:
-        # Get memory object (prefer from keyword results for consistency)
-        if memory_id in keyword_scores:
-            memory = keyword_scores[memory_id][0]
-        else:
-            memory = semantic_scores[memory_id][0]
-
-        # Get normalized scores (0 if not in that result set)
-        kw_score = kw_norm_map.get(memory_id, 0.0)
-        sem_score = sem_norm_map.get(memory_id, 0.0)
-
-        combined_results.append((memory, kw_score, sem_score))
-
-    # Sort by weighted combined score
-    def combined_score(item: tuple[Memory, float, float]) -> float:
-        _, kw, sem = item
-        return (kw * keyword_weight) + (sem * semantic_weight)
-
-    combined_results.sort(key=combined_score, reverse=True)
-
-    return combined_results[:limit]
-
-
-def search(
-    conn: sqlite3.Connection,
-    query: str,
-    mode: str = "keyword",
-    type_filter: Optional[str] = None,
-    tags_filter: Optional[list[str]] = None,
-    status_filter: Optional[str] = None,
-    min_importance: Optional[int] = None,
-    include_archived: bool = False,
-    limit: int = 10,
-) -> list[tuple[Memory, float, float]]:
-    """Unified search function supporting all modes.
-
-    Args:
-        conn: Database connection
-        query: Search query string
-        mode: Search mode - "keyword", "semantic", or "hybrid"
-        type_filter: Filter by memory type
-        tags_filter: Filter by tags
-        status_filter: Filter by status
-        min_importance: Minimum importance score
-        include_archived: Include archived memories
-        limit: Maximum results
-
-    Returns:
-        List of (Memory, keyword_score, semantic_score) tuples
-    """
-    common_args = {
-        "conn": conn,
-        "query": query,
-        "type_filter": type_filter,
-        "tags_filter": tags_filter,
-        "status_filter": status_filter,
-        "min_importance": min_importance,
-        "include_archived": include_archived,
-        "limit": limit,
-    }
-
-    if mode == "keyword":
-        results = keyword_search(**common_args)
-        # Convert to unified format (keyword_score, semantic_score=0)
-        return [(memory, score, 0.0) for memory, score in results]
-
-    elif mode == "semantic":
-        try:
-            results = semantic_search(**common_args, similarity_threshold=0.3)
-            # Convert to unified format (keyword_score=0, semantic_score)
-            return [(memory, 0.0, score) for memory, score in results]
-        except Exception as e:
-            logger.warning(f"Semantic search failed, falling back to keyword: {e}")
-            results = keyword_search(**common_args)
-            return [(memory, score, 0.0) for memory, score in results]
-
-    elif mode == "hybrid":
-        return hybrid_search(**common_args)
-
-    else:
-        logger.warning(f"Unknown search mode '{mode}', using keyword")
-        results = keyword_search(**common_args)
-        return [(memory, score, 0.0) for memory, score in results]