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

omni_cortex/models/memory.py

@@ -1,395 +0,0 @@
-"""Memory model and CRUD operations."""
-
-import json
-import sqlite3
-from typing import Optional, Any
-from pydantic import BaseModel, Field, ConfigDict, field_validator
-
-from ..utils.ids import generate_memory_id
-from ..utils.timestamps import now_iso
-
-
-class MemoryBase(BaseModel):
-    """Base memory model."""
-
-    model_config = ConfigDict(
-        str_strip_whitespace=True,
-        validate_assignment=True,
-    )
-
-    content: str = Field(..., description="The memory content", min_length=1)
-    context: Optional[str] = Field(None, description="Additional context")
-    tags: Optional[list[str]] = Field(default_factory=list, description="Tags for categorization")
-    type: str = Field("general", description="Memory type")
-
-
-class MemoryCreate(MemoryBase):
-    """Input model for creating a memory."""
-
-    importance: Optional[int] = Field(
-        None, description="Importance score 1-100", ge=1, le=100
-    )
-    related_activity_id: Optional[str] = Field(None, description="Related activity ID")
-    related_memory_ids: Optional[list[str]] = Field(
-        default_factory=list, description="Related memory IDs"
-    )
-
-    @field_validator("tags", mode="before")
-    @classmethod
-    def parse_tags(cls, v: Any) -> list[str]:
-        if v is None:
-            return []
-        if isinstance(v, str):
-            return [t.strip() for t in v.split(",") if t.strip()]
-        return list(v)
-
-
-class MemoryUpdate(BaseModel):
-    """Input model for updating a memory."""
-
-    model_config = ConfigDict(
-        str_strip_whitespace=True,
-        validate_assignment=True,
-    )
-
-    content: Optional[str] = Field(None, description="New content")
-    context: Optional[str] = Field(None, description="New context")
-    tags: Optional[list[str]] = Field(None, description="Replace all tags")
-    add_tags: Optional[list[str]] = Field(None, description="Tags to add")
-    remove_tags: Optional[list[str]] = Field(None, description="Tags to remove")
-    status: Optional[str] = Field(None, description="New status")
-    importance: Optional[int] = Field(None, description="New importance", ge=1, le=100)
-
-
-class Memory(MemoryBase):
-    """Full memory model from database."""
-
-    id: str
-    created_at: str
-    updated_at: str
-    last_accessed: str
-    last_verified: Optional[str] = None
-    access_count: int = 0
-    importance_score: float = 50.0
-    manual_importance: Optional[int] = None
-    status: str = "fresh"
-    source_session_id: Optional[str] = None
-    source_agent_id: Optional[str] = None
-    source_activity_id: Optional[str] = None
-    project_path: Optional[str] = None
-    file_context: Optional[list[str]] = None
-    has_embedding: bool = False
-    metadata: Optional[dict[str, Any]] = None
-
-
-def create_memory(
-    conn: sqlite3.Connection,
-    data: MemoryCreate,
-    project_path: Optional[str] = None,
-    session_id: Optional[str] = None,
-    agent_id: Optional[str] = None,
-) -> Memory:
-    """Create a new memory in the database.
-
-    Args:
-        conn: Database connection
-        data: Memory creation data
-        project_path: Current project path
-        session_id: Current session ID
-        agent_id: Current agent ID
-
-    Returns:
-        Created memory object
-    """
-    from ..categorization import detect_memory_type, suggest_tags
-
-    memory_id = generate_memory_id()
-    now = now_iso()
-
-    # Auto-detect type if not specified or is default
-    mem_type = data.type
-    if mem_type == "general":
-        mem_type = detect_memory_type(data.content, data.context)
-
-    # Auto-suggest tags and merge with provided
-    suggested = suggest_tags(data.content, data.context)
-    tags = list(set((data.tags or []) + suggested))
-
-    # Determine importance
-    importance = float(data.importance) if data.importance else 50.0
-    manual_importance = data.importance
-
-    cursor = conn.cursor()
-    cursor.execute(
-        """
-        INSERT INTO memories (
-            id, content, type, tags, context,
-            created_at, updated_at, last_accessed,
-            access_count, importance_score, manual_importance, status,
-            source_session_id, source_agent_id, source_activity_id,
-            project_path, has_embedding
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        """,
-        (
-            memory_id,
-            data.content,
-            mem_type,
-            json.dumps(tags),
-            data.context,
-            now,
-            now,
-            now,
-            0,
-            importance,
-            manual_importance,
-            "fresh",
-            session_id,
-            agent_id,
-            data.related_activity_id,
-            project_path,
-            0,
-        ),
-    )
-    conn.commit()
-
-    return Memory(
-        id=memory_id,
-        content=data.content,
-        type=mem_type,
-        tags=tags,
-        context=data.context,
-        created_at=now,
-        updated_at=now,
-        last_accessed=now,
-        access_count=0,
-        importance_score=importance,
-        manual_importance=manual_importance,
-        status="fresh",
-        source_session_id=session_id,
-        source_activity_id=data.related_activity_id,
-        project_path=project_path,
-    )
-
-
-def get_memory(conn: sqlite3.Connection, memory_id: str) -> Optional[Memory]:
-    """Get a memory by ID.
-
-    Args:
-        conn: Database connection
-        memory_id: Memory ID
-
-    Returns:
-        Memory object or None if not found
-    """
-    cursor = conn.cursor()
-    cursor.execute("SELECT * FROM memories WHERE id = ?", (memory_id,))
-    row = cursor.fetchone()
-
-    if not row:
-        return None
-
-    return _row_to_memory(row)
-
-
-def update_memory(
-    conn: sqlite3.Connection,
-    memory_id: str,
-    data: MemoryUpdate,
-) -> Optional[Memory]:
-    """Update a memory.
-
-    Args:
-        conn: Database connection
-        memory_id: Memory ID
-        data: Update data
-
-    Returns:
-        Updated memory or None if not found
-    """
-    memory = get_memory(conn, memory_id)
-    if not memory:
-        return None
-
-    updates = []
-    params = []
-
-    if data.content is not None:
-        updates.append("content = ?")
-        params.append(data.content)
-
-    if data.context is not None:
-        updates.append("context = ?")
-        params.append(data.context)
-
-    if data.status is not None:
-        updates.append("status = ?")
-        params.append(data.status)
-
-    if data.importance is not None:
-        updates.append("manual_importance = ?")
-        params.append(data.importance)
-        updates.append("importance_score = ?")
-        params.append(float(data.importance))
-
-    # Handle tags
-    current_tags = memory.tags or []
-    new_tags = current_tags
-
-    if data.tags is not None:
-        new_tags = data.tags
-    else:
-        if data.add_tags:
-            new_tags = list(set(current_tags + data.add_tags))
-        if data.remove_tags:
-            new_tags = [t for t in new_tags if t not in data.remove_tags]
-
-    if new_tags != current_tags:
-        updates.append("tags = ?")
-        params.append(json.dumps(new_tags))
-
-    if updates:
-        updates.append("updated_at = ?")
-        params.append(now_iso())
-        params.append(memory_id)
-
-        cursor = conn.cursor()
-        cursor.execute(
-            f"UPDATE memories SET {', '.join(updates)} WHERE id = ?",
-            params,
-        )
-        conn.commit()
-
-    return get_memory(conn, memory_id)
-
-
-def delete_memory(conn: sqlite3.Connection, memory_id: str) -> bool:
-    """Delete a memory.
-
-    Args:
-        conn: Database connection
-        memory_id: Memory ID
-
-    Returns:
-        True if deleted, False if not found
-    """
-    cursor = conn.cursor()
-    cursor.execute("DELETE FROM memories WHERE id = ?", (memory_id,))
-    conn.commit()
-    return cursor.rowcount > 0
-
-
-def list_memories(
-    conn: sqlite3.Connection,
-    type_filter: Optional[str] = None,
-    tags_filter: Optional[list[str]] = None,
-    status_filter: Optional[str] = None,
-    sort_by: str = "last_accessed",
-    sort_order: str = "desc",
-    limit: int = 20,
-    offset: int = 0,
-) -> tuple[list[Memory], int]:
-    """List memories with filters.
-
-    Returns:
-        Tuple of (memories list, total count)
-    """
-    where_clauses = []
-    params: list[Any] = []
-
-    if type_filter:
-        where_clauses.append("type = ?")
-        params.append(type_filter)
-
-    if status_filter:
-        where_clauses.append("status = ?")
-        params.append(status_filter)
-
-    if tags_filter:
-        # Match any of the tags
-        tag_conditions = []
-        for tag in tags_filter:
-            tag_conditions.append("tags LIKE ?")
-            params.append(f'%"{tag}"%')
-        where_clauses.append(f"({' OR '.join(tag_conditions)})")
-
-    where_sql = ""
-    if where_clauses:
-        where_sql = "WHERE " + " AND ".join(where_clauses)
-
-    # Validate sort column
-    valid_sorts = ["last_accessed", "created_at", "importance_score", "access_count"]
-    if sort_by not in valid_sorts:
-        sort_by = "last_accessed"
-
-    order = "DESC" if sort_order.lower() == "desc" else "ASC"
-
-    # Get total count
-    cursor = conn.cursor()
-    cursor.execute(f"SELECT COUNT(*) FROM memories {where_sql}", params)
-    total = cursor.fetchone()[0]
-
-    # Get page
-    params_page = params + [limit, offset]
-    cursor.execute(
-        f"""
-        SELECT * FROM memories {where_sql}
-        ORDER BY {sort_by} {order}
-        LIMIT ? OFFSET ?
-        """,
-        params_page,
-    )
-
-    memories = [_row_to_memory(row) for row in cursor.fetchall()]
-    return memories, total
-
-
-def touch_memory(conn: sqlite3.Connection, memory_id: str) -> None:
-    """Update last_accessed and increment access_count."""
-    cursor = conn.cursor()
-    cursor.execute(
-        """
-        UPDATE memories
-        SET last_accessed = ?, access_count = access_count + 1
-        WHERE id = ?
-        """,
-        (now_iso(), memory_id),
-    )
-    conn.commit()
-
-
-def _row_to_memory(row: sqlite3.Row) -> Memory:
-    """Convert database row to Memory object."""
-    tags = row["tags"]
-    if tags and isinstance(tags, str):
-        tags = json.loads(tags)
-
-    file_context = row["file_context"]
-    if file_context and isinstance(file_context, str):
-        file_context = json.loads(file_context)
-
-    metadata = row["metadata"]
-    if metadata and isinstance(metadata, str):
-        metadata = json.loads(metadata)
-
-    return Memory(
-        id=row["id"],
-        content=row["content"],
-        type=row["type"],
-        tags=tags or [],
-        context=row["context"],
-        created_at=row["created_at"],
-        updated_at=row["updated_at"],
-        last_accessed=row["last_accessed"],
-        last_verified=row["last_verified"],
-        access_count=row["access_count"],
-        importance_score=row["importance_score"],
-        manual_importance=row["manual_importance"],
-        status=row["status"],
-        source_session_id=row["source_session_id"],
-        source_agent_id=row["source_agent_id"],
-        source_activity_id=row["source_activity_id"],
-        project_path=row["project_path"],
-        file_context=file_context,
-        has_embedding=bool(row["has_embedding"]),
-        metadata=metadata,
-    )

omni_cortex/models/relationship.py

@@ -1,206 +0,0 @@
-"""Memory relationship model and operations."""
-
-import json
-import sqlite3
-from typing import Optional, Any
-from pydantic import BaseModel, Field, ConfigDict
-
-from ..utils.ids import generate_relationship_id
-from ..utils.timestamps import now_iso
-
-
-class MemoryRelationship(BaseModel):
-    """Memory relationship model."""
-
-    model_config = ConfigDict(
-        str_strip_whitespace=True,
-    )
-
-    id: str
-    source_memory_id: str
-    target_memory_id: str
-    relationship_type: str  # related_to, supersedes, derived_from, contradicts
-    strength: float = 1.0
-    created_at: str
-    metadata: Optional[dict[str, Any]] = None
-
-
-class LinkMemoriesInput(BaseModel):
-    """Input for linking two memories."""
-
-    model_config = ConfigDict(
-        str_strip_whitespace=True,
-        validate_assignment=True,
-    )
-
-    source_id: str = Field(..., description="Source memory ID")
-    target_id: str = Field(..., description="Target memory ID")
-    relationship_type: str = Field(
-        ...,
-        description="Relationship type: related_to, supersedes, derived_from, contradicts",
-    )
-    strength: float = Field(1.0, description="Relationship strength 0.0-1.0", ge=0.0, le=1.0)
-
-
-VALID_RELATIONSHIP_TYPES = ["related_to", "supersedes", "derived_from", "contradicts"]
-
-
-def create_relationship(
-    conn: sqlite3.Connection,
-    source_id: str,
-    target_id: str,
-    relationship_type: str,
-    strength: float = 1.0,
-) -> Optional[MemoryRelationship]:
-    """Create a relationship between two memories.
-
-    Args:
-        conn: Database connection
-        source_id: Source memory ID
-        target_id: Target memory ID
-        relationship_type: Type of relationship
-        strength: Relationship strength
-
-    Returns:
-        Created relationship or None if memories don't exist
-    """
-    if relationship_type not in VALID_RELATIONSHIP_TYPES:
-        raise ValueError(f"Invalid relationship type: {relationship_type}")
-
-    # Verify both memories exist
-    cursor = conn.cursor()
-    cursor.execute("SELECT id FROM memories WHERE id IN (?, ?)", (source_id, target_id))
-    found = [row[0] for row in cursor.fetchall()]
-    if len(found) != 2:
-        return None
-
-    rel_id = generate_relationship_id()
-    now = now_iso()
-
-    try:
-        cursor.execute(
-            """
-            INSERT INTO memory_relationships (
-                id, source_memory_id, target_memory_id,
-                relationship_type, strength, created_at
-            ) VALUES (?, ?, ?, ?, ?, ?)
-            """,
-            (rel_id, source_id, target_id, relationship_type, strength, now),
-        )
-        conn.commit()
-    except sqlite3.IntegrityError:
-        # Relationship already exists
-        cursor.execute(
-            """
-            SELECT * FROM memory_relationships
-            WHERE source_memory_id = ? AND target_memory_id = ? AND relationship_type = ?
-            """,
-            (source_id, target_id, relationship_type),
-        )
-        row = cursor.fetchone()
-        if row:
-            return _row_to_relationship(row)
-        return None
-
-    return MemoryRelationship(
-        id=rel_id,
-        source_memory_id=source_id,
-        target_memory_id=target_id,
-        relationship_type=relationship_type,
-        strength=strength,
-        created_at=now,
-    )
-
-
-def get_relationships(
-    conn: sqlite3.Connection,
-    memory_id: str,
-    as_source: bool = True,
-    as_target: bool = True,
-) -> list[MemoryRelationship]:
-    """Get all relationships for a memory.
-
-    Args:
-        conn: Database connection
-        memory_id: Memory ID
-        as_source: Include relationships where memory is source
-        as_target: Include relationships where memory is target
-
-    Returns:
-        List of relationships
-    """
-    cursor = conn.cursor()
-    relationships = []
-
-    if as_source:
-        cursor.execute(
-            "SELECT * FROM memory_relationships WHERE source_memory_id = ?",
-            (memory_id,),
-        )
-        relationships.extend([_row_to_relationship(row) for row in cursor.fetchall()])
-
-    if as_target:
-        cursor.execute(
-            "SELECT * FROM memory_relationships WHERE target_memory_id = ?",
-            (memory_id,),
-        )
-        relationships.extend([_row_to_relationship(row) for row in cursor.fetchall()])
-
-    return relationships
-
-
-def delete_relationship(
-    conn: sqlite3.Connection,
-    source_id: str,
-    target_id: str,
-    relationship_type: Optional[str] = None,
-) -> int:
-    """Delete relationships between memories.
-
-    Args:
-        conn: Database connection
-        source_id: Source memory ID
-        target_id: Target memory ID
-        relationship_type: Optional type filter
-
-    Returns:
-        Number of relationships deleted
-    """
-    cursor = conn.cursor()
-
-    if relationship_type:
-        cursor.execute(
-            """
-            DELETE FROM memory_relationships
-            WHERE source_memory_id = ? AND target_memory_id = ? AND relationship_type = ?
-            """,
-            (source_id, target_id, relationship_type),
-        )
-    else:
-        cursor.execute(
-            """
-            DELETE FROM memory_relationships
-            WHERE source_memory_id = ? AND target_memory_id = ?
-            """,
-            (source_id, target_id),
-        )
-
-    conn.commit()
-    return cursor.rowcount
-
-
-def _row_to_relationship(row: sqlite3.Row) -> MemoryRelationship:
-    """Convert database row to MemoryRelationship object."""
-    metadata = row["metadata"]
-    if metadata and isinstance(metadata, str):
-        metadata = json.loads(metadata)
-
-    return MemoryRelationship(
-        id=row["id"],
-        source_memory_id=row["source_memory_id"],
-        target_memory_id=row["target_memory_id"],
-        relationship_type=row["relationship_type"],
-        strength=row["strength"],
-        created_at=row["created_at"],
-        metadata=metadata,
-    )