memstack-skill-loader 4.4.0__tar.gz → 4.5.0__tar.gz

{memstack_skill_loader-4.4.0/src/memstack_skill_loader.egg-info → memstack_skill_loader-4.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memstack-skill-loader
-Version: 4.4.0
+Version: 4.5.0
 Summary: MCP server that vector-indexes MemStack Pro skills for on-demand loading
 Requires-Python: >=3.10
 Requires-Dist: mcp>=1.0.0

{memstack_skill_loader-4.4.0 → memstack_skill_loader-4.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memstack-skill-loader"
-version = "4.4.0"
+version = "4.5.0"
 description = "MCP server that vector-indexes MemStack Pro skills for on-demand loading"
 requires-python = ">=3.10"
 dependencies = [

{memstack_skill_loader-4.4.0 → memstack_skill_loader-4.5.0}/src/memstack_skill_loader/__init__.py

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

{memstack_skill_loader-4.4.0 → memstack_skill_loader-4.5.0}/src/memstack_skill_loader/dashboard.html

@@ -546,6 +546,39 @@
   .diary-pagination .diary-pg-btn { font-size: 0.78rem; color: #58a6ff; cursor: pointer; background: none; border: 1px solid #30363d; border-radius: 4px; padding: 0.25rem 0.7rem; }
   .diary-pagination .diary-pg-btn:hover { border-color: #58a6ff; }
 
+  /* ── Memory Browser ── */
+  .mb-controls { display: flex; gap: 0.6rem; align-items: center; margin-bottom: 0.9rem; flex-wrap: wrap; }
+  .mb-select, .mb-search {
+    background: #0d1117; border: 1px solid #30363d; color: #c9d1d9;
+    padding: 0.4rem 0.6rem; border-radius: 6px; font-size: 0.82rem;
+  }
+  .mb-search { flex: 1; min-width: 200px; }
+  .mb-search:focus, .mb-select:focus { outline: none; border-color: #58a6ff; }
+  .mb-count { font-size: 0.75rem; color: #484f58; white-space: nowrap; }
+  .mb-entry { cursor: pointer; transition: border-color 0.15s; }
+  .mb-entry:hover { border-color: #58a6ff; }
+  .mb-badges { display: flex; gap: 0.4rem; align-items: center; flex-wrap: wrap; }
+  .mb-badge {
+    font-size: 0.66rem; padding: 0.1rem 0.45rem; border-radius: 10px;
+    border: 1px solid #30363d; color: #8b949e; white-space: nowrap;
+  }
+  .mb-badge.project { color: #58a6ff; border-color: #1f4068; }
+  .mb-badge.agent { color: #d29922; border-color: #5a4413; }
+  .mb-badge.direct { color: #3fb950; border-color: #1b4721; }
+  .mb-detail-head { display: flex; justify-content: space-between; align-items: center; gap: 0.6rem; margin-bottom: 0.5rem; flex-wrap: wrap; }
+  .mb-back {
+    background: #21262d; border: 1px solid #30363d; color: #c9d1d9;
+    padding: 0.3rem 0.7rem; border-radius: 6px; cursor: pointer; font-size: 0.78rem;
+  }
+  .mb-back:hover { border-color: #58a6ff; }
+  .mb-detail-actions { display: flex; gap: 0.5rem; align-items: center; }
+  .mb-detail-title { color: #e6edf3; font-size: 1rem; margin-bottom: 0.6rem; }
+  .mb-detail-content {
+    background: #0d1117; border: 1px solid #21262d; border-radius: 6px;
+    padding: 1rem; font-size: 0.8rem; color: #c9d1d9; line-height: 1.5;
+    white-space: pre-wrap; word-break: break-word; max-height: 65vh; overflow-y: auto;
+  }
+
   /* ── Projects ── */
   .projects-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); gap: 1rem; }
   .project-card {
@@ -1656,13 +1689,18 @@
 
 <!-- ═══════ Memory Browser ═══════ -->
 <div id="page-memory-browser" class="page">
-  <div class="placeholder-page">
-    <div class="placeholder-card">
-      <div class="icon">&#128218;</div>
-      <h3>Memory Browser</h3>
-      <div class="version-badge">Coming in v4.1</div>
-      <p>Search across sessions, lessons, and facts from your development history. Memory capture pipelines are being refined for the next release.</p>
+  <div class="page-header">
+    <h2>Memory Browser</h2>
+    <p class="meta">Search session diaries across all projects (agent runs and direct sessions).</p>
+  </div>
+  <div class="panel">
+    <div class="mb-controls">
+      <select id="mb-project" class="mb-select" aria-label="Project filter"></select>
+      <input id="mb-search" class="mb-search" type="text" placeholder="Search title and content..." autocomplete="off">
+      <span id="mb-count" class="mb-count"></span>
     </div>
+    <div id="mb-list" class="diary-list"></div>
+    <div id="mb-detail" class="mb-detail" style="display:none;"></div>
   </div>
 </div>
 
@@ -2194,6 +2232,7 @@ document.querySelectorAll('.nav-item').forEach(item => {
     if (page === 'overview' && !projectsLoaded) loadProjects();
     if (page === 'overview') { updateWelcomeGreeting(); loadDiary(); }
     if (page === 'agent-monitor') loadAgentMonitor();
+    if (page === 'memory-browser') loadMemoryBrowser();
     if (page === 'burn-report') loadBurnReport();
     if (page === 'settings') loadSettings();
     if (page !== 'agent-monitor') stopAgentRefresh();
@@ -2922,7 +2961,166 @@ async function loadProjects() {
   }
 }
 
-/* Memory Browser — placeholder, full implementation coming in v4.1 */
+/* ════════════════════════════════════════════
+   Memory Browser
+   ════════════════════════════════════════════ */
+let _mbEntries = [];
+let _mbLoaded = false;
+
+// Mask secrets/PII so they are never rendered in plain sight.
+function maskSecrets(text) {
+  if (!text) return '';
+  return text
+    .replace(/MSPRO-[A-Z0-9-]{4,}/gi, 'MSPRO-****')
+    .replace(/sk-[A-Za-z0-9-]{8,}/g, 'sk-****')
+    .replace(/[\w.+-]+@[\w-]+\.[\w.-]+/g, function (m) {
+      const at = m.indexOf('@');
+      return m[0] + '****' + m.slice(at);
+    });
+}
+
+// Clean seam: a future semantic search can replace this body without touching the UI.
+function searchEntries(entries, query) {
+  const q = (query || '').trim().toLowerCase();
+  if (!q) return entries;
+  const terms = q.split(/\s+/);
+  return entries.filter(function (e) {
+    const hay = ((e.title || '') + '\n' + (e.content || '')).toLowerCase();
+    return terms.every(function (t) { return hay.includes(t); });
+  });
+}
+
+function _mbCleanBody(raw, title) {
+  const titleLower = (title || '').toLowerCase().trim();
+  return (raw || '').split('\n')
+    .map(function (l) { return l.replace(/^#{1,6}\s+/, ''); })
+    .filter(function (l, i) {
+      const t = l.trim();
+      if (!t) return true;
+      if (t.startsWith('Working directory:')) return false;
+      if (i === 0 && (t.toLowerCase() === titleLower || /^\d{4}-/.test(t))) return false;
+      return true;
+    })
+    .join('\n').replace(/\n{3,}/g, '\n\n').trim();
+}
+
+function _mbCleanTitle(e) {
+  return (e.title || e.filename || '').replace(/^\d{4}-\d{2}-\d{2}[\s\-_]*/, '').trim() || e.filename || 'Untitled';
+}
+
+function _mbFormatDate(raw) {
+  if (!raw) return '';
+  const d = new Date(raw + 'T00:00:00');
+  return isNaN(d.getTime()) ? raw : d.toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric' });
+}
+
+function _mbSourceClass(e) { return e.source_type === 'agent' ? 'agent' : 'direct'; }
+
+function renderMemoryList() {
+  const listEl = document.getElementById('mb-list');
+  const detailEl = document.getElementById('mb-detail');
+  const countEl = document.getElementById('mb-count');
+  detailEl.style.display = 'none';
+  listEl.style.display = 'flex';
+  const query = document.getElementById('mb-search').value;
+  const filtered = searchEntries(_mbEntries, query);
+  countEl.textContent = filtered.length + ' of ' + _mbEntries.length + ' entries';
+  if (!_mbEntries.length) {
+    listEl.innerHTML = '<span class="empty-state">No diary entries found.</span>';
+    return;
+  }
+  if (!filtered.length) {
+    listEl.innerHTML = '<span class="empty-state">No entries match your search.</span>';
+    return;
+  }
+  listEl.innerHTML = filtered.map(function (e, i) {
+    const body = _mbCleanBody(e.content, e.title);
+    const snippet = escapeHtml(maskSecrets(body.substring(0, 220)));
+    const more = body.length > 220 ? '...' : '';
+    return '<div class="diary-entry mb-entry" data-idx="' + i + '">'
+      + '<div class="diary-header">'
+      + '<span class="diary-title">' + escapeHtml(_mbCleanTitle(e)) + '</span>'
+      + '<span class="diary-date">' + _mbFormatDate(e.date) + '</span>'
+      + '</div>'
+      + '<div class="mb-badges">'
+      + '<span class="mb-badge project">' + escapeHtml(e.project || 'Unknown') + '</span>'
+      + '<span class="mb-badge ' + _mbSourceClass(e) + '">' + _mbSourceClass(e) + '</span>'
+      + '</div>'
+      + '<div class="diary-body" style="margin-top:0.4rem">' + snippet + more + '</div>'
+      + '</div>';
+  }).join('');
+  listEl.querySelectorAll('.mb-entry').forEach(function (el) {
+    el.addEventListener('click', function () {
+      showMemoryDetail(filtered[parseInt(el.dataset.idx, 10)]);
+    });
+  });
+}
+
+function showMemoryDetail(e) {
+  if (!e) return;
+  const listEl = document.getElementById('mb-list');
+  const detailEl = document.getElementById('mb-detail');
+  listEl.style.display = 'none';
+  detailEl.style.display = 'block';
+  const body = maskSecrets(_mbCleanBody(e.content, e.title));
+  detailEl.innerHTML = ''
+    + '<div class="mb-detail-head">'
+    + '<div class="mb-detail-actions">'
+    + '<button class="mb-back" id="mb-back-btn">&larr; Back to list</button>'
+    + '<button class="mb-back" id="mb-copy-btn" title="Copy to clipboard">Copy</button>'
+    + '</div>'
+    + '<div class="mb-badges">'
+    + '<span class="mb-badge project">' + escapeHtml(e.project || 'Unknown') + '</span>'
+    + '<span class="mb-badge ' + _mbSourceClass(e) + '">' + _mbSourceClass(e) + '</span>'
+    + '<span class="diary-date">' + _mbFormatDate(e.date) + '</span>'
+    + '</div></div>'
+    + '<h3 class="mb-detail-title">' + escapeHtml(_mbCleanTitle(e)) + '</h3>'
+    + '<div class="mb-detail-content">' + escapeHtml(body) + '</div>';
+  document.getElementById('mb-back-btn').addEventListener('click', renderMemoryList);
+  document.getElementById('mb-copy-btn').addEventListener('click', function() {
+    const btn = this;
+    // Copy the masked body (what is displayed), never the raw e.content
+    navigator.clipboard.writeText(body).then(function() {
+      btn.textContent = 'Copied!';
+      btn.style.color = '#3fb950';
+      btn.style.borderColor = '#3fb950';
+      setTimeout(function() { btn.textContent = 'Copy'; btn.style.color = ''; btn.style.borderColor = ''; }, 2000);
+    }).catch(function() { /* fallback: ignore */ });
+  });
+}
+
+async function fetchMemoryEntries(project) {
+  const listEl = document.getElementById('mb-list');
+  listEl.innerHTML = '<span class="empty-state">Loading...</span>';
+  try {
+    const res = await fetch('/api/memory-browser/entries?project=' + encodeURIComponent(project), {headers: AUTH_GET});
+    _mbEntries = await res.json();
+  } catch (err) {
+    _mbEntries = [];
+  }
+  renderMemoryList();
+}
+
+async function loadMemoryBrowser() {
+  if (_mbLoaded) return;
+  _mbLoaded = true;
+  const sel = document.getElementById('mb-project');
+  const searchEl = document.getElementById('mb-search');
+  searchEl.addEventListener('input', renderMemoryList);
+  sel.addEventListener('change', function () { fetchMemoryEntries(sel.value); });
+  try {
+    const res = await fetch('/api/memory-browser/projects', {headers: AUTH_GET});
+    const projects = await res.json();
+    const total = projects.reduce(function (s, p) { return s + p.count; }, 0);
+    sel.innerHTML = '<option value="__all__">All projects (' + total + ')</option>'
+      + projects.map(function (p) {
+          return '<option value="' + escapeHtml(p.project) + '">' + escapeHtml(p.project) + ' (' + p.count + ')</option>';
+        }).join('');
+  } catch (err) {
+    sel.innerHTML = '<option value="__all__">All projects</option>';
+  }
+  await fetchMemoryEntries('__all__');
+}
 
 
 /* ════════════════════════════════════════════

{memstack_skill_loader-4.4.0 → memstack_skill_loader-4.5.0}/src/memstack_skill_loader/dashboard.py

@@ -427,6 +427,118 @@ def _get_diary_entries() -> list[dict]:
     return entries
 
 
+# ── Memory Browser (project-aware diary reader) ──────────────────────────────
+# Reuses the markdown diary record (agent autosaves in ~/.memstack/diary + each
+# project's memory/sessions) but, unlike _get_diary_entries above, resolves
+# projects EXPLICITLY instead of inheriting the launch cwd.
+
+_MB_WORKDIR_RE = re.compile(r"(?:Working directory|Project)\s*[:=]\s*(.+)", re.IGNORECASE)
+_MB_PROJECTS_PATH_RE = re.compile(r"([A-Za-z]:[\\/]+Projects[\\/]+[A-Za-z0-9_.+\- ]+)")
+
+
+def _mb_basename(path_str: str) -> str | None:
+    """Last non-empty path segment of a filesystem path."""
+    path_str = (path_str or "").strip().strip('"').strip()
+    if not path_str:
+        return None
+    parts = [p for p in re.split(r"[\\/]+", path_str.rstrip("\\/")) if p]
+    return parts[-1] if parts else None
+
+
+def _mb_extract_workdir(content: str) -> str | None:
+    """Best-effort absolute working dir for an agent diary (no structured field exists)."""
+    head = content[:1500]
+    m = _MB_WORKDIR_RE.search(head)
+    if m:
+        cand = m.group(1).strip().strip('"').strip()
+        if cand and re.match(r"^[A-Za-z]:[\\/]", cand):
+            return cand
+    m2 = _MB_PROJECTS_PATH_RE.search(head)
+    if m2:
+        return m2.group(1).strip()
+    return None
+
+
+def _mb_read_md_dir(diary_dir: Path, source_type: str, project_override: str | None = None) -> list[dict]:
+    """Read *.md from one directory into browser entries."""
+    out = []
+    if not diary_dir.exists():
+        return out
+    for f in diary_dir.glob("*.md"):
+        try:
+            content = f.read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            continue
+        name = f.stem
+        date_part = name[:10] if len(name) >= 10 else name
+        first_line = content.split("\n", 1)[0].strip("#").strip()
+        if project_override is not None:
+            project = project_override
+        else:
+            wd = _mb_extract_workdir(content)
+            project = (_mb_basename(wd) if wd else None) or "Agent Runs"
+        try:
+            mtime = f.stat().st_mtime
+        except OSError:
+            mtime = 0.0
+        out.append({
+            "date": date_part,
+            "filename": f.name,
+            "title": first_line or name,
+            "project": project,
+            "source_type": source_type,
+            "content": content,
+            "mtime": mtime,
+        })
+    return out
+
+
+def _resolve_diary_project_roots() -> dict[str, Path]:
+    """Resolve project roots that hold a memory/sessions dir, WITHOUT inheriting cwd.
+
+    Candidates: recent project dirs (Store B telemetry), working dirs harvested from
+    agent diaries, and the launch cwd. Only roots with memory/sessions are kept.
+    """
+    candidates: list[str] = []
+    try:
+        candidates.extend(memory_db.get_recent_project_dirs(limit=25))
+    except Exception:
+        pass
+    candidates.append(os.getcwd())
+    agent_dir = Path.home() / ".memstack" / "diary"
+    if agent_dir.exists():
+        for f in agent_dir.glob("*.md"):
+            try:
+                wd = _mb_extract_workdir(f.read_text(encoding="utf-8", errors="replace"))
+            except Exception:
+                wd = None
+            if wd:
+                candidates.append(wd)
+    roots: dict[str, Path] = {}
+    for c in candidates:
+        if not c:
+            continue
+        try:
+            root = Path(c)
+        except (TypeError, ValueError):
+            continue
+        if (root / "memory" / "sessions").is_dir():
+            roots[root.name] = root
+    return roots
+
+
+def _collect_browser_entries(project: str | None = None) -> list[dict]:
+    """All diary entries across agent autosaves + every resolved project's sessions."""
+    entries: list[dict] = []
+    entries.extend(_mb_read_md_dir(Path.home() / ".memstack" / "diary", "agent"))
+    for proj_name, root in _resolve_diary_project_roots().items():
+        entries.extend(_mb_read_md_dir(root / "memory" / "sessions", "direct", project_override=proj_name))
+    entries.sort(key=lambda e: e["mtime"], reverse=True)
+    if project and project != "__all__":
+        entries = [e for e in entries if e["project"] == project]
+    return entries
+
+
 class _DashboardServer(HTTPServer):
     allow_reuse_address = False
 
@@ -486,6 +598,23 @@ class _Handler(BaseHTTPRequestHandler):
         elif self.path == "/api/diary":
             body = json.dumps(_get_diary_entries()).encode()
             self._respond(200, "application/json", body)
+        elif self.path.startswith("/api/memory-browser/projects"):
+            entries = _collect_browser_entries()
+            counts: dict[str, int] = {}
+            for e in entries:
+                counts[e["project"]] = counts.get(e["project"], 0) + 1
+            data = sorted(
+                ({"project": p, "count": n} for p, n in counts.items()),
+                key=lambda d: (-d["count"], d["project"].lower()),
+            )
+            body = json.dumps(data).encode()
+            self._respond(200, "application/json", body)
+        elif self.path.startswith("/api/memory-browser/entries"):
+            parsed = urlparse(self.path)
+            qs = parse_qs(parsed.query)
+            project = qs.get("project", ["__all__"])[0]
+            body = json.dumps(_collect_browser_entries(project)).encode()
+            self._respond(200, "application/json", body)
         elif self.path == "/api/projects":
             body = json.dumps(get_project_details()).encode()
             self._respond(200, "application/json", body)