sqlite-graph-memory 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

sqlite_graph_memory/__init__.py

@@ -21,6 +21,6 @@ the indexer and the reranker will tell you what is missing instead of failing
 on an ``ImportError`` at startup.
 """
 
-__version__ = "0.3.1"
+__version__ = "0.3.3"
 
 __all__ = ["__version__"]

sqlite_graph_memory/brain_ask.py

@@ -9,12 +9,18 @@ USAGE:
   python brain_ask.py --graph "question"      # vector + graph expansion (Associative)
   python brain_ask.py --ab "question"         # run BOTH, diff, log to SQLite (ab_recall)
   python brain_ask.py --ask "question"        # emit a context bundle for an LLM agent
+  python brain_ask.py --ppr --graph "question"  # + PageRank lane in the ORDERING (see ppr.py)
 
 Config (env, all optional):
   BRAIN_INDEX_DIR   dir holding the embedding index (default: ./index)
   TURNSTATE_DB      SQLite db for A/B telemetry (default: ./turnstate.db)
   BRAIN_ANSWER_OUT  file to mirror the answer into (default: ./_brain_answer.txt)
   BRAIN_AB_JSON     if set, --ab also writes a structured JSON diff to this path
+  SGM_PPR=1         same as --ppr: fuse personalized PageRank over [[wikilinks]] with the
+                    reranker by RRF, reranker top 5 protected (off by default)
+  SGM_NO_STAR_PROMPT=1  never print the one-time GitHub star line after --ab
+  SGM_CONFIG_DIR    where that line's once-per-machine marker lives
+                    (default: $XDG_CONFIG_HOME or ~/.config, /sqlite-graph-memory)
 """
 import os, re, sys, pickle, datetime, sqlite3, time
 from pathlib import Path
@@ -25,6 +31,7 @@ for _s in (sys.stdout, sys.stderr):
     try: _s.reconfigure(encoding='utf-8')
     except Exception: pass
 
+FEEDBACK_URL = 'https://github.com/tonydzi/sqlite-graph-memory/discussions/categories/ideas'
 INDEX_DIR = Path(os.getenv('BRAIN_INDEX_DIR', 'index'))
 AB_DB = Path(os.getenv('TURNSTATE_DB', 'turnstate.db'))
 EMB = INDEX_DIR / '_brain_e5.npy'
@@ -187,20 +194,115 @@ def expand_1hop(sims, meta, base_order, by_base=None, ghops=GHOPS, gmax=GMAX):
 
 
 def rerank_candidates(ce, query, cand, meta, topn=TOPN):
-    """Cross-encoder rerank of candidate chunks -> [(chunk index, score)], best first."""
+    """Cross-encoder rerank of candidate chunks -> [(chunk index, score)], best first.
+    topn=None returns the whole reranked list (the PPR fusion needs the tail)."""
     pairs = [(query, meta[i]['title'] + '. ' + meta[i]['snippet']) for i in cand]
     sc = ce.predict(pairs) if len(pairs) else []
     return sorted(zip(cand, sc), key=lambda x: -x[1])[:topn]
 
 
+def _ppr():
+    try:
+        from sqlite_graph_memory import ppr
+    except ImportError:                       # run as a loose script next to ppr.py
+        import ppr
+    return ppr
+
+
+def ppr_enabled(env=None):
+    """True when SGM_PPR asks for the PageRank lane. Never raises."""
+    try:
+        return _ppr().enabled(env)
+    except Exception:
+        return False
+
+
+def ppr_lane(meta, sims, base_order):
+    """PPR file order for this query, or [] (lane off) on ANY failure, including import."""
+    try:
+        return _ppr().ppr_file_order(meta, sims, base_order)
+    except Exception as e:
+        sys.stderr.write('PPR lane fell back to reranker order (%s)\n' % str(e)[:140])
+        return []
+
+
+def fuse_ppr(ranked_full, meta, ppr_stems, topn=TOPN):
+    """Reranker list fused with the PPR order, top `topn`. Any failure: reranker top `topn`."""
+    try:
+        return _ppr().fuse_after_rerank(ranked_full, meta, ppr_stems, topn)
+    except Exception as e:
+        sys.stderr.write('PPR fusion fell back to reranker order (%s)\n' % str(e)[:140])
+        return list(ranked_full)[:topn]
+
+
+STAR_URL = 'https://github.com/tonydzi/sqlite-graph-memory'
+STAR_MARKER = 'star_prompt_shown'
+
+
+def _config_dir(env=None):
+    """Per-user config folder: SGM_CONFIG_DIR, else $XDG_CONFIG_HOME or ~/.config."""
+    env = os.environ if env is None else env
+    if env.get('SGM_CONFIG_DIR'):
+        return Path(os.path.expanduser(env['SGM_CONFIG_DIR']))
+    base = env.get('XDG_CONFIG_HOME') or os.path.join(os.path.expanduser('~'), '.config')
+    return Path(base) / 'sqlite-graph-memory'
+
+
+def maybe_star_prompt(stream=None, env=None, interactive=None):
+    """After a successful --ab run, ask for a star once per machine, on stderr.
+
+    Silent when SGM_NO_STAR_PROMPT is set (anything but '' or '0'), when CI is set
+    (anything but '', '0' or 'false'), when BRAIN_AB_JSON is set (a machine reads the
+    result), when stdout or stderr is not a terminal, or when the marker file exists.
+    The marker is created with O_EXCL, so two first runs at once print one line.
+    CRASH-SAFETY: any failure here is swallowed; the answer was already printed.
+    Returns True only if the line was printed.
+    """
+    env = os.environ if env is None else env
+    stream = sys.stderr if stream is None else stream
+    try:
+        if env.get('SGM_NO_STAR_PROMPT', '') not in ('', '0'):
+            return False
+        if env.get('CI', '').strip().lower() not in ('', '0', 'false'):
+            return False
+        if env.get('BRAIN_AB_JSON'):
+            return False
+        if interactive is None:
+            interactive = sys.stdout.isatty() and stream.isatty()
+        if not interactive:
+            return False
+        marker = _config_dir(env) / STAR_MARKER
+        marker.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            fd = os.open(str(marker), os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o644)
+        except FileExistsError:
+            return False
+        with os.fdopen(fd, 'w', encoding='utf-8') as f:
+            f.write(time.strftime('%Y-%m-%d %H:%M:%S') + '\n')
+        try:
+            stream.write('\nIf the A/B diff above was useful, a star helps other people find it: '
+                         '%s (shown once; SGM_NO_STAR_PROMPT=1 silences it)\n' % STAR_URL)
+            stream.flush()
+        except Exception:
+            try: marker.unlink()          # the user never saw it: ask again next time
+            except Exception: pass
+            return False
+        return True
+    except Exception:
+        return False
+
+
 def main():
     args = sys.argv[1:]
     ask = '--ask' in args
     graph = '--graph' in args; ab = '--ab' in args
-    flags = {'--ask', '--graph', '--ab'}
+    flags = {'--ask', '--graph', '--ab', '--ppr'}
     query = ' '.join(a for a in args if a not in flags)
     if not query or not EMB.exists():
-        print('need an embedding index (%s) and a query — run index_notes.py first' % EMB); return
+        sys.stderr.write('need an embedding index (%s) and a query — run index_notes.py first\n' % EMB)
+        if query and not EMB.exists():
+            print('Stuck? Tell us what you were trying to do: %s' % FEEDBACK_URL, file=sys.stderr)
+        raise SystemExit(1)
 
     dev = pick_device()
     emb, meta = load_index()
@@ -223,10 +325,23 @@ def main():
         added = expand_1hop(sims, meta, base_order)
     graph_order = base_order + added; graph_set = set(added)
 
+    # PageRank lane (opt-in): a second ORDERING, not a candidate source. Crash-safe like the
+    # hop: any failure leaves ppr_stems empty and every list below keeps the reranker's order.
+    # Not in --ab: the A/B answers "does the 1-hop graph help?", and its rows in ab_recall
+    # carry no PPR column, so a lane on both arms would be logged as plain vector vs graph.
+    ppr_stems = []
+    if ab and ('--ppr' in args or ppr_enabled()):
+        sys.stderr.write('PPR lane is not applied in --ab (score it with eval/run_eval.py --ppr)\n')
+    elif order and ('--ppr' in args or ppr_enabled()):
+        ppr_stems = ppr_lane(meta, sims, base_order)
+
     # rerank on the matched chunk (precise)
     ce = load_reranker(dev)
     def rerank(cand):
-        return rerank_candidates(ce, query, cand, meta)
+        if not ppr_stems:
+            return rerank_candidates(ce, query, cand, meta)
+        full = rerank_candidates(ce, query, cand, meta, topn=None)   # fusion needs the tail
+        return fuse_ppr(full, meta, ppr_stems, TOPN)
 
     # --ab: run BOTH paths in ONE process, diff, log. Answers "does graph REALLY help?"
     if ab:
@@ -279,6 +394,7 @@ def main():
                 pass
         _out = Path(os.getenv('BRAIN_ANSWER_OUT', '_brain_answer.txt'))
         _out.write_text(text, encoding='utf-8'); print(text)
+        maybe_star_prompt()
         return
 
     # GATE: wiki-graph helps THEME queries, hurts ENTITY/name queries -> skip graph for entities.
@@ -287,7 +403,7 @@ def main():
         sys.stderr.write("wiki-graph gated OFF (entity-like query) -> Direct only\n")
     order = graph_order if (graph and not gated) else base_order
     reranked = rerank(order)
-    scope = 'all' + (' /graph+%d' % len(graph_set) if graph else '')
+    scope = 'all' + (' /graph+%d' % len(graph_set) if graph else '') + (' /ppr' if ppr_stems else '')
     lines = [f'QUERY: {query}', f'(scope={scope}; e5 {len(order)} files -> rerank; {len(meta)} chunks)', '']
     if ask:
         lines.append('=== CONTEXT BUNDLE (paste to your agent) ===\n')

sqlite_graph_memory/index_notes.py

@@ -12,9 +12,9 @@ USAGE:
   python index_notes.py <notes_dir>
 Config (env, optional):
   BRAIN_INDEX_DIR     output dir (default: ./index)
-  BRAIN_INDEX_HIDDEN  1 = also index dot-directories (default: skip them,
-                      so .stversions/.obsidian/.git and Syncthing conflict
-                      copies never enter the index)
+  BRAIN_INDEX_HIDDEN  1 = also index dot-files and dot-directories (default:
+                      skip them, so .draft.md, .stversions/.obsidian/.git and
+                      Syncthing conflict copies never enter the index)
 """
 import os, re, sys, pickle
 from pathlib import Path
@@ -77,15 +77,15 @@ CONFLICT_MARKER = 'sync-conflict'
 def iter_notes(notes_dir):
     """Files that count as a note under ``notes_dir``.
 
-    Skips dot-directories and Syncthing conflict copies. Set ``BRAIN_INDEX_HIDDEN=1``
-    to index hidden folders too — someone will legitimately keep notes in one.
+    Skips dot-directories, dot-files (``.draft.md``) and Syncthing conflict copies.
+    Set ``BRAIN_INDEX_HIDDEN=1`` to index hidden paths too — someone will legitimately keep notes in one.
     """
     root = Path(notes_dir)
     include_hidden = os.getenv('BRAIN_INDEX_HIDDEN', '') not in ('', '0', 'false', 'no')
     out = []
     for p in root.rglob('*.md'):
         rel = p.relative_to(root)
-        if not include_hidden and any(part.startswith('.') for part in rel.parts[:-1]):
+        if not include_hidden and any(part.startswith('.') for part in rel.parts):
             continue
         if CONFLICT_MARKER in p.name:
             continue

sqlite_graph_memory/mcp_server.py

@@ -22,7 +22,25 @@ Config (env, optional):
 import sys, os, json, subprocess, tempfile
 from pathlib import Path
 
-from sqlite_graph_memory import __version__
+# Where the recall subprocess runs and where the package root resides.
+# The server deliberately shells out instead of importing brain_ask: a model load
+# that segfaults or runs out of memory then kills a child process and returns an
+# MCP error, rather than taking the server down mid-session.
+ROOT_DIR = Path(__file__).resolve().parent
+
+# Ensure the package root (src/) is on sys.path when invoked directly as a script
+# from a source checkout without an active editable install.
+_SRC_DIR = str(ROOT_DIR.parent)
+if _SRC_DIR not in sys.path:
+    sys.path.insert(0, _SRC_DIR)
+
+try:
+    from sqlite_graph_memory import __version__
+except ImportError:
+    try:
+        from . import __version__
+    except (ImportError, ValueError):
+        __version__ = "0.3.2"
 
 # Ensure UTF-8 for stdio communication on all platforms (including Windows console)
 try:
@@ -32,15 +50,12 @@ try:
 except Exception:
     pass
 
-# Where the recall subprocess runs. The server deliberately shells out instead
-# of importing brain_ask: a model load that segfaults or runs out of memory then
-# kills a child process and returns an MCP error, rather than taking the server
-# down mid-session.
-ROOT_DIR = Path(__file__).resolve().parent
-
 
 def _brain_ask_cmd():
-    """How to invoke brain_ask — a guaranteed sibling module inside this package."""
+    """How to invoke brain_ask — prefers the sibling script when present, falls back to module."""
+    sibling = ROOT_DIR / "brain_ask.py"
+    if sibling.exists():
+        return [sys.executable, str(sibling)]
     return [sys.executable, "-m", "sqlite_graph_memory.brain_ask"]
 
 SERVER_INFO = {
@@ -111,9 +126,11 @@ def run_recall(query: str, mode: str = "associative") -> tuple[str, bool]:
 
     try:
         call_env = {**os.environ, "BRAIN_ANSWER_OUT": str(temp_ans_file)}
+        src_dir = str(ROOT_DIR.parent)
+        existing_pp = call_env.get("PYTHONPATH", "")
+        call_env["PYTHONPATH"] = f"{src_dir}{os.pathsep}{existing_pp}" if existing_pp else src_dir
         res = subprocess.run(
             cmd,
-            cwd=str(ROOT_DIR),
             env=call_env,
             capture_output=True,
             text=True,
@@ -149,6 +166,15 @@ def run_recall(query: str, mode: str = "associative") -> tuple[str, bool]:
 
 def handle_request(req: dict) -> dict:
     """Handle a single JSON-RPC 2.0 MCP request."""
+    if not isinstance(req, dict):
+        return {
+            "jsonrpc": "2.0",
+            "id": None,
+            "error": {
+                "code": -32600,
+                "message": "Invalid Request: expected JSON object"
+            }
+        }
     method = req.get("method")
     req_id = req.get("id")
 
@@ -245,9 +271,11 @@ def main():
             mode = "ab"
         query_parts = [a for a in sys.argv[1:] if a not in flags]
         q = " ".join(query_parts) if query_parts else "agent memory"
-        text, _ = run_recall(q, mode=mode)
+        text, is_err = run_recall(q, mode=mode)
         print(f"=== MCP Test Query: {q} (mode={mode}) ===")
         print(text)
+        if is_err:
+            sys.exit(1)
         return
 
 

sqlite_graph_memory/ppr.py

@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+"""ppr.py: personalized PageRank over the [[wikilink]] graph, fused with the reranker by RRF.
+
+WHY IT EXISTS. On the home vault's frozen gold set (2026-09-16, 60 bridge questions) 97% of
+the correct bridge answers were already in the candidate pool, and Recall@12 in that diagnosis
+run was 0.225 (the README's 0.251 is the graph-mode baseline of the final measurement):
+the cross-encoder dropped them, because the relation is structural, not textual. Adding more
+candidates (more hops, larger GMAX) cannot fix that. This module gives the graph a vote in the
+ORDERING instead: PPR seeded by the dense hits yields a structural file order, and that order
+is fused with the reranker's order by Reciprocal Rank Fusion. Ranks, not scores, because
+cosine, cross-encoder logits and PageRank mass are on incomparable scales.
+
+THE HEAD IS PROTECTED. The first PPR_HEAD (5) positions of the reranker are never touched. When
+a query names one thing, the right answer is already first, and any shuffling drops it (home
+vault: without the protection title nDCG@12 fell by 0.076; with head=5 it rose by 0.006 at the
+same bridge gain). PPR only reorders candidates already in the pool; it never brings new files,
+because a file outside the pool has no chunk and no score to show.
+
+OFF BY DEFAULT. Turn it on with SGM_PPR=1 (or `sgm-ask --ppr`). The home pipeline runs it on by
+default; the package does not, because the measurement behind it was taken on one vault.
+
+CRASH-SAFETY, same contract as the graph hop: no graph, no edges, a PPR failure or a fusion
+failure each return the reranker's order unchanged and write one line to stderr. Worst case you
+get the old result, never an empty or broken recall.
+
+COST on the home vault (7.8k files, ~40k edges): building the graph 0.5 s once per process
+(cached in memory by an index fingerprint), PPR itself ~3 ms per query.
+
+Ported from the maintainer's home module brain_graph.py (2026-09-16) for issue #51.
+"""
+import hashlib
+import os
+import sys
+from pathlib import Path
+
+import numpy as np
+
+PPR_ALPHA = 0.85     # damping: share of mass that walks the edges. High on purpose: the gain is
+                     # in moving AWAY from the hits to their neighbours (0.5 gave half the bridge gain)
+PPR_ITERS = 20       # power iteration; converges in <10 on a graph this size
+PPR_SEED_TOPK = 15   # how many best dense FILES seed the personalization (same as GHOPS)
+PPR_TOPM = 10        # how many PPR files enter the fusion. More is WORSE: a long structural tail
+                     # dilutes the top (topm=30 gave bridge +0.053, topm=10 gave +0.103)
+PPR_HEAD = 5         # reranker positions the fusion never touches
+RRF_K = 60           # RRF constant (Cormack et al. 2009)
+
+_CACHE = {}          # index fingerprint -> Graph, in process memory only
+
+
+def enabled(env=None):
+    """True when SGM_PPR is set to 1/on/yes/true. Default: off."""
+    env = os.environ if env is None else env
+    return str(env.get('SGM_PPR', '')).strip().lower() in ('1', 'on', 'yes', 'true')
+
+
+def _links_in(path):
+    # One wikilink parser for the whole package: the one the graph hop uses.
+    try:
+        from sqlite_graph_memory.brain_ask import _links_in as f
+    except ImportError:                       # run as a loose script next to brain_ask.py
+        from brain_ask import _links_in as f
+    return f(path)
+
+
+class Graph:
+    """File-level wikilink graph in CSR form: node = lowercase file stem."""
+
+    def __init__(self, stems, idx, indptr, indices):
+        self.stems = stems
+        self.idx = idx
+        self.indptr = indptr
+        self.indices = indices
+        self.n_edges = int(len(indices))
+
+    def ppr(self, seed, alpha=None, iters=None):
+        """Personalized PageRank: p = alpha * A^T p + (1 - alpha) * seed.
+
+        Dangling nodes (no outgoing links) return their mass to the seed instead of spreading
+        it over the whole graph, otherwise the unlinked half of a vault would wash out the
+        personalization.
+        """
+        alpha = PPR_ALPHA if alpha is None else alpha
+        iters = PPR_ITERS if iters is None else iters
+        n = len(self.stems)
+        s = np.asarray(seed, dtype='float64')
+        tot = s.sum()
+        if n == 0 or tot <= 0:
+            return np.zeros(n, dtype='float64')
+        s = s / tot
+        if self.n_edges == 0:
+            return s                          # no edges: PPR is the personalization itself
+        p = s.copy()
+        deg = np.diff(self.indptr)
+        live = deg > 0
+        src = np.repeat(np.arange(n), deg)
+        for _ in range(iters):
+            contrib = np.zeros(n, dtype='float64')
+            contrib[live] = p[live] / deg[live]
+            nxt = np.zeros(n, dtype='float64')
+            np.add.at(nxt, self.indices, contrib[src])
+            dangling = float(p[~live].sum())
+            p = alpha * nxt + (alpha * dangling + (1.0 - alpha)) * s
+        return p
+
+
+def _fingerprint(meta):
+    """sha256 over (path, sha) of every chunk, so the cache expires when the index changes."""
+    h = hashlib.sha256()
+    for m in meta:
+        h.update(str(m.get('path', '')).encode('utf-8', 'replace'))
+        h.update(b'\x1f')
+        h.update(str(m.get('sha', '')).encode('utf-8', 'replace'))
+        h.update(b'\x1e')
+    return h.hexdigest()
+
+
+def build(meta):
+    """Build the file graph from the notes' outgoing [[wikilinks]] (self-links and dups dropped).
+
+    A node is a file NAME, because that is what a wikilink addresses: a/index.md and
+    b/index.md are one node, and the outgoing links of both files become its edges.
+    """
+    try:
+        fp = _fingerprint(meta)
+    except Exception:
+        fp = None
+    if fp and fp in _CACHE:
+        return _CACHE[fp]
+    stems, paths, idx = [], [], {}
+    for m in meta:
+        st = Path(m['path']).stem.lower()
+        if st not in idx:
+            idx[st] = len(stems)
+            stems.append(st)
+            paths.append([])
+        if m['path'] not in paths[idx[st]]:
+            paths[idx[st]].append(m['path'])
+    indptr = np.zeros(len(stems) + 1, dtype='int64')
+    indices = []
+    for u, files in enumerate(paths):
+        seen = set()
+        for p in files:
+            for tgt in _links_in(p):
+                v = idx.get(tgt.strip().lower())
+                if v is None or v == u or v in seen:
+                    continue
+                seen.add(v)
+                indices.append(v)
+        indptr[u + 1] = len(indices)
+    g = Graph(stems, idx, indptr, np.asarray(indices, dtype='int64'))
+    if fp:
+        _CACHE[fp] = g
+    return g
+
+
+def ppr_file_order(meta, sims, base_order, graph=None, topm=None, seed_topk=None):
+    """File stems ordered by personalized PageRank, seeded by the dense hits in base_order.
+
+    Seed weight = best chunk cosine + 1, so it is non-negative (PageRank needs a non-negative
+    teleport, cosine lives in [-1, 1]). Returns [] on any failure; the caller keeps its order.
+    """
+    topm = PPR_TOPM if topm is None else topm
+    seed_topk = PPR_SEED_TOPK if seed_topk is None else seed_topk
+    try:
+        g = build(meta) if graph is None else graph
+        if not g.stems or g.n_edges == 0:
+            return []
+        seed = np.zeros(len(g.stems), dtype='float64')
+        seen, used = set(), 0
+        for i in base_order:
+            st = Path(meta[i]['path']).stem.lower()
+            if st in seen:
+                continue
+            seen.add(st)
+            u = g.idx.get(st)
+            if u is None:
+                continue
+            seed[u] = max(seed[u], float(sims[i]) + 1.0)   # seed starts at 0: never negative
+            used += 1
+            if used >= seed_topk:
+                break
+        if seed.sum() <= 0:
+            return []
+        p = g.ppr(seed)
+        top = np.argsort(-p, kind='stable')[:max(1, topm)]
+        return [g.stems[int(u)] for u in top if p[int(u)] > 0]
+    except Exception as e:
+        sys.stderr.write('PPR lane failed (%s) -> reranker order unchanged\n' % str(e)[:140])
+        return []
+
+
+def rrf_fuse(*ranked_lists, k=RRF_K):
+    """Reciprocal Rank Fusion: score(d) = sum 1 / (k + rank_d + 1). Ties break by item value."""
+    score, order = {}, []
+    for lst in ranked_lists:
+        for rank, i in enumerate(lst):
+            if i not in score:
+                score[i] = 0.0
+                order.append(i)
+            score[i] += 1.0 / (k + rank + 1)
+    order.sort(key=lambda i: (-score[i], i))
+    return order
+
+
+def fuse_after_rerank(ranked_idx, meta, ppr_stems, topn, head=None):
+    """Pipeline hook: reorder [(chunk index, score)] from the reranker, then cut to topn.
+
+    `ranked_idx` must be the FULL reranked list, not the top-12: the point is to lift the right
+    neighbour out of the tail, which a fusion that only sees the top-12 cannot do. Empty PPR
+    returns the first topn exactly as given.
+
+    Every item is kept: two notes with the same file name in different folders are one graph
+    node (wikilinks address notes by name) but stay two results, so the output is never
+    shorter than the input. Positions, not names, go into RRF, so a tie breaks toward the
+    reranker's earlier position instead of the alphabetical order of file names.
+    """
+    if not ppr_stems or not ranked_idx:
+        return list(ranked_idx)[:topn]
+    try:
+        items = list(ranked_idx)
+        head = PPR_HEAD if head is None else head
+        stems = [Path(meta[i]['path']).stem.lower() for i, _ in items]
+        kept = set(stems[:head])
+        first = {}
+        for p in range(head, len(items)):
+            first.setdefault(stems[p], p - head)
+        ppr_pos = [first[s] for s in ppr_stems if s in first and s not in kept]
+        if not ppr_pos:
+            return items[:topn]
+        fused = rrf_fuse(list(range(len(items) - head)), ppr_pos)
+        return (items[:head] + [items[head + p] for p in fused])[:topn]
+    except Exception as e:
+        sys.stderr.write('PPR fusion failed (%s) -> reranker order\n' % str(e)[:140])
+        return list(ranked_idx)[:topn]

sqlite_graph_memory/vault_stats.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""sgm-stats -- four health numbers for a folder of linked markdown notes.
+
+    sgm-stats <notes_dir> [--json] [--today YYYY-MM-DD] [--threshold-* N ...]
+
+Measures the graph the retriever actually walks: the same note filter as the indexer
+(``iter_notes``: no dot-directories, no sync-conflict copies) and the same wikilink parser
+and target resolution as ``brain_ask`` (``_links_in``, basename match, case-insensitive).
+A second parser would report on a graph recall never sees.
+
+  orphan rate      pages with no inbound link          ok <5%   warn 5-15%   fail >15%
+  avg degree       resolved outgoing links per page    ok 3-8   warn 2-3 / 8-10   fail <2 or >10
+  main component   share of pages in the largest       ok >=80%  warn below
+                   weakly connected component
+  stale concepts   concept pages whose `updated`       warn >50%
+                   (or `date`) is older than 90 days
+
+Pages are keyed by their path inside the vault, so two notes with the same name in
+different folders stay two pages; a ``[[name]]`` link reaches every page with that name,
+the same candidates ``brain_ask.index_by_basename`` keeps. Links to pages that do not
+exist and links from a page to itself are not edges. A concept page is one with
+``type: concept`` in its frontmatter or one that lives in a folder named ``concepts``
+inside the vault. Stale share is over all concept pages; undated ones (no date, or a
+date that is not a real day) are named in the detail and never count as stale.
+Verdicts are taken on the same rounded value the report prints.
+
+Exit code: 0 all ok, 1 any warn, 2 any fail -- so it can sit in cron as a watchdog.
+Zero model calls, zero network, stdlib + the two sibling modules.
+"""
+import argparse
+import datetime
+import json
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+from sqlite_graph_memory.brain_ask import _links_in
+from sqlite_graph_memory.index_notes import FM_RX, iter_notes, read_note
+
+DEFAULTS = {
+    'orphan_warn': 5.0, 'orphan_fail': 15.0,
+    'degree_ok_min': 3.0, 'degree_ok_max': 8.0,
+    'degree_warn_min': 2.0, 'degree_warn_max': 10.0,
+    'component_ok': 80.0,
+    'stale_days': 90, 'stale_warn': 50.0,
+}
+RANK = {'ok': 0, 'warn': 1, 'fail': 2, 'n/a': 0}
+
+TYPE_RX = re.compile(r"""(?m)^type:\s*["']?([^"'\n]+?)["']?\s*$""")
+UPDATED_RX = re.compile(r"""(?m)^updated:\s*["']?(\d{4}-\d{2}-\d{2})""")
+DATE_RX = re.compile(r"""(?m)^date:\s*["']?(\d{4}-\d{2}-\d{2})""")
+
+
+class EmptyVault(Exception):
+    """No note under the folder: an unmounted or wrong path, reported as fail."""
+
+
+def build_graph(notes_dir):
+    """(pages, edges): pages = {relative path without .md: Path},
+    edges = {(src, dst)} between real pages."""
+    root = Path(notes_dir)
+    pages, by_stem = {}, defaultdict(list)
+    for p in iter_notes(root):
+        key = p.relative_to(root).with_suffix('').as_posix()
+        pages[key] = p
+        by_stem[p.stem.lower()].append(key)
+    edges = set()
+    for src, path in pages.items():
+        for tgt in _links_in(path):
+            for dst in by_stem.get(tgt.lower(), ()):
+                if dst != src:
+                    edges.add((src, dst))
+    return pages, edges
+
+
+def largest_component(pages, edges):
+    """Size of the largest weakly connected component (union-find)."""
+    parent = {p: p for p in pages}
+
+    def find(x):
+        while parent[x] != x:
+            parent[x] = parent[parent[x]]
+            x = parent[x]
+        return x
+
+    for a, b in edges:
+        ra, rb = find(a), find(b)
+        if ra != rb:
+            parent[ra] = rb
+    sizes = defaultdict(int)
+    for p in pages:
+        sizes[find(p)] += 1
+    return max(sizes.values()) if sizes else 0, len(sizes)
+
+
+def _parse_day(s):
+    try:
+        return datetime.date.fromisoformat(s)
+    except ValueError:              # 2026-02-30: date-shaped, not a day
+        return None
+
+
+def concept_dates(pages):
+    """[(key, date or None)] for every concept page."""
+    out = []
+    for key, path in pages.items():
+        text = read_note(path) or ''
+        m = FM_RX.match(text)
+        fm = m.group(1) if m else ''
+        t = TYPE_RX.search(fm)
+        is_concept = (t and t.group(1).strip().lower() == 'concept') or \
+            any(part.lower() == 'concepts' for part in Path(key).parent.parts)
+        if not is_concept:
+            continue
+        d = UPDATED_RX.search(fm) or DATE_RX.search(fm)
+        out.append((key, _parse_day(d.group(1)) if d else None))
+    return out
+
+
+def verdict_orphan(v, th):
+    return 'fail' if v > th['orphan_fail'] else 'warn' if v >= th['orphan_warn'] else 'ok'
+
+
+def verdict_degree(v, th):
+    if th['degree_ok_min'] <= v <= th['degree_ok_max']:
+        return 'ok'
+    if th['degree_warn_min'] <= v <= th['degree_warn_max']:
+        return 'warn'
+    return 'fail'
+
+
+def compute(notes_dir, today=None, th=None):
+    th = {**DEFAULTS, **(th or {})}
+    today = today or datetime.date.today()
+    pages, edges = build_graph(notes_dir)
+    n = len(pages)
+    if n == 0:
+        raise EmptyVault(f"sgm-stats: no notes under {notes_dir}")
+
+    indeg = defaultdict(int)
+    for _, dst in edges:
+        indeg[dst] += 1
+    orphans = sorted(p for p in pages if indeg[p] == 0)
+    orphan_pct = round(100.0 * len(orphans) / n, 1)
+    degree = round(len(edges) / n, 2)
+    main, n_comp = largest_component(pages, edges)
+    main_pct = round(100.0 * main / n, 1)
+
+    concepts = concept_dates(pages)
+    dated = [(s, d) for s, d in concepts if d is not None]
+    cutoff = today - datetime.timedelta(days=int(th['stale_days']))
+    stale = sorted(s for s, d in dated if d < cutoff)
+    if concepts:
+        stale_pct = round(100.0 * len(stale) / len(concepts), 1)
+        stale_v = 'warn' if stale_pct > th['stale_warn'] else 'ok'
+    else:
+        stale_pct, stale_v = None, 'n/a'
+
+    metrics = [
+        {'name': 'orphan_rate', 'value': orphan_pct, 'unit': '%',
+         'verdict': verdict_orphan(orphan_pct, th),
+         'detail': f"{len(orphans)} of {n} pages have no inbound link",
+         'examples': orphans[:5]},
+        {'name': 'avg_degree', 'value': degree, 'unit': 'links/page',
+         'verdict': verdict_degree(degree, th),
+         'detail': f"{len(edges)} resolved links over {n} pages"},
+        {'name': 'main_component', 'value': main_pct, 'unit': '%',
+         'verdict': 'ok' if main_pct >= th['component_ok'] else 'warn',
+         'detail': f"{main} of {n} pages; {n_comp} component{'' if n_comp == 1 else 's'}"},
+        {'name': 'stale_concepts',
+         'value': stale_pct, 'unit': '%',
+         'verdict': stale_v,
+         'detail': (f"{len(stale)} of {len(concepts)} concept pages older than "
+                    f"{int(th['stale_days'])} days (as of {today.isoformat()})"
+                    + (f"; {len(concepts) - len(dated)} undated" if len(dated) < len(concepts) else '')
+                    if concepts else "no concept pages"),
+         'examples': stale[:5]},
+    ]
+    worst = max(RANK[m['verdict']] for m in metrics)
+    return {'notes_dir': str(notes_dir), 'pages': n, 'metrics': metrics,
+            'verdict': ['ok', 'warn', 'fail'][worst], 'exit_code': worst}
+
+
+def render(report):
+    lines = [f"{report['pages']} pages in {report['notes_dir']}", '']
+    for m in report['metrics']:
+        val = 'n/a' if m['value'] is None else f"{m['value']}{'%' if m['unit'] == '%' else ''}"
+        lines.append(f"{m['verdict'].upper():<5} {m['name']:<15} {val:>7}   {m['detail']}")
+    lines += ['', f"verdict: {report['verdict']}"]
+    return '\n'.join(lines)
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog='sgm-stats', description=__doc__.split('\n\n')[0])
+    ap.add_argument('notes_dir')
+    ap.add_argument('--json', action='store_true', help='machine-readable output')
+    ap.add_argument('--today', type=datetime.date.fromisoformat,
+                    help='date to measure staleness against (YYYY-MM-DD; default: today)')
+    for key, val in DEFAULTS.items():
+        ap.add_argument('--threshold-' + key.replace('_', '-'), dest=key, type=float,
+                        default=val, help=f'default {val}')
+    a = ap.parse_args(argv)
+    if not Path(a.notes_dir).is_dir():
+        ap.error(f"not a directory: {a.notes_dir}")
+    th = {k: getattr(a, k) for k in DEFAULTS}
+    try:
+        report = compute(a.notes_dir, today=a.today, th=th)
+    except EmptyVault as e:
+        print(e, file=sys.stderr)
+        return 2
+    print(json.dumps(report, indent=2, ensure_ascii=False) if a.json else render(report))
+    return report['exit_code']
+
+
+if __name__ == '__main__':
+    sys.exit(main())

{sqlite_graph_memory-0.3.1.dist-info → sqlite_graph_memory-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sqlite-graph-memory
-Version: 0.3.1
+Version: 0.3.3
 Summary: Associative memory for LLM agents: Graph RAG over a folder of markdown notes, in one SQLite file, with no server to run.
 Project-URL: Homepage, https://github.com/tonydzi/sqlite-graph-memory
 Project-URL: Repository, https://github.com/tonydzi/sqlite-graph-memory
@@ -49,10 +49,16 @@ Requires-Dist: sentence-transformers>=2.6; extra == 'embeddings'
 Requires-Dist: transformers<4.50; (sys_platform == 'darwin' and platform_machine == 'x86_64') and extra == 'embeddings'
 Description-Content-Type: text/markdown
 
-# sqlite-graph-memory
+# sqlite-graph-memory: persistent memory for Claude Code, Cursor and Codex over your own markdown notes
 
 <!-- mcp-name: io.github.tonydzi/sqlite-graph-memory -->
 
+[![PyPI](https://img.shields.io/pypi/v/sqlite-graph-memory)](https://pypi.org/project/sqlite-graph-memory/) [![tests](https://img.shields.io/github/actions/workflow/status/tonydzi/sqlite-graph-memory/tests.yml?label=tests)](https://github.com/tonydzi/sqlite-graph-memory/actions/workflows/tests.yml) [![MCP Registry](https://img.shields.io/badge/MCP%20Registry-io.github.tonydzi%2Fsqlite--graph--memory-blue)](https://registry.modelcontextprotocol.io/v0/servers?search=sqlite-graph-memory) [![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+
+Long-term memory for coding agents that lives in the notes you already keep: an MCP server
+and a CLI over any folder of markdown, Obsidian vaults included. `pip install`, point it at
+the folder, and Claude Code, Cursor, Codex or any other MCP client can recall from it.
+
 **Your agent forgets everything between sessions, and plain vector search gives it back
 flat, unrelated chunks. This gives it associative recall over your own markdown notes:
 vector search finds the entry points, the `[[wikilinks]]` you already wrote are the graph.
@@ -95,6 +101,11 @@ The answer lives in `tool-lanternfish` ("Lanternfish is written in Elixir"). The
 never names Lanternfish, so the vector pass does not find it in the top 12 at all.
 `project-ouzel` links to it, so one graph hop puts it second.
 
+If that hop found something your vector search missed, a
+[star](https://github.com/tonydzi/sqlite-graph-memory) is how other people with a notes
+folder find this repo. `sgm-ask --ab` asks the same once per machine, in a terminal only;
+`SGM_NO_STAR_PROMPT=1` turns it off.
+
 That is the idea in one query, and it is not a blanket win. On this same vault vector-only
 ranks ahead of graph mode overall; the numbers are in [`bench/`](bench/README.md). `--ab`
 exists so you can measure which one wins on your own notes.
@@ -102,7 +113,10 @@ exists so you can measure which one wins on your own notes.
 **From any MCP client** (Claude Desktop, Cursor, Zed, Windsurf): `sgm-mcp` after the install
 above, or `uvx --with 'sqlite-graph-memory[embeddings]' sqlite-graph-memory`. Set
 `BRAIN_INDEX_DIR` to the `index` folder `sgm-index` wrote. Config:
-[`examples/mcp-config.json`](examples/mcp-config.json).
+[`examples/mcp-config.json`](examples/mcp-config.json). Claude Code:
+`claude mcp add sqlite-graph-memory -e BRAIN_INDEX_DIR=/path/to/index -- sgm-mcp`.
+Codex: a `[mcp_servers.sqlite-graph-memory]` table in `~/.codex/config.toml` with
+`command = "sgm-mcp"`. Agents that read files first: [`llms.txt`](llms.txt).
 
 ## What it is
 
@@ -112,7 +126,7 @@ points, the `[[wikilinks]]` you already wrote by hand are the graph, and a cross
 reranks what the hop dragged in.
 SQLite is the only database ([`schema.sql`](src/sqlite_graph_memory/schema.sql)).
 
-Status: **pilot**, and the word is load-bearing: it runs daily in one real setup (a ~100k-note
+Status: **pilot**, and the word is load-bearing: it runs daily in one real setup (an index of ~28k curated notes, ~93k chunks, rebuilt nightly from a ~270k-file
 Obsidian vault driven by Claude Code), but it is deliberately minimal and makes no attempt
 to be general — see [What's intentionally missing](#whats-intentionally-missing), which is
 where the uneven test coverage is described.
@@ -189,12 +203,13 @@ an edge table only when hop depth or corpus size demands it.
 
 - No entity lane. The production setup has an extra retrieval lane over people/project
   cards; it is too entangled with personal data to publish.
-- No incremental indexing and no packaging. There IS an eval suite now — see
+- No incremental indexing (tracked in the issues). Packaging exists since v0.3.0 (`pip install sqlite-graph-memory`). There IS an eval suite now — see
   [Measure before you swap](#measure-before-you-swap--eval) — but it scores retrieval on
   wikilink-derived gold, which is weak supervision and says so out loud. Test coverage is uneven:
-  `index_notes.py`, `brain_ask.py` and `mcp_server.py` have unit tests, `turnstate_hook.py`
-  has none. Run `pytest -q` for the current count rather than trusting a number written in
-  prose here — that is how this file ended up claiming "no tests" while seven were passing.
+  `index_notes.py`, `brain_ask.py` and `mcp_server.py` have unit tests, and
+  `turnstate_hook.py` has write-path coverage. Run `pytest -q` for the current count rather
+  than trusting a number written in prose here — that is how this file ended up claiming
+  "no tests" while seven were passing.
   The status line above says **pilot** on purpose.
 
 ## Quickstart
@@ -237,7 +252,7 @@ present, and CPU works fine for small corpora.
 
 ### What `--ab` looks like
 
-Output of `brain_ask.py` with `--ab`, on a toy 4-note corpus (real runs use a ~100k-note vault):
+Output of `brain_ask.py` with `--ab`, on a toy 4-note corpus (real runs use an index of ~28k notes / ~93k chunks):
 
 ```
 A/B RECALL: how should agent memory work
@@ -281,6 +296,26 @@ board with one adapter file and a pull request: [bench/CONTRIBUTING.md](bench/CO
 CI recomputes every submitted number from the per-question outputs, so a typed-in number
 cannot get onto the board.
 
+## Health check — `sgm-stats`
+
+Four numbers about the link graph itself, no model and no index needed. It reads the notes with
+the same filter and the same `[[wikilink]]` parser as recall, so it measures the graph `--graph`
+actually walks. Thresholds follow [second-brain-os metrics](https://github.com/undefined-ui/second-brain-os/blob/main/docs/05-graphs/metrics.md);
+each is a `--threshold-*` flag. Exit code 0 ok, 1 warn, 2 fail, so it can sit in cron.
+
+```text
+$ sgm-stats bench/vault --today 2026-10-20
+202 pages in bench/vault
+
+FAIL  orphan_rate       26.2%   53 of 202 pages have no inbound link
+OK    avg_degree         4.65   940 resolved links over 202 pages
+OK    main_component   100.0%   202 of 202 pages; 1 component
+WARN  stale_concepts   100.0%   12 of 12 concept pages older than 90 days (as of 2026-10-20)
+```
+
+The synthetic bench vault fails the orphan check for a plain reason: its 40 meeting and 12 decision notes link out and nothing
+links back to them. `--json` gives the same report with the first orphan and stale page names.
+
 ## Measure before you swap — `eval/`
 
 Every "obvious" upgrade to a RAG pipeline — a newer embedder, a stronger reranker, hybrid
@@ -342,6 +377,17 @@ of guessing — 97% of the correct `bridge` answers were *already in the candida
 cross-encoder was dropping them, because the relation is structural, not textual. Widening
 retrieval, the obvious fix, would have done nothing at all.
 
+That lane ships in the package as `src/sqlite_graph_memory/ppr.py`, **off by default**: turn it
+on with `SGM_PPR=1` or `sgm-ask --ppr`, and score it with `python eval/run_eval.py --gold ...
+--ppr`, which adds a third mode next to `vector` and `graph`. The numbers above were measured on
+the graph pool, so the matching command is `sgm-ask --graph --ppr`; `--ppr` alone reorders the
+vector pool, and `--ab` leaves the lane out so its A/B log stays vector against graph. Any failure in it falls back to
+the reranker's order, like the graph hop. Be clear about what that reproduces: the bridge
+numbers above came from the maintainer's home vault and home pipeline on 2026-09-16, and they
+have not been re-run from the published package. The code is the same algorithm with the same
+constants (alpha 0.85, 10 PPR files, top 5 protected), but your vault will give your numbers,
+and `bench/` does not score this lane yet.
+
 Seven other changes were rejected by the same ruler, under one rule fixed in advance:
 **a regression worse than 0.01 nDCG@12 on any class reverts the change.**
 
@@ -351,10 +397,10 @@ Seven other changes were rejected by the same ruler, under one rule fixed in adv
 | Qwen3-Embedding-0.6B | body Recall 0.767 -> 0.683; reindex 2863 s vs 333 s -> **rejected** |
 | bge-reranker-v2-m3 | −0.011…−0.018 nDCG on every class except English (+0.041) -> **rejected** |
 | Qwen3-Reranker-0.6B | title −0.111 nDCG at 12x the cost -> **rejected** |
-| BM25 + RRF hybrid | temporal −0.035 -> **merged switched off** |
+| BM25 + RRF hybrid | temporal −0.035 -> **merged switched off** (in the home pipeline, not in this package) |
 | heading-path prefix in every chunk | body −0.023, temporal −0.035 -> **reverted** |
 | `sqlite-vec` (vec0) | full scan 11.99 s vs 0.14 s for a plain SQLite table, and its ANN missed 1.2 hits of 60 -> vectors live in SQLite, **the extension does not** |
-| bi-temporal demotion of superseded notes | temporal +0.130 nDCG on a 41-question temporal set, but title −0.012 -> **merged behind a flag, default off** |
+| bi-temporal demotion of superseded notes | temporal +0.130 nDCG on a 41-question temporal set, but title −0.012 -> **merged behind a flag, default off** (in the home pipeline, not in this package) |
 
 None of those verdicts is a claim about the models. They are claims about *this corpus with
 this ruler*, which is the only kind of claim a swap decision actually needs — and the reason
@@ -376,7 +422,7 @@ while the metric is broken never tested the metric.
 
 ## Roadmap
 
-**Now — [v0.1.1](https://github.com/tonydzi/sqlite-graph-memory/releases).**
+**Now — [latest release](https://github.com/tonydzi/sqlite-graph-memory/releases/latest)** (v0.3.1 on PyPI and in the MCP Registry as of 2026-10-19).
 The pilot as it runs daily: retrieval pipeline, per-turn ledger and A/B telemetry, all in
 `brain_ask.py` and `turnstate_hook.py`, plus the bi-temporal design note. Known defects live in
 the [tracker](https://github.com/tonydzi/sqlite-graph-memory/issues) rather than in footnotes
@@ -414,9 +460,10 @@ Both are set as constants (`E5_MODEL`, `RERANK_MODEL`) in `brain_ask.py` and sma
 to run on a laptop GPU; swap freely, since nothing in the pipeline depends on these
 specific models.
 
-## Cite this work
+## Maintainers
 
-If this repo shows up in your research, cite it via [CITATION.cff](CITATION.cff) (GitHub's "Cite this repository" button). Academic identity: Anton Dzyatkovsky publishes as **Anton Dziatkovskii** ([ORCID 0000-0001-7408-3054](https://orcid.org/0000-0001-7408-3054)).
+- **Anton Dziatkovskii** ([@tonydzi](https://github.com/tonydzi)): retrieval pipeline, ledger, bench, releases.
+- **Vardhman Gupta** ([@Kaap10](https://github.com/Kaap10)): the MCP server (`sgm-mcp`, PRs #8, #10, #14) and its tests; reviews on `mcp_server.py` route to him via CODEOWNERS.
 
 ## AI contributors
 
@@ -428,7 +475,7 @@ content** — no decorative credits. Lab-wide policy, one source for every repo:
 
 ## Cite this work
 
-The paper about this system — retrieval design, pilot telemetry, and the query-class-stratified evaluation protocol — is published: [DOI 10.5281/zenodo.22639718](https://doi.org/10.5281/zenodo.22639718) (preprint, CC BY 4.0). Machine-readable citation: [CITATION.cff](CITATION.cff).
+The paper about this system — retrieval design, pilot telemetry, and the query-class-stratified evaluation protocol — is published: [DOI 10.5281/zenodo.22639718](https://doi.org/10.5281/zenodo.22639718) (preprint, CC BY 4.0). Machine-readable citation: [CITATION.cff](CITATION.cff) (GitHub's "Cite this repository" button). Academic identity: Anton Dzyatkovsky publishes as **Anton Dziatkovskii** ([ORCID 0000-0001-7408-3054](https://orcid.org/0000-0001-7408-3054)).
 
 ## License
 
@@ -444,6 +491,16 @@ Questions, war stories, or you want to run this on your own fleet:
 - 🌐 [palo-alto.ai](https://palo-alto.ai) · [Palo Alto AI Research Lab](https://github.com/tonydzi)
 - 🧪 **Engineers: want to test-drive this setup?** Message me — I hand out free starter seeds to engineers who test and report back.
 
+## Tell us what is missing
+
+You tried this on your own notes and something was missing or broke. That is the most useful
+thing anyone can tell us.
+
+- **You started and it did not work:** [open the 3-question form](https://github.com/tonydzi/sqlite-graph-memory/issues/new?template=feature_request.yml) (what you tried, what broke, which machine).
+- **Not sure it is a bug, or just an idea:** [Discussions → Ideas](https://github.com/tonydzi/sqlite-graph-memory/discussions/categories/ideas).
+
+Nothing in this package phones home. There is no telemetry, so we only know what you write to us.
+
 ## Contributors welcome — and there is a queue
 
 Issues labelled [`accepted`](https://github.com/tonydzi/sqlite-graph-memory/issues?q=is%3Aissue+is%3Aopen+label%3Aaccepted)

sqlite_graph_memory-0.3.3.dist-info/RECORD

@@ -0,0 +1,14 @@
+sqlite_graph_memory/__init__.py,sha256=2xKSCi2vAjRyWsMf6N3Sd9-Znk0IYgmoSc_RzwKM6go,1151
+sqlite_graph_memory/brain_ask.py,sha256=rcXquak8fIYzKLPJL0GhrQGvbA0cVIcj805lNUjvcTY,19392
+sqlite_graph_memory/index_notes.py,sha256=blm9lLlB5MSLB39tNYVtjVGULLQXTQGOth_LV4utyic,5378
+sqlite_graph_memory/mcp_server.py,sha256=XSCd2qJPvAcw9X-81YJzXeAlwL_Ss9soh9kDUqPQ3aQ,9817
+sqlite_graph_memory/ppr.py,sha256=L7VSAiliXr8j3PH2hQqKbdgm08BPm6pZkLcckoMxAro,10001
+sqlite_graph_memory/schema.sql,sha256=8aySXKw3Azaxyzqbd76mKTfOaDP7FlpkLXtgwA8ZVK4,2543
+sqlite_graph_memory/turnstate_hook.py,sha256=fypGmUcHQkzlRN74tvIG07lr9uAXpp2GjetqthkuMc8,8641
+sqlite_graph_memory/turnstate_show.py,sha256=IED7fmJQM5VgBNwxmEoNSZtujRmWja-qVPg5ckbWVnY,2909
+sqlite_graph_memory/vault_stats.py,sha256=QYNGck556RDyLIVFH1C864su5tWehep1DHE21sSTi9g,8596
+sqlite_graph_memory-0.3.3.dist-info/METADATA,sha256=OQVb_K2tbcV2Do83KtG7JlRPLTWnr2ZzNYvBpYhYIiw,33515
+sqlite_graph_memory-0.3.3.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+sqlite_graph_memory-0.3.3.dist-info/entry_points.txt,sha256=ggzirSEagKB7DZnMli9NUDiMuaog1oeBu_NpRPiKmr0,387
+sqlite_graph_memory-0.3.3.dist-info/licenses/LICENSE,sha256=p88nZdrfMUiES3_MpUEwhGmqz2hQFpyMh0k0cqdpfU8,1082
+sqlite_graph_memory-0.3.3.dist-info/RECORD,,

{sqlite_graph_memory-0.3.1.dist-info → sqlite_graph_memory-0.3.3.dist-info}/entry_points.txt

@@ -2,6 +2,7 @@
 sgm-ask = sqlite_graph_memory.brain_ask:main
 sgm-index = sqlite_graph_memory.index_notes:main
 sgm-mcp = sqlite_graph_memory.mcp_server:main
+sgm-stats = sqlite_graph_memory.vault_stats:main
 sgm-turnstate-hook = sqlite_graph_memory.turnstate_hook:main
 sgm-turnstate-show = sqlite_graph_memory.turnstate_show:main
 sqlite-graph-memory = sqlite_graph_memory.mcp_server:main

sqlite_graph_memory-0.3.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-sqlite_graph_memory/__init__.py,sha256=zmDhq3ADXY29WMzJp6FtMnBDanbenCU1bQ9Sa3cLwv0,1151
-sqlite_graph_memory/brain_ask.py,sha256=IU8AVk8VvDJr0XC02a7Foil_f0ui0N-Rr_jD734Onbk,14104
-sqlite_graph_memory/index_notes.py,sha256=Hmt0_VVJHS-zXhPPw9h2te8iG1W48f1tJ_H0ALt9aLk,5333
-sqlite_graph_memory/mcp_server.py,sha256=2pBRuKcWTIfQHfM6-P1fa1x1s1377RnAlyrsZdABFQM,8820
-sqlite_graph_memory/schema.sql,sha256=8aySXKw3Azaxyzqbd76mKTfOaDP7FlpkLXtgwA8ZVK4,2543
-sqlite_graph_memory/turnstate_hook.py,sha256=fypGmUcHQkzlRN74tvIG07lr9uAXpp2GjetqthkuMc8,8641
-sqlite_graph_memory/turnstate_show.py,sha256=IED7fmJQM5VgBNwxmEoNSZtujRmWja-qVPg5ckbWVnY,2909
-sqlite_graph_memory-0.3.1.dist-info/METADATA,sha256=8t6SsujTinP7SCt58hrfQKDrJIvMLw1tKlJfddGqCU4,28958
-sqlite_graph_memory-0.3.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-sqlite_graph_memory-0.3.1.dist-info/entry_points.txt,sha256=klRDFFhyh3MrP3dfrF9wYciV9QnprfzmQCxU1lJ2FgU,338
-sqlite_graph_memory-0.3.1.dist-info/licenses/LICENSE,sha256=p88nZdrfMUiES3_MpUEwhGmqz2hQFpyMh0k0cqdpfU8,1082
-sqlite_graph_memory-0.3.1.dist-info/RECORD,,