foldkeep 0.9.2__py3-none-any.whl

foldkeep/session.py

@@ -0,0 +1,423 @@
+"""Agent session hooks -- rolling compression for long conversations (v0.8).
+
+A session is an ordered list of turns (user/assistant). As the session grows,
+oldest raw turns are automatically rolled up into compressed form ("head"),
+while recent turns stay verbatim ("tail"). render() assembles the context
+within an optional token budget, RECENCY-FIRST: newest turns stay verbatim,
+older ones are dropped -- but their facts survive via two pinned layers:
+  - entity registry (SCREAMING_CASE tokens, one line)
+  - fact lines      (salient sentence per turn; shown only for turns that
+                     fell out of the body -- render stays read-only)
+"""
+import json
+import os
+import re
+import sqlite3
+import time
+
+from .core.compressor import ENT_RE, FastLingua
+from .estimate import estimate_tokens
+
+_DB = os.path.join(os.path.dirname(os.path.abspath(__file__)), "memories.db")
+NL = chr(10)
+NUM_RE = re.compile(r"\d+(?:\.\d+)?")
+
+def _sig(text):
+    """Diversity signature of a fact line: entities PLUS numbers --
+    'PASS 12' vs 'PASS 20' differ only in digits, and digits are facts."""
+    return frozenset(ENT_RE.findall(text)) | frozenset(NUM_RE.findall(text))
+
+_TOK_RE = re.compile(r"[A-Za-z_][A-Za-z0-9_.]*|\d+(?:\.\d+)?")
+
+def _lean(text, win=28, cap=200):
+    """Context windows around every entity/number occurrence -- the
+    evidence an agent needs, minus connective filler. ~3x cheaper than
+    the verbatim sentence while keeping exact substrings intact."""
+    spans = []
+    for m in _TOK_RE.finditer(text):
+        if ENT_RE.fullmatch(m.group()) or NUM_RE.fullmatch(m.group()):
+            spans.append((max(0, m.start() - win),
+                          min(len(text), m.end() + win)))
+    if not spans:
+        return text[:cap]
+    spans.sort()
+    merged = [list(spans[0])]
+    for s, e in spans[1:]:
+        if s <= merged[-1][1] + 8:
+            merged[-1][1] = max(merged[-1][1], e)
+        else:
+            merged.append([s, e])
+    parts = []
+    pos = 0
+    for s, e in merged:
+        if s > pos:
+            parts.append("...")
+        parts.append(text[s:e].strip())
+        pos = e
+        if sum(len(p) for p in parts) > cap:
+            break
+    out = " ... ".join(parts)
+    return out[:cap]
+_FL_PIN = None
+
+def _pin_fl():
+    """Lazy FastLingua for pin-time fact compression."""
+    global _FL_PIN
+    if _FL_PIN is None:
+        _FL_PIN = FastLingua("balanced", 0.25)
+    return _FL_PIN
+
+def _conn():
+    c = sqlite3.connect(_DB)
+    c.execute("""CREATE TABLE IF NOT EXISTS sessions (
+        name TEXT PRIMARY KEY, project TEXT NOT NULL DEFAULT 'default',
+        created REAL)""")
+    c.execute("""CREATE TABLE IF NOT EXISTS turns (
+        sid INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL, seq INTEGER NOT NULL,
+        role TEXT NOT NULL, kind TEXT NOT NULL DEFAULT 'raw',
+        text TEXT NOT NULL, orig_chars INTEGER,
+        created REAL)""")
+    c.execute("""CREATE TABLE IF NOT EXISTS entities (
+        name TEXT NOT NULL, ent TEXT NOT NULL)""")
+    c.execute("""CREATE TABLE IF NOT EXISTS facts (
+        name TEXT NOT NULL, seq INTEGER NOT NULL,
+        text TEXT NOT NULL)""")
+    # v0.9 lossless base (learned from pi-fold): originals survive
+    # rollup/consolidate and stay expandable byte-for-byte
+    cols = [r[1] for r in c.execute("PRAGMA table_info(turns)").fetchall()]
+    if "orig_text" not in cols:
+        c.execute("ALTER TABLE turns ADD COLUMN orig_text TEXT")
+    c.execute("""CREATE TABLE IF NOT EXISTS originals (
+        name TEXT NOT NULL, seq INTEGER NOT NULL,
+        text TEXT NOT NULL, PRIMARY KEY (name, seq))""")
+    return c
+
+_FENCE_RE = re.compile(r"```|~~~")
+
+def _intolerant(text):
+    """Loss-tolerance routing (learned from leanctx/LLMLingua): code
+    fences, JSON payloads and tool-call shapes must NOT be compressed --
+    distortion there destroys semantics, not filler. Such turns are kept
+    verbatim or dropped-to-facts, never hard-compressed."""
+    if _FENCE_RE.search(text):
+        return True
+    if text.lstrip()[:1] in "{[":
+        try:
+            json.loads(text)
+            return True
+        except Exception:
+            pass
+    if re.search(r'"(?:tool_use_id|tool_call|function_call)"\s*:', text):
+        return True
+    return False
+
+def new(name, project="default"):
+    """Create (or reset) a named session: clears its previous turns."""
+    with _conn() as c:
+        c.execute("INSERT OR REPLACE INTO sessions VALUES (?,?,?)",
+                  (name, project, time.time()))
+        c.execute("DELETE FROM turns WHERE name=?", (name,))
+        c.execute("DELETE FROM entities WHERE name=?", (name,))
+        c.execute("DELETE FROM facts WHERE name=?", (name,))
+    return name
+
+def _rows(name):
+    with _conn() as c:
+        return c.execute("SELECT sid,seq,role,kind,text,orig_chars FROM turns "
+                         "WHERE name=? ORDER BY seq", (name,)).fetchall()
+
+def push(name, role, text, roll_threshold=2600):
+    with _conn() as c:
+        mx = c.execute("SELECT COALESCE(MAX(seq),0) FROM turns WHERE name=?",
+                       (name,)).fetchone()[0]
+        c.execute("INSERT INTO turns (name,seq,role,kind,text,orig_chars,"
+                  "created,orig_text) VALUES (?,?,?,?,?,?,?,?)",
+                  (name, mx + 1, role, "raw", text, len(text), time.time(),
+                   text))
+        # pin a LEAN fact line: context windows around entities/numbers
+        # of the salient sentence -- exact substrings survive, filler
+        # does not; render shows it only for out-of-body turns
+        sal = _salient(text)
+        lean = _lean(sal)
+        c.execute("INSERT OR REPLACE INTO facts VALUES (?,?,?)",
+                  (name, mx + 1, lean or sal[:96]))
+    rolled = _rollup(name, roll_threshold)
+    return {"seq": mx + 1, "rolled": rolled or 0}
+
+def _salient(text, cap=160):
+    """The turn's POINT: in agent transcripts the decision sentence
+    precedes tool-output noise, so take the FIRST entity-bearing
+    sentence (falling back to the first sentence), not the longest --
+    longest routinely selects a noise line full of URLs/hashes."""
+    sents = [s.strip() for s in re.split(r"(?<=[.!?\u3002])\s+|\n+", text)
+             if s.strip()]
+    if not sents:
+        return text[:cap]
+    for s in sents:
+        if ENT_RE.search(s):
+            return s[:cap]
+    return sents[0][:cap]
+
+def _rollup(name, threshold):
+    fl = FastLingua("balanced", 0.45)
+    rows = [r for r in _rows(name) if r[3] == "raw"]
+    toks = [estimate_tokens(r[4]) for r in rows]
+    total = sum(toks)
+    if total <= threshold:
+        return 0
+    target = threshold * 0.55
+    run, cut = 0, len(rows)
+    for i in range(len(rows) - 1, -1, -1):
+        run += toks[i]
+        if run <= target:
+            cut = i
+        else:
+            break
+    n = 0
+    ents = set()
+    with _conn() as c:
+        for r in rows[:cut]:
+            if _intolerant(r[4]):
+                continue    # zero-tolerance content stays raw
+            comp, _st = fl.compress(r[4])
+            c.execute("UPDATE turns SET kind='comp', text=?, orig_chars=?, "
+                      "orig_text=COALESCE(orig_text,?) WHERE sid=?",
+                      (comp, r[5], r[4], r[0]))
+            ents.update(ENT_RE.findall(r[4]))
+            n += 1
+        # entity registry: rolled-away turns keep entity facts reachable
+        for e in ents:
+            c.execute("INSERT OR IGNORE INTO entities VALUES (?,?)", (name, e))
+    _consolidate(name)
+    return n
+
+
+def _consolidate(name, max_head=120, keep=60):
+    """Hierarchical head merge: too many compressed rows -> re-compress the
+    oldest block into ONE denser row so the head keeps shrinking."""
+    with _conn() as c:
+        comp = c.execute("SELECT sid,text FROM turns WHERE name=? AND "
+                         "kind='comp' ORDER BY seq", (name,)).fetchall()
+        if len(comp) <= max_head:
+            return 0
+        old = comp[:-keep]
+        joined = NL.join(t for _sid, t in old)
+        fl = FastLingua("aggressive", 0.45)
+        merged, _st = fl.compress(joined)
+        sids = [sid for sid, _t in old]
+        # stash verbatim originals before the merge deletes the rows
+        keep_rows = c.execute(
+            "SELECT seq, COALESCE(orig_text, text) FROM turns "
+            "WHERE sid IN (%s)" % ",".join("?" * len(sids)), sids).fetchall()
+        c.executemany("INSERT OR REPLACE INTO originals VALUES (?,?,?)",
+                      [(name, sq, tx) for sq, tx in keep_rows])
+        c.execute("DELETE FROM turns WHERE sid IN (%s)"
+                  % ",".join("?" * len(sids)), sids)
+        c.execute("INSERT INTO turns (name,seq,role,kind,text,orig_chars,"
+                  "created) VALUES (?,?,?,?,?,?,?)",
+                  (name, int(time.time()), "system", "comp", merged,
+                   len(joined), time.time()))
+    return len(sids)
+
+def _env_int(key, dflt):
+    """Layer-budget knob (learned from ECC context controls): operators
+    cap injected context via env without touching code."""
+    try:
+        return int(os.environ.get(key, dflt))
+    except (TypeError, ValueError):
+        return dflt
+
+def _registry(name, cap=None):
+    """Session-level entity registry, priority-ordered:
+    SCREAMING_CASE fact tokens first, then the rest. Deterministic.
+    Cap defaults to OC_REGISTRY_MAX env (ECC-style context control)."""
+    if cap is None:
+        cap = _env_int("OC_REGISTRY_MAX", 48)
+    with _conn() as c:
+        rows = c.execute("SELECT DISTINCT ent FROM entities WHERE name=?",
+                         (name,)).fetchall()
+    ents = [r[0] for r in rows]
+    ents.sort(key=lambda e: (0 if re.match(r"^[A-Z][A-Z0-9_]{2,}$", e)
+                             else 1, e))
+    return ents[:cap]
+
+def _fact_block(name, max_tok=320, exclude=()):
+    """Pinned fact lines for turns NOT present in the body (oldest kept
+    first when trimming). Keeps render read-only and deterministic."""
+    with _conn() as c:
+        frows = c.execute(
+            "SELECT seq,text FROM facts WHERE name=? ORDER BY seq DESC "
+            "LIMIT 64", (name,)).fetchall()
+    frows = [(sq, tx) for sq, tx in frows if sq not in exclude]
+    cands = list(reversed(frows[-24:]))
+    if not cands:
+        return ""
+    header = "=== pinned facts (out-of-body turns) ==="
+
+    def _blk(items):
+        ls = ["[t%d] %s" % (sq, tx) for sq, tx in sorted(items)]
+        return header + NL + NL.join(ls)
+
+    # greedy SET-COVER knapsack: repeatedly take the line adding the
+    # most NEW entities (shorter lines win ties), subject to the cap --
+    # spreads coverage across turns instead of clustering on a few
+    # entity-dense neighbours
+    sigs = [(sq, tx, _sig(tx)) for sq, tx in cands]
+    chosen, seen = [], set()
+    pool = list(sigs)
+    while pool:
+        best_i, best_key = 0, None
+        for i, (sq, tx, sg) in enumerate(pool):
+            key = (-len(sg - seen), len(tx))
+            if best_key is None or key < best_key:
+                best_i, best_key = i, key
+        sq, tx, sg = pool.pop(best_i)
+        if estimate_tokens(_blk(chosen + [(sq, tx)])) <= max_tok:
+            chosen.append((sq, tx))
+            seen |= sg
+    if not chosen:
+        return ""
+    return _blk(chosen)
+
+
+def render(name, budget=None):
+    """Recency-first assembly: walk NEWEST -> OLDEST so under budget
+    pressure the newest turns stay verbatim and the OLDEST are dropped
+    (their facts survive via registry + pinned-fact layers)."""
+    used, dropped = 0, 0
+    fl_hard = FastLingua("balanced", 0.25)
+    rows = _rows(name)
+    ents = _registry(name)
+    reg = ""
+    if ents:
+        reg = "=== key facts: %s ===" % " ".join(ents)
+        used += estimate_tokens(reg)
+    # reserve a slice of the budget for pinned facts up-front so the
+    # fact layer can NEVER trigger an eviction spiral against the body;
+    # floor of 170 tok lets the fact layer carry ALL facts at tiny
+    # budgets (body turns go hard-compressed, facts remain the guarantee)
+    reserve = int(min(320, max(170, budget * 0.35))) if budget else 0
+    eff = (budget - reserve) if budget else None
+    pairs, verbatim = [], set()   # verbatim seqs: facts NOT needed for them
+    for sid, seq, role, kind, text, ochars in reversed(rows):
+        tok = estimate_tokens(text)
+        tag = "comp" if kind == "comp" else "raw"
+        if eff is None or used + tok <= eff:
+            pairs.append((seq, "[%02d][%s/%s] %s" % (seq, role, tag, text)))
+            verbatim.add(seq)
+            used += tok
+            continue
+        comp, _st = fl_hard.compress(text)
+        tok2 = estimate_tokens(comp)
+        if (not _intolerant(text) and comp.strip() and tok2 < tok
+                and used + tok2 <= eff):
+            # hard-compress is LOSSY (numbers/format can die) -- the turn
+            # stays in the body but its pinned fact line still shows
+            pairs.append((seq, "[%02d][%s/hard] %s" % (seq, role, comp)))
+            used += tok2
+        else:
+            dropped += 1
+    pairs.reverse()     # now oldest-first
+    parts = [tx for _sq, tx in pairs]
+    fact_block = ""
+    if reserve:
+        room = budget - used
+        if room > 20:
+            fact_block = _fact_block(name, max_tok=min(320, room),
+                                     exclude=verbatim)
+            if fact_block:
+                used += estimate_tokens(fact_block)
+    # min-viable floor: never return a completely empty render when the
+    # session has turns and a positive budget -- fall back to the last
+    # turn, hard-compressed and hard-truncated to fit.
+    if not parts and rows and budget and int(budget) > 0:
+        sid, seq, role, kind, text, ochars = rows[-1]
+        comp, _st = fl_hard.compress(text)
+        maxchars = max(int(budget) * 4, 200)
+        if len(comp) > maxchars:
+            comp = comp[:maxchars] + " ...[truncated]"
+        parts.append("[%02d][%s/floor] %s" % (seq, role, comp))
+        used = estimate_tokens(comp)
+    body = NL.join(parts)
+    pre = [b for b in (reg, fact_block) if b]
+    if pre:
+        body = NL.join(pre) + NL + body
+    head = "=== session %s | ~%d tok%s ===" % (
+        name, used, "" if budget is None else " / budget %d" % budget)
+    if dropped:
+        head += " | dropped %d old turns" % dropped
+    return head + NL + body, used, dropped
+
+def expand(name, seq):
+    """Lossless recovery (learned from pi-fold): fetch the verbatim
+    original of any turn -- survives rollup, consolidate and render
+    drops. Returns None if the turn never existed."""
+    with _conn() as c:
+        row = c.execute("SELECT kind, text, orig_text FROM turns "
+                        "WHERE name=? AND seq=?", (name, seq)).fetchone()
+        if row:
+            kind, text, orig = row
+            if orig:
+                return orig
+            if kind == "raw":
+                return text
+        row = c.execute("SELECT text FROM originals WHERE name=? AND seq=?",
+                        (name, seq)).fetchone()
+        return row[0] if row else None
+
+def search(name, query, limit=10):
+    """Cross-session recall (learned from hermes-agent's FTS5 session
+    search): substring match over verbatim originals + pinned facts,
+    newest first. Works even for turns that were rolled away or merged,
+    because originals survive (v0.9 lossless base)."""
+    pat = "%" + query.replace("%", "").replace("_", " ") + "%"
+    like = "%" + query.replace("%", "") + "%"
+    with _conn() as c:
+        rows = c.execute(
+            "SELECT seq, role, COALESCE(orig_text, text) FROM turns "
+            "WHERE name=? AND (COALESCE(orig_text, text) LIKE ? "
+            "OR COALESCE(orig_text, text) LIKE ?) "
+            "ORDER BY seq DESC LIMIT ?",
+            (name, like, pat, limit)).fetchall()
+        facts = c.execute(
+            "SELECT seq, text FROM facts WHERE name=? AND text LIKE ? "
+            "ORDER BY seq DESC LIMIT ?", (name, like, limit)).fetchall()
+    return {"turns": [{"seq": s, "role": r, "text": t}
+                      for s, r, t in rows],
+            "facts": [{"seq": s, "text": t} for s, t in facts]}
+
+def export_md(name, path=None):
+    """Inspectable Markdown vault (learned from ECC's Memory Vault):
+    dump the FULL session -- every turn verbatim via originals, plus
+    registry and fact layers -- to a human-readable string/file."""
+    lines = ["# session %s" % name, ""]
+    ents = _registry(name)
+    if ents:
+        lines += ["## key facts", "", " ".join(ents), ""]
+    lines += ["## turns", ""]
+    for _sid, seq, role, kind, text, _oc in _rows(name):
+        body = expand(name, seq)
+        if body is None:
+            body = text
+        lines.append("### [%02d] %s (%s)" % (seq, role, kind))
+        lines += ["", body, ""]
+    lines += ["## pinned facts", ""]
+    with _conn() as c:
+        frows = c.execute("SELECT seq,text FROM facts WHERE name=? "
+                          "ORDER BY seq", (name,)).fetchall()
+    for sq, tx in frows:
+        lines.append("- [t%d] %s" % (sq, tx))
+    md = NL.join(lines)
+    if path:
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(md)
+    return md
+
+def stat(name):
+    rows = _rows(name)
+    raw = [r for r in rows if r[3] == "raw"]
+    comp = [r for r in rows if r[3] == "comp"]
+    return {"turns": len(rows),
+            "raw": len(raw), "comp": len(comp),
+            "est_tokens": sum(estimate_tokens(r[4]) for r in rows)}

foldkeep-0.9.2.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: foldkeep
+Version: 0.9.2
+Summary: Zero-dependency lossless context folding for agent sessions: pinned facts, tolerance routing, byte-for-byte expand.
+Author: foldkeep contributors
+License: MIT License
+        
+        Copyright (c) 2026 foldkeep contributors
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Keywords: llm,agent,context-window,memory,compression
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# foldkeep
+
+**Fold the context. Keep the facts.**
+
+foldkeep is a zero-dependency, deterministic context-compression engine for
+long agent conversations. It rolls old turns into compressed form while a
+pinned fact layer keeps every decision reachable — and a lossless base lets
+you expand ANY turn back byte-for-byte, even after rolling and merging.
+
+Pure Python stdlib. No LLM calls. Millisecond latency. SQLite-backed.
+
+## Why
+
+Agent transcripts grow until the model drowns. Naive fixes lose the past:
+tail-truncation drops early decisions; naive compression mangles numbers,
+code and tool payloads. foldkeep keeps three guarantees:
+
+1. **Pinned facts survive** — every turn pins a salient evidence line;
+   a set-cover knapsack picks which lines fill the leftover budget so
+   entity coverage is maximized, not clustered.
+2. **Zero-tolerance content is never mangled** — code fences, JSON payloads
+   and tool-call shapes are routed away from lossy compression.
+3. **Nothing is ever lost** — originals persist on disk; `expand(name, seq)`
+   recovers any turn byte-for-byte after rollup, consolidation or render
+   drops.
+
+## Quickstart
+
+```python
+from foldkeep import session as sess
+
+sess.new("my-session")
+for role, text in conversation:          # push turns as they happen
+    sess.push("my-session", role, text)  # auto-rolls when long
+
+out, used, dropped = sess.render("my-session", budget=800)
+# -> compressed body + key-facts registry + pinned-fact block, <= 800 tok
+
+orig = sess.expand("my-session", 3)      # byte-for-byte original of turn 3
+hits = sess.search("my-session", "TKT-9001")   # recall across rolled turns
+md = sess.export_md("my-session", "vault.md")  # inspectable Markdown vault
+```
+
+CLI:
+
+```bash
+python -m foldkeep selftest        # 16-case correctness battery
+```
+
+## Proven, not promised
+
+| Suite | Result |
+|---|---|
+| selftest (correctness) | 16/16 |
+| stress_audit (adversarial probes) | 22/22 |
+| marathon (long-session checkpoints) | 9/9, push ≤ 12 ms, render ≤ 80 ms |
+| agent_selftest (real build-session replay, equal budgets) | wins 5/6 cells vs tail-only & head-trunc |
+| chat_selftest (this project's own chat replay) | 12/12, recall 9/9 under forced rolling |
+
+Benchmarks live in this repo (`agent_selftest.py`, `chat_selftest.py`,
+`stress_audit.py`, `long_session_test.py`) — every number reproducible.
+
+## Design
+
+- **Rolling compression**: newest stays verbatim, oldest compresses into a
+  head; hierarchical re-merge keeps the head shrinking.
+- **Three-layer render**: compressed body + one-line entity registry +
+  set-cover pinned-fact block, all inside your token budget.
+- **Loss-tolerance routing**: fences / JSON / tool-call shapes bypass
+  lossy paths entirely.
+- **Lossless base**: `orig_text` column + `originals` table + `expand()`.
+- **Operator knobs**: `OC_REGISTRY_MAX` env caps registry injection.
+
+## Status
+
+v0.9.2. Research notes (`RESEARCH.md`) document the competitive landscape
+(LLMLingua, leanctx, mnesis, FoldAgent, pi-fold, ECC, hermes-agent) and what
+we learned from each.
+
+MIT licensed. Windows/macOS/Linux, Python 3.10+.

foldkeep-0.9.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+foldkeep/__init__.py,sha256=YgI1i0HkgOC7Tyy_6FvUHd8QfF67BvTEoL78kOn3d64,654
+foldkeep/__main__.py,sha256=wT62aXCuN7iwRPQoswnmeGiBS5Cou0CIBvMxbOTfvFs,33
+foldkeep/cli.py,sha256=klhNcHWfvy3fTnLW37acwYdfQ82iL_Xdc9yk6t-eQVE,10193
+foldkeep/diff.py,sha256=XbQXeYAI0J30SI8toFvl69mEh5nuDyLjdXqYwrehHFk,3812
+foldkeep/estimate.py,sha256=9b-ycl1kV6GtLxfd1jaiM17Frw1Ae7RxiiouYTvwOpM,1084
+foldkeep/mcp_server.py,sha256=MEcfMIglstnEHfinuhgf7DC9koQd4MpTqaHDFKdjSek,8245
+foldkeep/packing.py,sha256=c4bIaB37_wvUDjB27nJoiXvB2q_HuxlnqkucTxnf0t4,2469
+foldkeep/selftest.py,sha256=Ty3mgppgnyo26N3BB7VMdkHORE1Pxke8bCv5jA73M9o,5993
+foldkeep/session.py,sha256=z5TwHaCZjvhsFQuTAHsY8ZFW9RH4CMwDmTEc3PbyLMY,17797
+foldkeep/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+foldkeep/core/compressor.py,sha256=Eand_M0KPNHbgZwP-RU2KAdEiFKIBaS-b0_fUIWdo9U,15642
+foldkeep/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+foldkeep/memory/store.py,sha256=6o7a7AMiboS1VZL3AgErmLWpm9OfQQJxMPGxzx4JVNw,3322
+foldkeep-0.9.2.dist-info/licenses/LICENSE,sha256=VFosHB0I5sHdQeeGhyQSyCZUEzDh6hXe5w8sUEMFhQY,1097
+foldkeep-0.9.2.dist-info/METADATA,sha256=G40-TvlErwV-h3HBpLkcfsV-JTENCtwRRek5rNCkSC8,5102
+foldkeep-0.9.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+foldkeep-0.9.2.dist-info/top_level.txt,sha256=rPCGfvrjkGK93LGcI4VTNyG3NqFejwB6pSBzmXOJXjs,9
+foldkeep-0.9.2.dist-info/RECORD,,

foldkeep-0.9.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

foldkeep-0.9.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 foldkeep contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

foldkeep-0.9.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+foldkeep