memstack-skill-loader 3.5.0__py3-none-any.whl

memstack_skill_loader/stats.py

@@ -0,0 +1,428 @@
+"""Local usage analytics — SQLite-backed skill fire tracking and dashboard data."""
+
+import sqlite3
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+DB_PATH = Path.home() / ".memstack" / "stats.db"
+
+
+def _get_conn() -> sqlite3.Connection:
+    """Open (and initialize) the stats database."""
+    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(DB_PATH), timeout=5)
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS skill_fires (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            skill_name TEXT NOT NULL,
+            category TEXT,
+            project TEXT,
+            tool TEXT,
+            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS daily_summary (
+            date TEXT PRIMARY KEY,
+            total_fires INTEGER DEFAULT 0,
+            unique_skills INTEGER DEFAULT 0,
+            unique_projects INTEGER DEFAULT 0
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS compression_stats (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            skill_name TEXT NOT NULL,
+            tokens_before INTEGER NOT NULL,
+            tokens_after INTEGER NOT NULL,
+            tier TEXT,
+            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+        """
+    )
+    conn.commit()
+    return conn
+
+
+def log_skill_fire(
+    skill_name: str,
+    category: str | None = None,
+    project: str | None = None,
+    tool: str | None = None,
+) -> None:
+    """Record a skill activation. Silently swallows all errors."""
+    try:
+        conn = _get_conn()
+        try:
+            today = datetime.now().strftime("%Y-%m-%d")
+
+            conn.execute(
+                "INSERT INTO skill_fires (skill_name, category, project, tool) VALUES (?, ?, ?, ?)",
+                (skill_name, category, project, tool),
+            )
+
+            # Upsert daily_summary for today
+            row = conn.execute(
+                """
+                SELECT COUNT(*), COUNT(DISTINCT skill_name), COUNT(DISTINCT project)
+                FROM skill_fires WHERE date(timestamp) = ?
+                """,
+                (today,),
+            ).fetchone()
+
+            conn.execute(
+                """
+                INSERT INTO daily_summary (date, total_fires, unique_skills, unique_projects)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT(date) DO UPDATE SET
+                    total_fires = excluded.total_fires,
+                    unique_skills = excluded.unique_skills,
+                    unique_projects = excluded.unique_projects
+                """,
+                (today, row[0], row[1], row[2]),
+            )
+            conn.commit()
+        finally:
+            conn.close()
+    except Exception as exc:
+        print(f"[memstack-stats] log_skill_fire failed: {exc}", file=sys.stderr)
+
+
+def log_compression(
+    skill_name: str,
+    tokens_before: int,
+    tokens_after: int,
+    tier: str = "free",
+) -> None:
+    """Record a compression event."""
+    try:
+        conn = _get_conn()
+        try:
+            conn.execute(
+                "INSERT INTO compression_stats (skill_name, tokens_before, tokens_after, tier) "
+                "VALUES (?, ?, ?, ?)",
+                (skill_name, tokens_before, tokens_after, tier),
+            )
+            conn.commit()
+        finally:
+            conn.close()
+    except Exception as exc:
+        print(f"[memstack-stats] log_compression failed: {exc}", file=sys.stderr)
+
+
+def get_compression_stats() -> dict:
+    """Return aggregate compression stats for dashboard."""
+    try:
+        conn = _get_conn()
+        try:
+            row = conn.execute(
+                "SELECT COUNT(*), COALESCE(SUM(tokens_before), 0), "
+                "COALESCE(SUM(tokens_after), 0) FROM compression_stats"
+            ).fetchone()
+            total_events = row[0]
+            total_before = row[1]
+            total_after = row[2]
+            total_saved = total_before - total_after
+            ratio = round(total_saved / total_before * 100, 1) if total_before > 0 else 0.0
+
+            # Per-skill breakdown (top 10)
+            per_skill = conn.execute(
+                "SELECT skill_name, COUNT(*), SUM(tokens_before), SUM(tokens_after) "
+                "FROM compression_stats GROUP BY skill_name "
+                "ORDER BY SUM(tokens_before) - SUM(tokens_after) DESC LIMIT 10"
+            ).fetchall()
+
+            return {
+                "total_compressions": total_events,
+                "total_tokens_before": total_before,
+                "total_tokens_after": total_after,
+                "total_tokens_saved": total_saved,
+                "avg_compression_pct": ratio,
+                "top_skills": [
+                    {
+                        "name": r[0],
+                        "compressions": r[1],
+                        "tokens_saved": r[2] - r[3],
+                        "avg_pct": round((r[2] - r[3]) / r[2] * 100, 1) if r[2] > 0 else 0,
+                    }
+                    for r in per_skill
+                ],
+            }
+        finally:
+            conn.close()
+    except Exception as exc:
+        print(f"[memstack-stats] get_compression_stats failed: {exc}", file=sys.stderr)
+        return {"total_compressions": 0, "total_tokens_saved": 0}
+
+
+def get_dashboard_data() -> dict:
+    """Return a dict of dashboard metrics. Returns sensible defaults if no data exists."""
+    defaults = {
+        "total_fires": 0,
+        "unique_skills_used": 0,
+        "total_sessions": 0,
+        "fires_today": 0,
+        "top_skills": [],
+        "category_breakdown": [],
+        "daily_trend": [],
+        "project_breakdown": [],
+        "context_saved_estimate": 0,
+        "dollar_savings": 0.0,
+        "most_active_project": None,
+    }
+    try:
+        if not DB_PATH.exists():
+            return defaults
+
+        conn = _get_conn()
+        try:
+            today = datetime.now().strftime("%Y-%m-%d")
+
+            # All-time totals
+            total_fires = conn.execute("SELECT COUNT(*) FROM skill_fires").fetchone()[0]
+            unique_skills = conn.execute(
+                "SELECT COUNT(DISTINCT skill_name) FROM skill_fires"
+            ).fetchone()[0]
+            total_sessions = conn.execute(
+                "SELECT COUNT(DISTINCT date(timestamp)) FROM skill_fires"
+            ).fetchone()[0]
+
+            # Today
+            fires_today = conn.execute(
+                "SELECT COUNT(*) FROM skill_fires WHERE date(timestamp) = ?",
+                (today,),
+            ).fetchone()[0]
+
+            # Top skills — last 7 days
+            seven_days_ago = (datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
+            top_skills = conn.execute(
+                """
+                SELECT skill_name, COUNT(*) as cnt
+                FROM skill_fires WHERE date(timestamp) >= ?
+                GROUP BY skill_name ORDER BY cnt DESC LIMIT 10
+                """,
+                (seven_days_ago,),
+            ).fetchall()
+
+            # Category breakdown — last 7 days
+            category_breakdown = conn.execute(
+                """
+                SELECT COALESCE(category, 'uncategorized') as cat, COUNT(*) as cnt
+                FROM skill_fires WHERE date(timestamp) >= ?
+                GROUP BY cat ORDER BY cnt DESC
+                """,
+                (seven_days_ago,),
+            ).fetchall()
+
+            # Daily trend — last 14 days (include zero-count days)
+            fourteen_days_ago = datetime.now() - timedelta(days=13)
+            daily_counts = dict(
+                conn.execute(
+                    """
+                    SELECT date(timestamp), COUNT(*)
+                    FROM skill_fires WHERE date(timestamp) >= ?
+                    GROUP BY date(timestamp)
+                    """,
+                    (fourteen_days_ago.strftime("%Y-%m-%d"),),
+                ).fetchall()
+            )
+            daily_trend = []
+            for i in range(14):
+                d = (fourteen_days_ago + timedelta(days=i)).strftime("%Y-%m-%d")
+                daily_trend.append({"date": d, "count": daily_counts.get(d, 0)})
+
+            # Project breakdown — all time, top 10
+            project_breakdown = conn.execute(
+                """
+                SELECT COALESCE(project, 'unknown') as proj, COUNT(*) as cnt
+                FROM skill_fires
+                GROUP BY proj ORDER BY cnt DESC LIMIT 10
+                """
+            ).fetchall()
+
+            # Most active project this week
+            most_active_project = conn.execute(
+                """
+                SELECT COALESCE(project, 'unknown') as proj, COUNT(*) as cnt
+                FROM skill_fires WHERE date(timestamp) >= ?
+                GROUP BY proj ORDER BY cnt DESC LIMIT 1
+                """,
+                (seven_days_ago,),
+            ).fetchone()
+
+            tokens_saved = total_fires * 1700
+            dollar_savings = round((tokens_saved / 1_000_000) * 15, 2)
+
+            return {
+                "total_fires": total_fires,
+                "unique_skills_used": unique_skills,
+                "total_sessions": total_sessions,
+                "fires_today": fires_today,
+                "top_skills": [{"name": r[0], "count": r[1]} for r in top_skills],
+                "category_breakdown": [
+                    {"category": r[0], "count": r[1]} for r in category_breakdown
+                ],
+                "daily_trend": daily_trend,
+                "project_breakdown": [
+                    {"project": r[0], "count": r[1]} for r in project_breakdown
+                ],
+                "context_saved_estimate": tokens_saved,
+                "dollar_savings": dollar_savings,
+                "most_active_project": {
+                    "name": most_active_project[0],
+                    "fires": most_active_project[1],
+                } if most_active_project else None,
+            }
+        finally:
+            conn.close()
+    except Exception as exc:
+        print(f"[memstack-stats] get_dashboard_data failed: {exc}", file=sys.stderr)
+        return defaults
+
+
+def get_project_details() -> list[dict]:
+    """Return per-project stats: total fires, last active, top 3 skills."""
+    try:
+        if not DB_PATH.exists():
+            return []
+        conn = _get_conn()
+        try:
+            rows = conn.execute(
+                """
+                SELECT COALESCE(project, 'unknown') as proj,
+                       COUNT(*) as cnt,
+                       MAX(timestamp) as last_active
+                FROM skill_fires
+                GROUP BY proj ORDER BY cnt DESC
+                """
+            ).fetchall()
+            projects = []
+            for proj_name, cnt, last_active in rows:
+                top_skills = conn.execute(
+                    """
+                    SELECT skill_name, COUNT(*) as c
+                    FROM skill_fires WHERE COALESCE(project, 'unknown') = ?
+                    AND skill_name NOT LIKE '@_%' ESCAPE '@'
+                    GROUP BY skill_name ORDER BY c DESC LIMIT 3
+                    """,
+                    (proj_name,),
+                ).fetchall()
+                projects.append({
+                    "name": proj_name,
+                    "total_fires": cnt,
+                    "last_active": last_active,
+                    "top_skills": [{"name": s[0], "count": s[1]} for s in top_skills],
+                })
+            return projects
+        finally:
+            conn.close()
+    except Exception as exc:
+        print(f"[memstack-stats] get_project_details failed: {exc}", file=sys.stderr)
+        return []
+
+
+def backfill_categories(category_map: dict[str, str]) -> int:
+    """Backfill NULL categories in existing skill_fires using a slug->category map.
+
+    Handles emoji-prefixed display names (e.g. "🛡️ OWASP Top 10") by stripping
+    non-ASCII chars before converting to slug form for matching.
+
+    Returns the number of rows updated.
+    """
+    import re
+
+    def _to_slug(name: str) -> str:
+        """Convert a display name to a slug for category map lookup."""
+        # Strip emoji and non-ASCII characters
+        clean = re.sub(r'[^\x00-\x7F]+', '', name).strip()
+        # Convert to lowercase slug
+        return clean.lower().replace(" ", "-").replace("_", "-")
+
+    updated = 0
+    try:
+        conn = _get_conn()
+        try:
+            rows = conn.execute(
+                "SELECT DISTINCT skill_name FROM skill_fires WHERE category IS NULL"
+            ).fetchall()
+
+            for (skill_name,) in rows:
+                slug = _to_slug(skill_name)
+                # For internal names like __list__, use the raw name as slug
+                if skill_name.startswith("__"):
+                    slug = skill_name
+                category = category_map.get(slug)
+
+                if not category:
+                    # Try substring matching against map keys
+                    for map_slug, map_cat in category_map.items():
+                        if map_slug in slug or slug in map_slug:
+                            category = map_cat
+                            break
+
+                if category:
+                    conn.execute(
+                        "UPDATE skill_fires SET category = ? WHERE skill_name = ? AND category IS NULL",
+                        (category, skill_name),
+                    )
+                    updated += 1
+
+            conn.commit()
+        finally:
+            conn.close()
+    except Exception as exc:
+        print(f"[memstack-stats] backfill_categories failed: {exc}", file=sys.stderr)
+    return updated
+
+
+def get_recent_activity(limit: int = 10) -> list[dict]:
+    """Return the most recent skill fires for the activity feed."""
+    try:
+        conn = _get_conn()
+        try:
+            rows = conn.execute(
+                "SELECT timestamp, skill_name, category, project "
+                "FROM skill_fires "
+                "WHERE skill_name NOT LIKE '@_%' ESCAPE '@' "
+                "ORDER BY timestamp DESC LIMIT ?",
+                (limit,),
+            ).fetchall()
+            return [
+                {
+                    "timestamp": row[0],
+                    "skill_name": row[1],
+                    "category": row[2],
+                    "project": row[3],
+                }
+                for row in rows
+            ]
+        finally:
+            conn.close()
+    except Exception as exc:
+        print(f"[memstack-stats] get_recent_activity failed: {exc}", file=sys.stderr)
+        return []
+
+
+def get_skill_fire_counts() -> dict[str, int]:
+    """Return {skill_name: fire_count} for all skills (excluding internal names)."""
+    try:
+        conn = _get_conn()
+        try:
+            rows = conn.execute(
+                "SELECT skill_name, COUNT(*) FROM skill_fires "
+                "WHERE skill_name NOT LIKE '@_%' ESCAPE '@' "
+                "GROUP BY skill_name"
+            ).fetchall()
+            return {row[0]: row[1] for row in rows}
+        finally:
+            conn.close()
+    except Exception as exc:
+        print(f"[memstack-stats] get_skill_fire_counts failed: {exc}", file=sys.stderr)
+        return {}

memstack_skill_loader/tfidf_search.py

@@ -0,0 +1,142 @@
+"""Lightweight TF-IDF search against pre-built skill index.
+
+This module replaces the heavy sentence-transformers/PyTorch search
+with scikit-learn TF-IDF, cutting cold start from ~10s to ~2s.
+The TF-IDF index is built at index time by indexer.py and loaded
+from a pickle file at search time.
+"""
+
+import pickle
+import sys
+from pathlib import Path
+
+from sklearn.metrics.pairwise import cosine_similarity
+
+from .config import Config, load_config
+
+# Lazy-loaded singletons
+_index = None  # dict with 'vectorizer', 'matrix', 'skills'
+
+
+def _get_index(config: Config) -> dict | None:
+    """Load the pre-built TF-IDF index from pickle."""
+    global _index
+    if _index is not None:
+        return _index
+
+    pkl_path = config.resolved_vector_db_path / "tfidf_index.pkl"
+    if not pkl_path.exists():
+        print(f"TF-IDF index not found at {pkl_path}. Run index_skills.py first.", file=sys.stderr)
+        return None
+
+    try:
+        with open(pkl_path, "rb") as f:
+            _index = pickle.load(f)
+        print(f"Loaded TF-IDF index: {len(_index['skills'])} skills", file=sys.stderr)
+        return _index
+    except Exception as e:
+        print(f"Error loading TF-IDF index: {e}", file=sys.stderr)
+        return None
+
+
+def search_skills(query: str, config: Config, top_k: int = 3) -> list[dict]:
+    """Search skills using TF-IDF cosine similarity."""
+    index = _get_index(config)
+    if index is None:
+        return []
+
+    vectorizer = index["vectorizer"]
+    matrix = index["matrix"]
+    skills = index["skills"]
+
+    query_vec = vectorizer.transform([query])
+    similarities = cosine_similarity(query_vec, matrix)[0]
+
+    # Get top-k indices sorted by score descending
+    ranked = sorted(range(len(similarities)), key=lambda i: similarities[i], reverse=True)[:top_k]
+
+    results = []
+    for idx in ranked:
+        score = round(float(similarities[idx]), 4)
+        if score <= 0:
+            continue
+        skill = skills[idx]
+        results.append({
+            "name": skill["name"],
+            "slug": skill["slug"],
+            "description": skill["description"],
+            "source_label": skill["source_label"],
+            "content": skill["content"],
+            "filepath": skill["filepath"],
+            "score": score,
+        })
+
+    return results
+
+
+def list_all_skills(config: Config) -> list[dict]:
+    """Return all indexed skills (name, description, source_label)."""
+    index = _get_index(config)
+    if index is None:
+        return []
+
+    return sorted(
+        [
+            {
+                "name": s["name"],
+                "slug": s["slug"],
+                "description": s["description"],
+                "source_label": s["source_label"],
+            }
+            for s in index["skills"]
+        ],
+        key=lambda s: s["name"],
+    )
+
+
+def get_skill_by_name(name: str, config: Config) -> dict | None:
+    """Find a skill by name: exact match -> substring -> TF-IDF fallback."""
+    index = _get_index(config)
+    if index is None:
+        return None
+
+    skills = index["skills"]
+    name_lower = name.strip().lower()
+
+    # Stage 1: exact match (by name or slug)
+    for skill in skills:
+        if skill["name"].lower() == name_lower or skill["slug"] == name_lower:
+            return {
+                "name": skill["name"],
+                "slug": skill["slug"],
+                "description": skill["description"],
+                "source_label": skill["source_label"],
+                "content": skill["content"],
+                "filepath": skill["filepath"],
+            }
+
+    # Stage 2: substring fuzzy match
+    for skill in skills:
+        skill_lower = skill["name"].lower()
+        if name_lower in skill_lower or skill_lower in name_lower:
+            return {
+                "name": skill["name"],
+                "slug": skill["slug"],
+                "description": skill["description"],
+                "source_label": skill["source_label"],
+                "content": skill["content"],
+                "filepath": skill["filepath"],
+            }
+
+    # Stage 3: TF-IDF search fallback
+    results = search_skills(name, config, top_k=1)
+    if results and results[0]["score"] > 0.3:
+        return results[0]
+
+    return None
+
+
+def reset_cache():
+    """Clear cached index so next query reloads from disk."""
+    global _index
+    _index = None

memstack_skill_loader/version_check.py

@@ -0,0 +1,93 @@
+"""Check for MemStack updates via GitHub releases API."""
+
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+GITHUB_API_URL = "https://api.github.com/repos/cwinvestments/memstack/releases/latest"
+CACHE_FILE = Path.home() / ".memstack" / "version-check.json"
+CACHE_TTL = 86400  # 24 hours in seconds
+
+
+def _read_local_version() -> str | None:
+    """Read the VERSION file from the parent memstack repo directory."""
+    # The skill loader lives inside memstack, so walk up to find VERSION
+    loader_dir = Path(__file__).resolve().parent
+    for parent in [loader_dir] + list(loader_dir.parents):
+        version_file = parent / "VERSION"
+        if version_file.exists():
+            try:
+                return version_file.read_text(encoding="utf-8").strip()
+            except OSError:
+                return None
+    return None
+
+
+def _read_cache() -> dict | None:
+    """Read cached version check result if still valid."""
+    try:
+        if not CACHE_FILE.exists():
+            return None
+        data = json.loads(CACHE_FILE.read_text(encoding="utf-8"))
+        if time.time() - data.get("checked_at", 0) < CACHE_TTL:
+            return data
+    except (json.JSONDecodeError, OSError, KeyError):
+        pass
+    return None
+
+
+def _write_cache(remote_version: str) -> None:
+    """Cache the remote version check result."""
+    try:
+        CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        CACHE_FILE.write_text(
+            json.dumps({"remote_version": remote_version, "checked_at": time.time()}, indent=2),
+            encoding="utf-8",
+        )
+    except OSError:
+        pass
+
+
+def check_for_updates() -> None:
+    """Check GitHub for a newer MemStack version. Prints to stderr if update available."""
+    try:
+        local_version = _read_local_version()
+        if not local_version:
+            return
+
+        # Check cache first
+        cached = _read_cache()
+        if cached:
+            remote_version = cached.get("remote_version", "")
+            if remote_version and remote_version != local_version:
+                print(
+                    f"[memstack] Update available: {remote_version} (you have {local_version}). "
+                    f"Run 'git pull' in your MemStack\u2122 directory to update.",
+                    file=sys.stderr,
+                )
+            return
+
+        # Fetch from GitHub API
+        import httpx
+        response = httpx.get(GITHUB_API_URL, timeout=5.0, follow_redirects=True)
+        if response.status_code != 200:
+            return
+
+        data = response.json()
+        remote_version = data.get("tag_name", "")
+        if not remote_version:
+            return
+
+        _write_cache(remote_version)
+
+        if remote_version != local_version:
+            print(
+                f"[memstack] Update available: {remote_version} (you have {local_version}). "
+                f"Run 'git pull' in your MemStack\u2122 directory to update.",
+                file=sys.stderr,
+            )
+    except Exception:
+        # Silently skip on any error — never block skill loading
+        pass

memstack_skill_loader-3.5.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: memstack-skill-loader
+Version: 3.5.0
+Summary: MCP server that vector-indexes MemStack Pro skills for on-demand loading
+Requires-Python: >=3.12
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: lancedb>=0.6.0
+Requires-Dist: sentence-transformers>=2.2.0
+Requires-Dist: pyarrow>=14.0.0
+Requires-Dist: httpx>=0.24.0

memstack_skill_loader-3.5.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+memstack_skill_loader/__init__.py,sha256=zIctJ-xsmRIAzE7HmG1Z4kDvbjiB8rxQT0LOmb1Fga0,71
+memstack_skill_loader/__main__.py,sha256=f4T6TuX1EPI4bHi-LOEWavdax2uDeG9J6mkoE-d8uzE,346
+memstack_skill_loader/compression.py,sha256=5NQMYa9wj6dyAA6OU1z6Udma96KZj6bFJmYrr0kGcDw,11761
+memstack_skill_loader/config.py,sha256=vQZr4DOM4cEL3oXm1xB1lqldNpXwEMcKyUtuiMXuqV4,4137
+memstack_skill_loader/dashboard.html,sha256=QGetBqAWZEmQc0CSLEpHlbZc9nLlwtr_-HpEcG4yyjc,34547
+memstack_skill_loader/dashboard.py,sha256=StM1ibJ6L0YLRMynwgmIWNl4uO-Z4CmAz2Hh4OkzRXI,13707
+memstack_skill_loader/indexer.py,sha256=hvKvJ8NTX-JpSEZ4G-6-qOCVMowj8jmmfeKVtlQhqpM,8276
+memstack_skill_loader/license.py,sha256=aVGKO30hEUuO7SJYbjhP7fmvX8R6V6smMMgWa7r9sn4,15789
+memstack_skill_loader/search.py,sha256=rKrYNqblgkl00XRcCIBg-PobCNCfiEiWWk_OmX7CGlg,4995
+memstack_skill_loader/server.py,sha256=-QoIBFrohMjak1DHjIv_EMOUaYd_4bAoaVeqZ6DgrSQ,36471
+memstack_skill_loader/stats.py,sha256=ynx75NyrUSzWq336e3_p38MTAWiDISVUC14vq69QKho,15651
+memstack_skill_loader/tfidf_search.py,sha256=QtNuQpdL261EIIoyqizv7psBVsH52uqDn7oHln8gfRQ,4473
+memstack_skill_loader/version_check.py,sha256=zuR0w3r_FNMeWoiUFinX_xRrClof92l2RjE9rI91VtI,3183
+memstack_skill_loader-3.5.0.dist-info/METADATA,sha256=NtRQ7EYvnYKJncLPejA8HlfnAZeArdogjiKaqiR6UAc,341
+memstack_skill_loader-3.5.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+memstack_skill_loader-3.5.0.dist-info/entry_points.txt,sha256=pbqO6c8Gtff3boho-pDlAOpt4s6JdCNtV0xGiqIQkuA,70
+memstack_skill_loader-3.5.0.dist-info/top_level.txt,sha256=tPNsHqnSWoQ8AYfLRRJR3fpHOWSSjoQzAE5FjJIiKPw,22
+memstack_skill_loader-3.5.0.dist-info/RECORD,,