vector-task-mcp 1.2.7__tar.gz → 1.2.9__tar.gz

{vector_task_mcp-1.2.7 → vector_task_mcp-1.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vector-task-mcp
-Version: 1.2.7
+Version: 1.2.9
 Summary: A secure, vector-based task management server for Claude Desktop using sqlite-vec and sentence-transformers
 Author-email: Xsaven <xsaven@gmail.com>
 License: MIT
@@ -23,6 +23,7 @@ License-File: LICENSE
 Requires-Dist: mcp>=0.3.0
 Requires-Dist: sqlite-vec>=0.1.6
 Requires-Dist: sentence-transformers>=2.2.2
+Requires-Dist: requests>=2.28.0
 Dynamic: license-file
 
 # Vector Task MCP Server

{vector_task_mcp-1.2.7 → vector_task_mcp-1.2.9}/main.py

@@ -4,9 +4,10 @@
 # dependencies = [
 #     "mcp>=0.3.0",
 #     "sqlite-vec>=0.1.6",
-#     "sentence-transformers>=2.2.2"
+#     "sentence-transformers>=2.2.2",
+#     "requests>=2.28.0"
 # ]
-# requires-python = ">=3.8"
+# requires-python = ">=3.10"
 # ///
 
 """

{vector_task_mcp-1.2.7 → vector_task_mcp-1.2.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vector-task-mcp"
-version = "1.2.7"
+version = "1.2.9"
 description = "A secure, vector-based task management server for Claude Desktop using sqlite-vec and sentence-transformers"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -34,6 +34,7 @@ dependencies = [
     "mcp>=0.3.0",
     "sqlite-vec>=0.1.6",
     "sentence-transformers>=2.2.2",
+    "requests>=2.28.0",
 ]
 
 [project.urls]

vector_task_mcp-1.2.9/src/embeddings.py

@@ -0,0 +1,151 @@
+"""
+Embedding Model Module
+======================
+
+Provides sentence transformer embedding functionality for semantic task search.
+Uses lazy loading with background preload for fast server startup.
+"""
+
+import threading
+from typing import List, Union, Optional
+import numpy as np
+
+
+class EmbeddingModelNotReadyError(Exception):
+    """Raised when embedding model not loaded and timeout exceeded."""
+    pass
+
+
+class LazyEmbeddingModel:
+    """Lazy-loading embedding model with background initialization."""
+
+    def __init__(self, model_name: str, preload: bool = True):
+        """
+        Initialize lazy embedding model.
+
+        Args:
+            model_name: HuggingFace model name (e.g., 'sentence-transformers/all-MiniLM-L6-v2')
+            preload: If True, start loading model in background immediately
+        """
+        self.model_name = model_name
+        self._model = None
+        self._lock = threading.Lock()
+        self._ready_event = threading.Event()
+        self._load_error: Optional[Exception] = None
+
+        if preload:
+            self._start_background_load()
+
+    def _start_background_load(self) -> None:
+        """Start model loading in background thread."""
+        thread = threading.Thread(target=self._load_model, daemon=True)
+        thread.start()
+
+    def _load_model(self) -> None:
+        """Load the model (runs in background thread)."""
+        try:
+            # DEFERRED IMPORT - only happens in background thread
+            # This is the key optimization: sentence_transformers import is slow
+            from sentence_transformers import SentenceTransformer
+            model = SentenceTransformer(self.model_name)
+            with self._lock:
+                self._model = model
+                self._ready_event.set()
+        except Exception as e:
+            with self._lock:
+                self._load_error = e
+                self._ready_event.set()
+
+    def _ensure_model(self, timeout: float = 30.0):
+        """
+        Ensure model is loaded, waiting up to timeout seconds.
+
+        Args:
+            timeout: Maximum seconds to wait for model
+
+        Returns:
+            Loaded SentenceTransformer model
+
+        Raises:
+            EmbeddingModelNotReadyError: If model not ready within timeout
+        """
+        if not self._ready_event.wait(timeout=timeout):
+            raise EmbeddingModelNotReadyError(
+                f"Embedding model not ready after {timeout}s. Try again shortly."
+            )
+        if self._load_error:
+            raise EmbeddingModelNotReadyError(
+                f"Failed to load embedding model: {self._load_error}"
+            )
+        return self._model
+
+    def encode(self, text: Union[str, List[str]], timeout: float = 30.0) -> np.ndarray:
+        """
+        Encode text to embedding vector(s).
+
+        Args:
+            text: Single text string or list of texts
+            timeout: Maximum seconds to wait for model
+
+        Returns:
+            Numpy array of embeddings (1D for single text, 2D for list)
+
+        Raises:
+            EmbeddingModelNotReadyError: If model not ready within timeout
+        """
+        model = self._ensure_model(timeout)
+        embeddings = model.encode(text, convert_to_numpy=True)
+        # Ensure float32 for sqlite-vec compatibility
+        return embeddings.astype(np.float32)
+
+    def encode_single(self, text: str, timeout: float = 30.0) -> np.ndarray:
+        """
+        Encode single text to embedding vector.
+
+        Args:
+            text: Single text string
+            timeout: Maximum seconds to wait for model
+
+        Returns:
+            Numpy array of embedding (1D float32)
+
+        Raises:
+            EmbeddingModelNotReadyError: If model not ready within timeout
+        """
+        return self.encode(text, timeout)
+
+    def get_embedding_dim(self, timeout: float = 30.0) -> int:
+        """
+        Get embedding dimension.
+
+        Args:
+            timeout: Maximum seconds to wait for model
+
+        Returns:
+            Embedding dimension (e.g., 384 for all-MiniLM-L6-v2)
+        """
+        model = self._ensure_model(timeout)
+        return model.get_sentence_embedding_dimension()
+
+    def is_ready(self) -> bool:
+        """
+        Check if model is loaded and ready.
+
+        Returns:
+            True if model is ready for encoding
+        """
+        return self._ready_event.is_set() and self._model is not None and self._load_error is None
+
+
+def get_embedding_model(model_name: str, preload: bool = True) -> LazyEmbeddingModel:
+    """
+    Factory function to get embedding model instance.
+
+    Args:
+        model_name: HuggingFace model name
+        preload: If True, start loading model in background immediately
+
+    Returns:
+        Initialized LazyEmbeddingModel instance
+    """
+    return LazyEmbeddingModel(model_name, preload=preload)

{vector_task_mcp-1.2.7 → vector_task_mcp-1.2.9}/src/models.py

@@ -328,4 +328,8 @@ class Config:
     # Database configuration
     DB_NAME = "vector_tasks.db"
     EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
-    EMBEDDING_DIM = 384
+    EMBEDDING_DIM = 384
+
+    # Embedding model configuration
+    EMBEDDING_LOAD_TIMEOUT = 30.0  # Seconds to wait for model during operations
+    EMBEDDING_PRELOAD = True       # Start loading model in background on init

{vector_task_mcp-1.2.7 → vector_task_mcp-1.2.9}/src/task_store.py

@@ -22,7 +22,7 @@ from .security import (
     generate_content_hash, validate_file_path, validate_parent_id,
     validate_bulk_tasks_params, validate_bulk_task_ids
 )
-from .embeddings import get_embedding_model
+from .embeddings import get_embedding_model, EmbeddingModelNotReadyError
 
 
 class TaskStore:
@@ -261,6 +261,76 @@ class TaskStore:
         # Recursively propagate to grandparent
         self._propagate_pending_to_parents(conn, parent_id)
 
+    def _propagate_in_progress_to_parents(self, conn: sqlite3.Connection, task_id: int) -> None:
+        """
+        Recursively propagate 'in_progress' status to parent tasks when ANY child starts work.
+
+        Rules:
+        - Parent gets 'in_progress' when ANY child becomes 'in_progress'
+        - Only propagates if parent is currently 'pending' (not already in_progress/completed)
+        - Recursively propagates up the parent chain
+
+        Args:
+            conn: Active database connection (must be within transaction)
+            task_id: Current task ID whose status just changed to 'in_progress'
+        """
+        # Get parent_id and parent status
+        cursor = conn.execute('SELECT parent_id FROM tasks WHERE id = ?', (task_id,))
+        row = cursor.fetchone()
+        if not row or not row[0]:  # No parent
+            return
+
+        parent_id = row[0]
+
+        # Get parent's current status
+        parent_status_row = conn.execute('SELECT status FROM tasks WHERE id = ?', (parent_id,)).fetchone()
+        if not parent_status_row:
+            return
+
+        parent_status = parent_status_row[0]
+
+        # Only update parent if it's pending (not already working or completed)
+        if parent_status == 'pending':
+            conn.execute('UPDATE tasks SET status = ? WHERE id = ?', ('in_progress', parent_id))
+            # Recursively propagate to grandparent
+            self._propagate_in_progress_to_parents(conn, parent_id)
+
+    def _propagate_stopped_to_parents(self, conn: sqlite3.Connection, task_id: int) -> None:
+        """
+        Recursively propagate status to parent tasks when a child is stopped.
+
+        Rules:
+        - When a child is stopped and parent has no other in_progress children,
+          parent reverts to 'pending' (no active work)
+        - Recursively propagates up the parent chain
+
+        Args:
+            conn: Active database connection (must be within transaction)
+            task_id: Current task ID whose status just changed to 'stopped'
+        """
+        # Get parent_id
+        cursor = conn.execute('SELECT parent_id FROM tasks WHERE id = ?', (task_id,))
+        row = cursor.fetchone()
+        if not row or not row[0]:  # No parent
+            return
+
+        parent_id = row[0]
+
+        # Check if parent has any other in_progress children
+        in_progress_children = conn.execute(
+            'SELECT COUNT(*) FROM tasks WHERE parent_id = ? AND status = ? AND id != ?',
+            (parent_id, 'in_progress', task_id)
+        ).fetchone()[0]
+
+        # If no in_progress children remain, set parent to pending
+        if in_progress_children == 0:
+            # Get parent's current status
+            parent_status_row = conn.execute('SELECT status FROM tasks WHERE id = ?', (parent_id,)).fetchone()
+            if parent_status_row and parent_status_row[0] == 'in_progress':
+                conn.execute('UPDATE tasks SET status = ? WHERE id = ?', ('pending', parent_id))
+                # Recursively propagate to grandparent
+                self._propagate_stopped_to_parents(conn, parent_id)
+
     def _start_time_session(self, conn: sqlite3.Connection, task_id: int, start_status: str) -> None:
         """
         Create new time session record in task_time_log table.
@@ -403,7 +473,16 @@ class TaskStore:
                 }
 
             # Generate embedding from title + content
-            embedding = self.embedding_model.encode_single(combined)
+            try:
+                embedding = self.embedding_model.encode_single(combined, timeout=Config.EMBEDDING_LOAD_TIMEOUT)
+            except EmbeddingModelNotReadyError as e:
+                conn.close()
+                return {
+                    "success": False,
+                    "error": "model_loading",
+                    "message": str(e),
+                    "retry_after": 5
+                }
 
             # Calculate or validate order
             if validated_order is None:
@@ -556,7 +635,16 @@ class TaskStore:
                 }
 
             # Batch generate embeddings for all valid tasks
-            embeddings = self.embedding_model.encode(combined_texts)
+            try:
+                embeddings = self.embedding_model.encode(combined_texts, timeout=Config.EMBEDDING_LOAD_TIMEOUT)
+            except EmbeddingModelNotReadyError as e:
+                conn.close()
+                return {
+                    "success": False,
+                    "error": "model_loading",
+                    "message": str(e),
+                    "retry_after": 5
+                }
 
             # Second pass: insert tasks and vectors in single transaction
             for idx, metadata in enumerate(task_metadata):
@@ -840,7 +928,17 @@ class TaskStore:
                 update_values.append(new_hash)
 
                 # Generate new embedding
-                embedding = self.embedding_model.encode_single(combined)
+                try:
+                    embedding = self.embedding_model.encode_single(combined, timeout=Config.EMBEDDING_LOAD_TIMEOUT)
+                except EmbeddingModelNotReadyError as e:
+                    conn.rollback()
+                    conn.close()
+                    return {
+                        "success": False,
+                        "error": "model_loading",
+                        "message": str(e),
+                        "retry_after": 5
+                    }
                 embedding_blob = sqlite_vec.serialize_float32(embedding)
 
                 # Update vector
@@ -871,6 +969,10 @@ class TaskStore:
                 elif old_status == 'in_progress' and new_status != 'in_progress':
                     self._finish_time_session(conn, task_id, time_delta, new_status)
 
+            # Propagate 'in_progress' status to parent when ANY child starts work
+            if status_changed and new_status == 'in_progress':
+                self._propagate_in_progress_to_parents(conn, task_id)
+
             # Propagate 'completed' status to parent when ALL children are finished
             if status_changed and new_status in TaskStatus.finish_statuses():
                 self._propagate_completed_to_parents(conn, task_id)
@@ -879,6 +981,10 @@ class TaskStore:
             if status_changed and new_status == 'pending':
                 self._propagate_pending_to_parents(conn, task_id)
 
+            # Propagate 'pending' to parent when child is stopped and no other in_progress children
+            if status_changed and new_status == 'stopped':
+                self._propagate_stopped_to_parents(conn, task_id)
+
             conn.commit()
 
             # Fetch updated task
@@ -1356,7 +1462,20 @@ class TaskStore:
                 query = sanitize_input(query)
 
                 # Generate query embedding
-                query_embedding = self.embedding_model.encode_single(query)
+                try:
+                    query_embedding = self.embedding_model.encode_single(query, timeout=Config.EMBEDDING_LOAD_TIMEOUT)
+                except EmbeddingModelNotReadyError as e:
+                    conn.close()
+                    return {
+                        "tasks": [],
+                        "total_count": 0,
+                        "returned_count": 0,
+                        "offset": offset,
+                        "success": False,
+                        "error": "model_loading",
+                        "message": str(e),
+                        "retry_after": 5
+                    }
                 query_blob = sqlite_vec.serialize_float32(query_embedding)
 
                 # Build search query

{vector_task_mcp-1.2.7 → vector_task_mcp-1.2.9}/vector_task_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vector-task-mcp
-Version: 1.2.7
+Version: 1.2.9
 Summary: A secure, vector-based task management server for Claude Desktop using sqlite-vec and sentence-transformers
 Author-email: Xsaven <xsaven@gmail.com>
 License: MIT
@@ -23,6 +23,7 @@ License-File: LICENSE
 Requires-Dist: mcp>=0.3.0
 Requires-Dist: sqlite-vec>=0.1.6
 Requires-Dist: sentence-transformers>=2.2.2
+Requires-Dist: requests>=2.28.0
 Dynamic: license-file
 
 # Vector Task MCP Server

{vector_task_mcp-1.2.7 → vector_task_mcp-1.2.9}/vector_task_mcp.egg-info/requires.txt

@@ -1,3 +1,4 @@
 mcp>=0.3.0
 sqlite-vec>=0.1.6
 sentence-transformers>=2.2.2
+requests>=2.28.0

vector_task_mcp-1.2.7/src/embeddings.py

@@ -1,68 +0,0 @@
-"""
-Embedding Model Module
-======================
-
-Provides sentence transformer embedding functionality for semantic task search.
-"""
-
-from typing import List, Union
-import numpy as np
-from sentence_transformers import SentenceTransformer
-
-
-class EmbeddingModel:
-    """Wrapper for sentence transformer embedding model."""
-
-    def __init__(self, model_name: str):
-        """
-        Initialize embedding model.
-
-        Args:
-            model_name: HuggingFace model name (e.g., 'sentence-transformers/all-MiniLM-L6-v2')
-        """
-        self.model_name = model_name
-        self.model = SentenceTransformer(model_name)
-
-    def encode(self, text: Union[str, List[str]]) -> np.ndarray:
-        """
-        Encode text to embedding vector(s).
-
-        Args:
-            text: Single text string or list of texts
-
-        Returns:
-            Numpy array of embeddings (1D for single text, 2D for list)
-        """
-        embeddings = self.model.encode(text, convert_to_numpy=True)
-
-        # Ensure float32 for sqlite-vec compatibility
-        return embeddings.astype(np.float32)
-
-    def encode_single(self, text: str) -> np.ndarray:
-        """
-        Encode single text to embedding vector.
-
-        Args:
-            text: Single text string
-
-        Returns:
-            Numpy array of embedding (1D float32)
-        """
-        return self.encode(text)
-
-    def get_embedding_dim(self) -> int:
-        """Get embedding dimension."""
-        return self.model.get_sentence_embedding_dimension()
-
-
-def get_embedding_model(model_name: str) -> EmbeddingModel:
-    """
-    Factory function to get embedding model instance.
-
-    Args:
-        model_name: HuggingFace model name
-
-    Returns:
-        Initialized EmbeddingModel instance
-    """
-    return EmbeddingModel(model_name)