memorytalk 0.4.0__tar.gz → 0.4.2__tar.gz

{memorytalk-0.4.0 → memorytalk-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorytalk
-Version: 0.4.0
+Version: 0.4.2
 Summary: Persistent cross-session memory for AI agents via Talk-Card architecture (v2)
 License-Expression: Apache-2.0
 Requires-Python: >=3.10
@@ -19,6 +19,7 @@ Requires-Dist: pyarrow>=14.0.0
 Requires-Dist: aiosqlite>=0.19.0
 Requires-Dist: aiofiles>=23.0.0
 Requires-Dist: rich>=13.0.0
+Requires-Dist: questionary>=2.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.4.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.1.0; extra == "dev"

{memorytalk-0.4.0 → memorytalk-0.4.2}/memorytalk/api/__init__.py

@@ -15,7 +15,7 @@ from memorytalk.provider.embedding import (
 )
 from memorytalk.service import (
     CardService, EventWriter, LinkService, RebuildService,
-    SearchService, SessionService,
+    RecallService, SearchService, SessionService, TagService,
 )
 from memorytalk.provider.lancedb import LanceStore
 from memorytalk.provider.storage import LocalStorage
@@ -52,8 +52,12 @@ def create_app(config: Config | None = None) -> FastAPI:
         app.state.db = db
         app.state.vectors = vectors
         app.state.embedder = embedder
+        # TagService must be wired before SessionService (the latter holds
+        # a reference so ingest can stamp `sync_session` tags).
+        app.state.tags = TagService(db=db, storage=storage, events=events)
         app.state.sessions = SessionService(
             config=config, db=db, vectors=vectors, events=events,
+            tags=app.state.tags,
         )
         app.state.cards = CardService(
             config=config, db=db, vectors=vectors, embedder=embedder, events=events,
@@ -62,6 +66,9 @@ def create_app(config: Config | None = None) -> FastAPI:
         app.state.search = SearchService(
             config=config, db=db, vectors=vectors, embedder=embedder,
         )
+        app.state.recall = RecallService(
+            config=config, db=db, vectors=vectors, embedder=embedder,
+        )
         app.state.rebuild = RebuildService(
             config=config, db=db, vectors=vectors, embedder=embedder,
         )
@@ -86,7 +93,7 @@ def create_app(config: Config | None = None) -> FastAPI:
     from memorytalk.api.status import router as status_router
     app.include_router(status_router, prefix="/v2")
 
-    for name in ("sessions", "cards", "links", "tags", "search", "view", "log", "rebuild"):
+    for name in ("sessions", "cards", "links", "tags", "search", "recall", "review", "view", "log", "rebuild"):
         try:
             mod = __import__(f"memorytalk.api.{name}", fromlist=["router"])
             app.include_router(mod.router, prefix="/v2")

memorytalk-0.4.2/memorytalk/api/recall.py

@@ -0,0 +1,18 @@
+"""POST /v2/recall."""
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request
+
+from memorytalk.schemas import RecallRequest, RecallResponse
+from memorytalk.service.recall import RecallError
+
+
+router = APIRouter()
+
+
+@router.post("/recall", response_model=RecallResponse)
+async def post_recall(payload: RecallRequest, request: Request):
+    try:
+        return await request.app.state.recall.recall(payload)
+    except RecallError as e:
+        raise HTTPException(status_code=400, detail=str(e))

memorytalk-0.4.2/memorytalk/api/review.py

@@ -0,0 +1,36 @@
+"""GET /v2/review/list, GET /v2/review/detail/{session_id}.
+
+Pure read-only: thin wrappers over RecallStore queries. No service-layer
+class needed — review has no business logic, it's just SELECTs.
+"""
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Query, Request
+
+from memorytalk.schemas import ReviewDetailResponse, ReviewListResponse
+from memorytalk.util.ids import prefix_session_id
+
+
+router = APIRouter()
+
+
+@router.get("/review/list", response_model=ReviewListResponse)
+async def review_list(
+    request: Request,
+    limit: int = Query(100, gt=0, le=1000),
+):
+    rows = await request.app.state.db.recall.list_sessions(limit=limit)
+    return ReviewListResponse(sessions=rows)
+
+
+@router.get("/review/detail/{session_id}", response_model=ReviewDetailResponse)
+async def review_detail(
+    session_id: str,
+    request: Request,
+    limit: int = Query(50, gt=0, le=500),
+):
+    sid = prefix_session_id(session_id)
+    detail = await request.app.state.db.recall.session_detail(sid, limit=limit)
+    if detail is None:
+        raise HTTPException(status_code=404, detail="session not found in recall log")
+    return ReviewDetailResponse(**detail)

memorytalk-0.4.2/memorytalk/api/tags.py

@@ -0,0 +1,71 @@
+"""Tag endpoints — resource-rooted (subject in URL path).
+
+Sessions:
+  POST   /v2/sessions/{session_id}/tags   body: {"tags": ["k:v", ...]}
+  DELETE /v2/sessions/{session_id}/tags?key=k1&key=k2
+
+Cards (commit 2 will enable):
+  POST   /v2/cards/{card_id}/tags
+  DELETE /v2/cards/{card_id}/tags?key=...
+
+Subject-id prefix validation happens inside TagService — the path param
+just plumbs whatever string the URL had through. A wrong-prefix id
+(e.g. ``sess_xxx`` posted to the cards route) returns 400 from the
+service layer rather than a 404 from FastAPI routing.
+"""
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Query, Request
+
+from memorytalk.schemas import TagsAddRequest, TagsResponse
+from memorytalk.service import SessionNotFound, TagServiceError
+
+
+router = APIRouter()
+
+
+async def _wrap_call(coro):
+    try:
+        return await coro
+    except SessionNotFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except TagServiceError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.post("/sessions/{session_id}/tags", response_model=TagsResponse)
+async def post_session_tags(
+    session_id: str, payload: TagsAddRequest, request: Request,
+) -> TagsResponse:
+    return await _wrap_call(
+        request.app.state.tags.add_tags(session_id, payload.tags)
+    )
+
+
+@router.delete("/sessions/{session_id}/tags", response_model=TagsResponse)
+async def delete_session_tags(
+    session_id: str, request: Request,
+    key: list[str] = Query(..., min_length=1),
+) -> TagsResponse:
+    return await _wrap_call(
+        request.app.state.tags.remove_tags(session_id, key)
+    )
+
+
+@router.post("/cards/{card_id}/tags", response_model=TagsResponse)
+async def post_card_tags(
+    card_id: str, payload: TagsAddRequest, request: Request,
+) -> TagsResponse:
+    return await _wrap_call(
+        request.app.state.tags.add_tags(card_id, payload.tags)
+    )
+
+
+@router.delete("/cards/{card_id}/tags", response_model=TagsResponse)
+async def delete_card_tags(
+    card_id: str, request: Request,
+    key: list[str] = Query(..., min_length=1),
+) -> TagsResponse:
+    return await _wrap_call(
+        request.app.state.tags.remove_tags(card_id, key)
+    )

{memorytalk-0.4.0 → memorytalk-0.4.2}/memorytalk/cli/__init__.py

@@ -13,9 +13,12 @@ def main() -> None:
 main.add_command(server)
 
 # Other command groups are attached as they're implemented.
-for _name in ("card", "tag", "link", "sync", "search", "view", "log", "rebuild", "setup"):
+for _name in ("card", "tag", "link", "sync", "search", "recall", "review", "view", "log", "rebuild", "setup", "filter"):
     try:
         _mod = __import__(f"memorytalk.cli.{_name}", fromlist=[_name])
-        main.add_command(getattr(_mod, _name))
+        # `filter` shadows a builtin → the command object is named `filter_`
+        # in the module; everything else uses the same name as the module.
+        attr = "filter_" if _name == "filter" else _name
+        main.add_command(getattr(_mod, attr))
     except ImportError:
         pass

{memorytalk-0.4.0 → memorytalk-0.4.2}/memorytalk/cli/_format.py

@@ -141,6 +141,10 @@ def fmt_view_card(resp: dict) -> str:
     if card.get("summary"):
         out.append(f"**Summary:** {card['summary']}")
         out.append("")
+    tags = card.get("tags") or []
+    if tags:
+        out.append("**Tags:** " + ", ".join(f"`{_tag_label(t)}`" for t in tags))
+        out.append("")
 
     links = resp.get("links") or []
     out.append(f"## links ({len(links)})")
@@ -180,7 +184,7 @@ def fmt_view_session(resp: dict) -> str:
         out.append("")
     tags = sess.get("tags") or []
     if tags:
-        out.append("**Tags:** " + ", ".join(f"`{t}`" for t in tags))
+        out.append("**Tags:** " + ", ".join(f"`{_tag_label(t)}`" for t in tags))
         out.append("")
     metadata = sess.get("metadata") or {}
     if metadata:
@@ -247,8 +251,18 @@ def _detail_summary(kind: str, detail: dict) -> str:
     if kind == "rounds_overwrite_skipped":
         idxs = detail.get("indexes", [])
         return f"indexes={','.join(str(i) for i in idxs)}"
-    if kind == "tag_added" or kind == "tag_removed":
-        return f"`{detail.get('tag', '')}`"
+    if kind in ("tag_added", "tag_removed"):
+        key = detail.get("key", "")
+        value = detail.get("value", "") or ""
+        label = f"{key}:{value}" if value else key
+        return f"`{label}`"
+    if kind == "tag_updated":
+        key = detail.get("key", "")
+        value = detail.get("value", "") or ""
+        prior = detail.get("prior_value", "") or ""
+        new_label = f"{key}:{value}" if value else key
+        old_label = f"{key}:{prior}" if prior else key
+        return f"`{old_label}` → `{new_label}`"
     if kind == "card_extracted":
         return f"`{detail.get('card_id', '')}` · indexes={detail.get('indexes', '')}"
     if kind == "linked":
@@ -321,6 +335,90 @@ def fmt_log(resp: dict) -> str:
     return fmt_error(f"unknown log type: {resp.get('type')!r}")
 
 
+# ---------- review ----------
+
+def fmt_review_list(resp: dict) -> str:
+    sessions = resp.get("sessions") or []
+    out: list[str] = []
+    out.append(f"# Sessions with recall history ({len(sessions)})")
+    out.append("")
+    if not sessions:
+        out.append("*(no recall history yet — call `memory-talk recall <session_id> <prompt>` first)*")
+        out.append("")
+        return _join(*out)
+    for s in sessions:
+        sid = s.get("session_id", "")
+        exist = "true" if s.get("session_exist") else "false"
+        rc = s.get("round_count", 0)
+        ci = s.get("cards_injected", 0)
+        last = s.get("last_at", "")
+        last_q = (s.get("last_query") or "").replace("\n", " ").strip()
+        out.append(
+            f"- **`{sid}`** · `session_exist={exist}` · {rc} rounds · "
+            f"{ci} cards · last {last}"
+        )
+        if last_q:
+            out.append(f"  > {last_q}")
+        out.append("")
+    return _join(*out)
+
+
+def fmt_review_detail(resp: dict) -> str:
+    sid = resp.get("session_id", "")
+    exist = "true" if resp.get("session_exist") else "false"
+    out: list[str] = []
+    out.append(f"# `{sid}` · session_exist={exist}")
+    out.append("")
+    out.append(
+        f"{resp.get('round_count', 0)} rounds · "
+        f"{resp.get('cards_injected', 0)} cards (deduped) · "
+        f"first {resp.get('first_at', '')} · last {resp.get('last_at', '')}"
+    )
+    out.append("")
+    rounds = resp.get("rounds") or []
+    for i, r in enumerate(rounds):
+        if i > 0:
+            out.append("---")
+            out.append("")
+        rc = r.get("round_count", "?")
+        rec_at = r.get("recalled_at", "")
+        out.append(f"## Round {rc} · {rec_at}")
+        out.append("")
+        q = (r.get("query") or "").replace("\n", " ").strip()
+        if q:
+            out.append(f"> {q}")
+            out.append("")
+        for hit in r.get("hits") or []:
+            cid = hit.get("card_id", "")
+            summary = (hit.get("summary") or "").replace("\n", " ").strip()
+            line = f"{hit.get('rank', '?')}. `{cid}`"
+            if summary:
+                line += f" — {summary}"
+            out.append(line)
+        out.append("")
+    return _join(*out)
+
+
+# ---------- recall ----------
+
+def fmt_recall(resp: dict) -> str:
+    """Bash code-block style — designed to be inlined into LLM context.
+
+    Empty hit set → empty string (per docs: no '## Memory recall (0)'
+    placeholder; the harness gets nothing to inject).
+    """
+    hits = resp.get("recalled") or []
+    if not hits:
+        return ""
+    lines = ["```bash", "# Relevant memories — run any to expand detail:"]
+    for h in hits:
+        cid = h.get("card_id", "")
+        summary = (h.get("summary") or "").replace("\n", " ").strip()
+        lines.append(f"memory-talk view {cid}  # {summary}")
+    lines.append("```")
+    return _join(*lines)
+
+
 # ---------- write commands (single line ok) ----------
 
 def fmt_card_create(resp: dict) -> str:
@@ -331,11 +429,18 @@ def fmt_link_create(resp: dict) -> str:
     return f"ok: linked `{resp.get('link_id', '')}`\n"
 
 
+def _tag_label(pair: dict) -> str:
+    """Render `{"key": "k", "value": "v"}` as ``k:v`` (or just ``k`` if value is empty)."""
+    key = pair.get("key", "")
+    value = pair.get("value", "") or ""
+    return f"{key}:{value}" if value else key
+
+
 def fmt_tag(resp: dict) -> str:
     tags = resp.get("tags") or []
     if not tags:
         return "ok: tags = *(empty)*\n"
-    return "ok: tags = " + ", ".join(f"`{t}`" for t in tags) + "\n"
+    return "ok: tags = " + ", ".join(f"`{_tag_label(p)}`" for p in tags) + "\n"
 
 
 # ---------- sync / rebuild ----------

{memorytalk-0.4.0 → memorytalk-0.4.2}/memorytalk/cli/_http.py

@@ -57,13 +57,14 @@ _make_client: Optional[Callable[[Config], httpx.Client]] = None
 
 
 def api(method: str, path: str, config: Config,
-        json_body: dict | None = None, timeout: float = 30.0) -> dict:
+        json_body: dict | None = None, timeout: float = 30.0,
+        params: dict | list[tuple[str, str]] | None = None) -> dict:
     factory = _make_client or _default_client
     client = factory(config)
     # No `with` — ASGI test transport has no context-manager support, and
     # the CLI is a short-lived process where leaked TCP sockets get reaped
     # at exit. Tests share a long-lived ASGI client across calls.
-    resp = client.request(method, path, json=json_body, timeout=timeout)
+    resp = client.request(method, path, json=json_body, timeout=timeout, params=params)
     if resp.status_code >= 400:
         try:
             payload = resp.json()