Phase 2 build initial

hcfs-python/hcfs/core/context_db.py

@@ -0,0 +1,148 @@
+"""
+Context Database - Storage and retrieval of context blobs.
+"""
+
+from datetime import datetime
+from typing import List, Optional, Dict, Any
+from dataclasses import dataclass
+from pathlib import Path
+
+from sqlalchemy import create_engine, Column, Integer, String, DateTime, Text, Float
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, Session
+
+
+Base = declarative_base()
+
+
+class ContextBlob(Base):
+    """Database model for context blobs."""
+    
+    __tablename__ = "context_blobs"
+    
+    id = Column(Integer, primary_key=True)
+    path = Column(String(512), nullable=False, index=True)
+    content = Column(Text, nullable=False)
+    summary = Column(Text)
+    embedding_model = Column(String(100))
+    embedding_vector = Column(Text)  # JSON serialized vector
+    author = Column(String(100))
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    version = Column(Integer, default=1)
+
+
+@dataclass
+class Context:
+    """Context data structure."""
+    id: Optional[int]
+    path: str
+    content: str
+    summary: Optional[str] = None
+    author: Optional[str] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    version: int = 1
+
+
+class ContextDatabase:
+    """Main interface for context storage and retrieval."""
+    
+    def __init__(self, db_path: str = "hcfs_context.db"):
+        self.db_path = db_path
+        self.engine = create_engine(f"sqlite:///{db_path}")
+        Base.metadata.create_all(self.engine)
+        self.SessionLocal = sessionmaker(bind=self.engine)
+    
+    def get_session(self) -> Session:
+        """Get database session."""
+        return self.SessionLocal()
+    
+    def store_context(self, context: Context) -> int:
+        """Store a context blob and return its ID."""
+        with self.get_session() as session:
+            blob = ContextBlob(
+                path=context.path,
+                content=context.content,
+                summary=context.summary,
+                author=context.author,
+                version=context.version
+            )
+            session.add(blob)
+            session.commit()
+            session.refresh(blob)
+            return blob.id
+    
+    def get_context_by_path(self, path: str, depth: int = 1) -> List[Context]:
+        """Retrieve contexts for a path and optionally parent paths."""
+        contexts = []
+        current_path = Path(path)
+        
+        with self.get_session() as session:
+            # Get contexts for current path and parents up to depth
+            for i in range(depth + 1):
+                search_path = str(current_path) if current_path != Path(".") else "/"
+                
+                blobs = session.query(ContextBlob).filter(
+                    ContextBlob.path == search_path
+                ).order_by(ContextBlob.created_at.desc()).all()
+                
+                for blob in blobs:
+                    contexts.append(Context(
+                        id=blob.id,
+                        path=blob.path,
+                        content=blob.content,
+                        summary=blob.summary,
+                        author=blob.author,
+                        created_at=blob.created_at,
+                        updated_at=blob.updated_at,
+                        version=blob.version
+                    ))
+                
+                if current_path.parent == current_path:  # Root reached
+                    break
+                current_path = current_path.parent
+        
+        return contexts
+    
+    def list_contexts_at_path(self, path: str) -> List[Context]:
+        """List all contexts at a specific path."""
+        with self.get_session() as session:
+            blobs = session.query(ContextBlob).filter(
+                ContextBlob.path == path
+            ).order_by(ContextBlob.created_at.desc()).all()
+            
+            return [Context(
+                id=blob.id,
+                path=blob.path,
+                content=blob.content,
+                summary=blob.summary,
+                author=blob.author,
+                created_at=blob.created_at,
+                updated_at=blob.updated_at,
+                version=blob.version
+            ) for blob in blobs]
+    
+    def update_context(self, context_id: int, content: str, summary: str = None) -> bool:
+        """Update an existing context."""
+        with self.get_session() as session:
+            blob = session.query(ContextBlob).filter(ContextBlob.id == context_id).first()
+            if blob:
+                blob.content = content
+                if summary:
+                    blob.summary = summary
+                blob.version += 1
+                blob.updated_at = datetime.utcnow()
+                session.commit()
+                return True
+            return False
+    
+    def delete_context(self, context_id: int) -> bool:
+        """Delete a context by ID."""
+        with self.get_session() as session:
+            blob = session.query(ContextBlob).filter(ContextBlob.id == context_id).first()
+            if blob:
+                session.delete(blob)
+                session.commit()
+                return True
+            return False