spooling 0.1.1__py3-none-any.whl

spooling/config.py

@@ -0,0 +1,44 @@
+"""Configuration for Spooling."""
+
+import os
+from pathlib import Path
+
+# Legacy session data directory (JSONL-format sessions)
+SESSIONS_DIR = Path.home() / ".sessions"
+SESSIONS_PROJECTS_DIR = SESSIONS_DIR / "projects"
+
+# Snowflake Cortex Code data directory. Sessions live in
+# ~/.snowflake/cortex/conversations/<uuid>.history.jsonl with a sidecar
+# <uuid>.json carrying title, working_directory, git info, and timestamps.
+CORTEX_DIR = Path.home() / ".snowflake" / "cortex"
+CORTEX_CONVERSATIONS_DIR = CORTEX_DIR / "conversations"
+
+# opencode (sst/opencode) data directory. Single SQLite DB at
+# ~/.local/share/opencode/opencode.db with session/message/part tables
+# (Drizzle-managed). Parts carry the Vercel AI SDK UIMessage payload.
+OPENCODE_DIR = Path.home() / ".local" / "share" / "opencode"
+OPENCODE_DB = OPENCODE_DIR / "opencode.db"
+
+# Database
+DB_HOST = os.getenv("SPOOLING_DB_HOST", "localhost")
+DB_PORT = int(os.getenv("SPOOLING_DB_PORT", "5434"))
+DB_NAME = os.getenv("SPOOLING_DB_NAME", "spooling")
+DB_USER = os.getenv("SPOOLING_DB_USER", "spooling")
+DB_PASSWORD = os.getenv("SPOOLING_DB_PASSWORD", "spooling")
+
+DATABASE_URL = f"postgresql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
+
+# Embeddings
+EMBEDDING_MODEL = os.getenv("SPOOLING_EMBEDDING_MODEL", "all-MiniLM-L6-v2")
+EMBEDDING_DIM = 384
+CHUNK_SIZE = 500  # chars per chunk for embedding
+
+# Server
+UI_HOST = os.getenv("SPOOLING_UI_HOST", "127.0.0.1")
+UI_PORT = int(os.getenv("SPOOLING_UI_PORT", "3001"))
+
+# Token estimation (rough heuristic: ~4 chars per token)
+CHARS_PER_TOKEN = 4
+
+# Default model pricing per 1M tokens (input, output)
+DEFAULT_PRICING = (3.0, 15.0)

spooling/db.py

@@ -0,0 +1,21 @@
+"""Database connection management."""
+
+import psycopg
+from psycopg.rows import dict_row
+
+from spooling.config import DATABASE_URL
+
+
+def get_connection():
+    """Get a database connection."""
+    return psycopg.connect(DATABASE_URL, row_factory=dict_row)
+
+
+def check_db():
+    """Check if the database is reachable."""
+    try:
+        with get_connection() as conn:
+            conn.execute("SELECT 1")
+        return True
+    except Exception:
+        return False

spooling/embeddings.py

@@ -0,0 +1,60 @@
+"""Local embeddings via sentence-transformers."""
+
+from functools import lru_cache
+
+from spooling.config import EMBEDDING_MODEL, CHUNK_SIZE
+
+
+@lru_cache(maxsize=1)
+def _get_model():
+    """Lazy-load the embedding model."""
+    from sentence_transformers import SentenceTransformer
+    return SentenceTransformer(EMBEDDING_MODEL)
+
+
+def embed_texts(texts: list[str]) -> list[list[float]]:
+    """Embed a batch of texts. Returns list of vectors."""
+    model = _get_model()
+    embeddings = model.encode(texts, show_progress_bar=False, normalize_embeddings=True)
+    return [e.tolist() for e in embeddings]
+
+
+def embed_text(text: str) -> list[float]:
+    """Embed a single text."""
+    return embed_texts([text])[0]
+
+
+def chunk_text(text: str, chunk_size: int = CHUNK_SIZE) -> list[str]:
+    """Split text into chunks for embedding."""
+    if len(text) <= chunk_size:
+        return [text] if text.strip() else []
+
+    chunks = []
+    # Split on paragraph boundaries first, then by size
+    paragraphs = text.split("\n\n")
+    current = ""
+
+    for para in paragraphs:
+        if len(current) + len(para) + 2 <= chunk_size:
+            current = f"{current}\n\n{para}" if current else para
+        else:
+            if current.strip():
+                chunks.append(current.strip())
+            # If a single paragraph exceeds chunk_size, split by sentences
+            if len(para) > chunk_size:
+                words = para.split()
+                current = ""
+                for word in words:
+                    if len(current) + len(word) + 1 <= chunk_size:
+                        current = f"{current} {word}" if current else word
+                    else:
+                        if current.strip():
+                            chunks.append(current.strip())
+                        current = word
+            else:
+                current = para
+
+    if current.strip():
+        chunks.append(current.strip())
+
+    return chunks