memstack-skill-loader 4.18.0__tar.gz → 4.18.1__tar.gz

{memstack_skill_loader-4.18.0/src/memstack_skill_loader.egg-info → memstack_skill_loader-4.18.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memstack-skill-loader
-Version: 4.18.0
+Version: 4.18.1
 Summary: MCP server that vector-indexes MemStack Pro skills for on-demand loading
 Project-URL: Homepage, https://memstack.pro
 Project-URL: Documentation, https://memstack.pro/docs

{memstack_skill_loader-4.18.0 → memstack_skill_loader-4.18.1}/pyproject.toml

@@ -1,51 +1,51 @@
-[build-system]
-requires = ["setuptools>=68.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "memstack-skill-loader"
-version = "4.18.0"
-description = "MCP server that vector-indexes MemStack Pro skills for on-demand loading"
-readme = "README.md"
-requires-python = ">=3.10"
-dependencies = [
-    # Upper bound is load-bearing: mcp 2.0.0 (2026-07-28) removed the
-    # Server.list_tools()/call_tool() decorator API that server.py is built on.
-    # Do not relax without porting server.py to the 2.x API first.
-    "mcp>=1.0.0,<2.0.0",
-    "lancedb>=0.6.0",
-    "sentence-transformers>=2.2.0",
-    "pyarrow>=14.0.0",
-    "httpx>=0.24.0",
-    "aiohttp>=3.9",
-]
-
-[project.urls]
-Homepage = "https://memstack.pro"
-Documentation = "https://memstack.pro/docs"
-
-[project.optional-dependencies]
-# setuptools is a TEST dependency here, not only a build dependency. The
-# packaging guard in tests/test_wheel_contents.py builds a wheel and inspects
-# it, and it fails rather than skips when the backend is absent, because a skip
-# is a silent pass. Python 3.12+ venvs no longer ship setuptools, so a bare venv
-# needs:  pip install -e ".[dev]"
-dev = ["setuptools>=68"]
-
-[project.scripts]
-memstack-index = "memstack_skill_loader.indexer:main"
-
-[tool.setuptools.packages.find]
-where = ["src"]
-
-[tool.setuptools.package-data]
-memstack_skill_loader = ["dashboard.html", "skill_descriptions.json"]
-
-[tool.pytest.ini_options]
-# Test the WORKING TREE, not whatever is installed. This package is installed
-# non-editable, so without this the suite imported memstack_skill_loader from
-# site-packages and silently graded a stale copy: a source change could be
-# green here and still be broken, and a new test could fail against code that
-# was already fixed. pythonpath puts src/ ahead of site-packages for the whole
-# suite, so `python -m pytest` needs no PYTHONPATH prefix to be correct.
-pythonpath = ["src"]
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "memstack-skill-loader"
+version = "4.18.1"
+description = "MCP server that vector-indexes MemStack Pro skills for on-demand loading"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    # Upper bound is load-bearing: mcp 2.0.0 (2026-07-28) removed the
+    # Server.list_tools()/call_tool() decorator API that server.py is built on.
+    # Do not relax without porting server.py to the 2.x API first.
+    "mcp>=1.0.0,<2.0.0",
+    "lancedb>=0.6.0",
+    "sentence-transformers>=2.2.0",
+    "pyarrow>=14.0.0",
+    "httpx>=0.24.0",
+    "aiohttp>=3.9",
+]
+
+[project.urls]
+Homepage = "https://memstack.pro"
+Documentation = "https://memstack.pro/docs"
+
+[project.optional-dependencies]
+# setuptools is a TEST dependency here, not only a build dependency. The
+# packaging guard in tests/test_wheel_contents.py builds a wheel and inspects
+# it, and it fails rather than skips when the backend is absent, because a skip
+# is a silent pass. Python 3.12+ venvs no longer ship setuptools, so a bare venv
+# needs:  pip install -e ".[dev]"
+dev = ["setuptools>=68"]
+
+[project.scripts]
+memstack-index = "memstack_skill_loader.indexer:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+memstack_skill_loader = ["dashboard.html", "skill_descriptions.json"]
+
+[tool.pytest.ini_options]
+# Test the WORKING TREE, not whatever is installed. This package is installed
+# non-editable, so without this the suite imported memstack_skill_loader from
+# site-packages and silently graded a stale copy: a source change could be
+# green here and still be broken, and a new test could fail against code that
+# was already fixed. pythonpath puts src/ ahead of site-packages for the whole
+# suite, so `python -m pytest` needs no PYTHONPATH prefix to be correct.
+pythonpath = ["src"]

{memstack_skill_loader-4.18.0 → memstack_skill_loader-4.18.1}/src/memstack_skill_loader/__init__.py

@@ -1,3 +1,3 @@
-"""MemStack Skill Loader — MCP server for semantic skill search."""
-
-__version__ = "4.18.0"
+"""MemStack Skill Loader — MCP server for semantic skill search."""
+
+__version__ = "4.18.1"

{memstack_skill_loader-4.18.0 → memstack_skill_loader-4.18.1}/src/memstack_skill_loader/memory_db.py

@@ -11,6 +11,18 @@ from pathlib import Path, PureWindowsPath
 DB_PATH = Path.home() / ".memstack" / "memory.db"
 SCHEMA_VERSION = 1
 
+#: Seconds a connection waits for a lock before raising "database is locked".
+#: Deliberately the same number as ``memory_engine._BUSY_TIMEOUT_S``: the two
+#: modules open connections to the SAME file, and a five-second waiter losing to
+#: a thirty-second one is a difference with no reason behind it.
+#:
+#: This is a cushion for TRANSIENT contention, not a fix for a held lock. The
+#: rehome migration used to compute its map inside its own BEGIN IMMEDIATE, so
+#: every connection opened here waited the full timeout and then failed no
+#: matter how large the number was — the holder was the caller. That map now
+#: runs before the write lock is taken, so this timeout should never be reached.
+_BUSY_TIMEOUT_S = 30
+
 # ── project_dir canonicalization ─────────────────────────────────────────────
 # project_dir was stored raw from os.getcwd(), which on Windows returns whichever
 # drive-letter case the process happened to be launched with. Two spellings of
@@ -63,11 +75,20 @@ def _resolve_db_path() -> Path:
 
 
 def _get_conn() -> sqlite3.Connection:
+    # NOTE: opening a connection WRITES. _init_tables ends with an
+    # "INSERT OR IGNORE INTO schema_version", and SQLite takes the write lock
+    # at statement start whether or not the row already exists. So this is not
+    # a read-only operation and must never be called from inside another
+    # transaction on the same file.
     db_path = _resolve_db_path()
     db_path.parent.mkdir(parents=True, exist_ok=True)
-    conn = sqlite3.connect(str(db_path), timeout=5)
+    conn = sqlite3.connect(str(db_path), timeout=_BUSY_TIMEOUT_S)
     conn.row_factory = sqlite3.Row
     conn.execute("PRAGMA journal_mode=WAL")
+    # Stated as a PRAGMA as well as the connect() kwarg. They set the same
+    # thing, but the PRAGMA is the one that survives a future refactor of the
+    # connect call, and it is the form the engine uses.
+    conn.execute(f"PRAGMA busy_timeout={_BUSY_TIMEOUT_S * 1000}")
     _init_tables(conn)
     return conn
 
@@ -771,59 +792,67 @@ def find_project_dirs_by_name(name: str) -> list[str]:
     stored paths are Windows backslash paths, and ``os.path.basename`` does not
     split on ``\\`` when this DB is read on a POSIX host. ``PureWindowsPath``
     treats both ``\\`` and ``/`` as separators regardless of the running OS.
-    """
-    try:
-        if name is None:
-            return []
-        if not isinstance(name, str):
-            name = str(name)
-        key = name.strip().lower()
-        if not key:
-            return []
 
-        conn = _get_conn()
-        try:
-            rows = conn.execute(
-                "SELECT DISTINCT project_dir FROM ("
-                "SELECT project_dir FROM context_facts "
-                "UNION SELECT project_dir FROM procedural_memory "
-                "UNION SELECT project_dir FROM session_summaries "
-                "UNION SELECT project_dir FROM temporal_events "
-                "UNION SELECT project_dir FROM failed_approaches"
-                ") WHERE project_dir IS NOT NULL"
-            ).fetchall()
-        finally:
-            conn.close()
+    RAISES on an unreachable store. This used to swallow every exception and
+    return ``[]``, which made "the store has never seen this project" and "the
+    store could not be read" the same answer. That cost a data migration: the
+    rehome migration's fail-open tripwire lives in ``diary_ingest._resolves``,
+    one level ABOVE this function, and could never fire because the exception
+    died here. A caller that wants to continue without an answer catches it and
+    says so; a caller that must not guess lets it propagate. Both exist.
 
-        matches = set()
-        for row in rows:
-            pdir = row[0]
-            if not pdir:
-                continue
-            if PureWindowsPath(pdir).name.lower() == key:
-                matches.add(pdir)
-
-        # Collapse spellings that denote the SAME directory (drive-letter case,
-        # separator style) before counting — otherwise one stray "c:\..." row
-        # turns a perfectly well-known project into an ambiguous one. Distinct
-        # directories that merely share a basename remain separate entries.
-        groups: dict = {}
-        for match in matches:
-            groups.setdefault(_project_dir_key(match), []).append(match)
-
-        # Deterministic representative per group: sorted() puts the upper-case
-        # drive first, and canonicalizing makes the result independent of which
-        # spellings happen to be in the store.
-        return sorted(
-            canonical_project_dir(sorted(spellings)[0])
-            for spellings in groups.values()
-        )
-    except Exception as exc:
-        print(
-            f"[memstack-memory] find_project_dirs_by_name failed: {exc}",
-            file=sys.stderr,
-        )
+    Removing the swallow also removed a ``print`` of the raw exception text.
+    That string is not allowlisted and could carry a path or a connection
+    string, so the callers now report the exception CLASS and nothing else.
+
+    Bad INPUT is still not an error: None, a non-string and an empty name all
+    return ``[]``, because those are answerable questions whose answer is "no".
+    """
+    if name is None:
         return []
+    if not isinstance(name, str):
+        name = str(name)
+    key = name.strip().lower()
+    if not key:
+        return []
+
+    conn = _get_conn()
+    try:
+        rows = conn.execute(
+            "SELECT DISTINCT project_dir FROM ("
+            "SELECT project_dir FROM context_facts "
+            "UNION SELECT project_dir FROM procedural_memory "
+            "UNION SELECT project_dir FROM session_summaries "
+            "UNION SELECT project_dir FROM temporal_events "
+            "UNION SELECT project_dir FROM failed_approaches"
+            ") WHERE project_dir IS NOT NULL"
+        ).fetchall()
+    finally:
+        conn.close()
+
+    matches = set()
+    for row in rows:
+        pdir = row[0]
+        if not pdir:
+            continue
+        if PureWindowsPath(pdir).name.lower() == key:
+            matches.add(pdir)
+
+    # Collapse spellings that denote the SAME directory (drive-letter case,
+    # separator style) before counting — otherwise one stray "c:\..." row
+    # turns a perfectly well-known project into an ambiguous one. Distinct
+    # directories that merely share a basename remain separate entries.
+    groups: dict = {}
+    for match in matches:
+        groups.setdefault(_project_dir_key(match), []).append(match)
+
+    # Deterministic representative per group: sorted() puts the upper-case
+    # drive first, and canonicalizing makes the result independent of which
+    # spellings happen to be in the store.
+    return sorted(
+        canonical_project_dir(sorted(spellings)[0])
+        for spellings in groups.values()
+    )
 
 
 def resolve_project_dir_by_name(name: str) -> str | None:
@@ -833,8 +862,24 @@ def resolve_project_dir_by_name(name: str) -> str | None:
     no sensible behavior for a collision. Callers that must distinguish "never
     seen" from "shares a basename with another project" — and act differently —
     should use :func:`find_project_dirs_by_name` and inspect the length.
+
+    FAIL-OPEN, and this is where that decision now lives rather than inside the
+    lookup. Every caller of this function already treats ``None`` as "no usable
+    path", so an unreachable store degrading to ``None`` changes nothing for
+    them, and the alternative — raising into paths that only wanted a directory
+    name — would break working features to report a condition they cannot act
+    on. Only the exception CLASS is printed; the message is attacker-influenced
+    free text and is never echoed.
     """
-    matches = find_project_dirs_by_name(name)
+    try:
+        matches = find_project_dirs_by_name(name)
+    except Exception as exc:  # noqa: BLE001 -- see FAIL-OPEN above
+        print(
+            f"[memstack-memory] project lookup failed ({type(exc).__name__}); "
+            f"treating the project as unknown",
+            file=sys.stderr,
+        )
+        return None
     return matches[0] if len(matches) == 1 else None