memorytalk 5.0.2__tar.gz → 5.0.4__tar.gz

{memorytalk-5.0.2 → memorytalk-5.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memorytalk
-Version: 5.0.2
+Version: 5.0.4
 Summary: memory.talk v5 — work / collections / user 三个顶层对象的工作台:跑 code agent 的 work 树,git 分层的认知层,注册的团队成员
 Project-URL: Homepage, https://github.com/memory-co/memory.talk
 Project-URL: Repository, https://github.com/memory-co/memory.talk

{memorytalk-5.0.2 → memorytalk-5.0.4}/docs/api/v5/README.md

@@ -56,7 +56,7 @@
 
 ## 通用约定
 
-- **响应信封**:所有 `/api/*` 的响应都是 **`{"data": …, "message": "ok"}`**——分页面里写的响应体是 `data` 那一半。纯文本端点(recall / capture)的 `data` 是那段字符串;删除类端点返回 `200`,`data` 为 `null`(不再有 204)。
+- **响应信封**:所有 `/api/*` 端点的 `response_model` 都是 **`Result[T]`** = **`{"data": T, "message": "ok"}`**(OpenAPI 里能看到 `Result_User_` 这类 schema)——分页面里写的响应体是 `data` 那一半。纯文本端点(recall / capture)的 `data` 是那段字符串;删除类端点返回 `200`,`data` 为 `null`(不再有 204)。
 - **错误体**:`{"data": null, "error": "<机器码>", "message": "<人读>"}`。
 
   | 状态 | `error` | 何时 |

{memorytalk-5.0.2 → memorytalk-5.0.4}/docs/cli/v5/README.md

@@ -8,6 +8,7 @@
 
 ```
 memory.talk
+├── version                                             # 版本号(也可 -V / --version)
 ├── server   start | stop | restart | status          # 本地 API 服务(后台守护)
 ├── work     create | list | show | set               # work 树
 │            attach | sessions | detach | capture | rounds   # 会话(现场)

memorytalk-5.0.4/memorytalk/__init__.py

@@ -0,0 +1,21 @@
+"""memory.talk —— 跑 code agent 的工作台,记忆是它的副产物。"""
+from importlib.metadata import PackageNotFoundError, version as _version
+from pathlib import Path
+
+
+def _from_pyproject() -> str:
+    """没安装、直接从源码跑时,读仓库根 pyproject.toml 的 version。"""
+    try:
+        import tomllib
+        with open(Path(__file__).resolve().parents[1] / "pyproject.toml", "rb") as f:
+            return tomllib.load(f)["project"]["version"] + "+src"
+    except Exception:
+        return "0.0.0+src"
+
+
+try:
+    __version__ = _version("memorytalk")
+except PackageNotFoundError:
+    __version__ = _from_pyproject()
+
+__all__ = ["__version__"]

{memorytalk-5.0.2 → memorytalk-5.0.4}/memorytalk/backend/README.md

@@ -7,9 +7,9 @@ memorytalk/backend/           # 服务本体;memorytalk/cli.py 是它的命令
 ├── main.py                   # FastAPI 实例、路由挂载、启动钩子
 ├── config.py                 # 环境变量与路径(~/.memory.talk/{memory,works})
 ├── gateway.py                # AuthGate + 静态托管 + 反代(/tty、/proxy/<port>)
-├── envelope.py               # 响应信封中间件:所有 /api/* → {"data", "message"[, "error"]}
 │
 ├── models/                   # 数据模型(纯结构,不含 IO)
+│   ├── result.py             #   Result[T]:统一响应信封 {data, message[, error]},每个端点的 response_model
 │   ├── users.py              #   User(档案,存)/ UserView / UserProfile(带派生统计)
 │   ├── work.py               #   Work 节点(目标、created_by、状态、父子)、Canvas、Session、WorkUser、Round、Event
 │   ├── collections.py            #   LayerInfo / Obj / Revision / SearchHit / Catalog / Tree / Manager / InboxItem

{memorytalk-5.0.2 → memorytalk-5.0.4}/memorytalk/backend/controllers/collections.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 from typing import Any
 
+from memorytalk.backend.models.result import Result, ok
 from fastapi import APIRouter, Depends, Header, Query, Request
 
 from memorytalk.backend.models.collections import (CatalogDir, InboxItem, LayerCreate, LayerInfo, Manager, ManagerPut, Obj,
@@ -25,91 +26,93 @@ def ctx(request: Request, x_memory_talk_user: str | None = Header(None, alias="X
 
 # ---- 固定路径先于 /{layer} ----
 
-@router.get("/layers", response_model=list[LayerInfo], summary="有哪些层(最底在前)、各自的 schema 与行为")
+@router.get("/layers", response_model=Result[list[LayerInfo]], summary="有哪些层(最底在前)、各自的 schema 与行为")
 def layers(svc: CollectionsService = Depends(collections)):
-    return svc.layer_infos()
+    return ok(svc.layer_infos())
 
 
-@router.post("/layers", response_model=LayerInfo, status_code=201, summary="加一个用户层:一份 schema YAML")
+@router.post("/layers", response_model=Result[LayerInfo], status_code=201, summary="加一个用户层:一份 schema YAML")
 def add_layer(req: LayerCreate, svc: CollectionsService = Depends(collections), c: Ctx = Depends(ctx)):
-    return svc.add_layer(req.name, req.schema_yaml, req.reason, c)
+    return ok(svc.add_layer(req.name, req.schema_yaml, req.reason, c))
 
 
-@router.get("/config", summary="collections.json 本体 + 它的 git 历史(层的变化史)")
+@router.get("/config", summary="collections.json 本体 + 它的 git 历史(层的变化史)", response_model=Result[dict])
 def config(svc: CollectionsService = Depends(collections)) -> dict:
-    return {"config": svc.anchor(), "history": [r.model_dump() for r in svc.anchor_history()]}
+    return ok({"config": svc.anchor(), "history": [r.model_dump() for r in svc.anchor_history()]})
 
 
-@router.get("/tree", response_model=list[TreeItem], summary="浏览目录树:对象(带后缀的目录折成一项)、目录、origin 文件")
+@router.get("/tree", response_model=Result[list[TreeItem]], summary="浏览目录树:对象(带后缀的目录折成一项)、目录、origin 文件")
 def tree(path: str = "", svc: CollectionsService = Depends(collections)):
-    return svc.tree(path)
+    return ok(svc.tree(path))
 
 
-@router.get("/search", response_model=list[SearchHit], summary="git grep 整个 Collections(可限定层)")
+@router.get("/search", response_model=Result[list[SearchHit]], summary="git grep 整个 Collections(可限定层)")
 def search(q: str, layer: str | None = None, svc: CollectionsService = Depends(collections)):
-    return svc.search(q, layer)
+    return ok(svc.search(q, layer))
 
 
-@router.get("/manager", response_model=Manager | None, summary="这个路径归谁管(最近的 manager.json)")
+@router.get("/manager", response_model=Result[Manager | None], summary="这个路径归谁管(最近的 manager.json)")
 def get_manager(path: str = "", svc: CollectionsService = Depends(collections)):
-    return svc.manager(path)
+    return ok(svc.manager(path))
 
 
-@router.put("/manager", response_model=Manager, summary="在这个目录(或对象)下放 manager.json,绑到一个 work")
+@router.put("/manager", response_model=Result[Manager], summary="在这个目录(或对象)下放 manager.json,绑到一个 work")
 def put_manager(req: ManagerPut, path: str = "", svc: CollectionsService = Depends(collections), c: Ctx = Depends(ctx)):
-    return svc.set_manager(path, req.work, req.reason, c)
+    return ok(svc.set_manager(path, req.work, req.reason, c))
 
 
 @router.delete("/manager", summary="解绑:删这个目录的 manager.json")
 def delete_manager(path: str = "", reason: str = "", svc: CollectionsService = Depends(collections), c: Ctx = Depends(ctx)):
     svc.unset_manager(path, reason, c)
+    return ok()
 
 
-@router.get("/managed", response_model=list[TreeItem], summary="某个 work 管的所有对象;不传 work = 没人管的对象")
+@router.get("/managed", response_model=Result[list[TreeItem]], summary="某个 work 管的所有对象;不传 work = 没人管的对象")
 def managed(work: str | None = None, svc: CollectionsService = Depends(collections)):
-    return svc.managed_by(work) if work else svc.unmanaged()
+    return ok(svc.managed_by(work) if work else svc.unmanaged())
 
 
-@router.get("/history/{layer}/{path:path}", response_model=list[Revision], summary="一个对象的 git log(这一层的分支上)")
+@router.get("/history/{layer}/{path:path}", response_model=Result[list[Revision]], summary="一个对象的 git log(这一层的分支上)")
 def history(layer: str, path: str, svc: CollectionsService = Depends(collections)):
-    return svc.history(layer, path)
+    return ok(svc.history(layer, path))
 
 
 @router.post("/act/{layer}/{action}/{path:path}", summary="行为:schema 之上的领域动作(issue: position / argue / link / spawn / decide;card: discuss)")
 def act(layer: str, action: str, path: str, payload: dict[str, Any], svc: CollectionsService = Depends(collections),
         c: Ctx = Depends(ctx)) -> Any:
-    return svc.act(layer, action, path, payload, c)
+    return ok(svc.act(layer, action, path, payload, c))
 
 
 # ---- 层级 / 对象 ----
 
-@router.get("/{layer}", response_model=CatalogDir, summary="一层的目录(按目录树列标题)")
+@router.get("/{layer}", response_model=Result[CatalogDir], summary="一层的目录(按目录树列标题)")
 def catalog(layer: str, dir: str = "", svc: CollectionsService = Depends(collections)):
-    return svc.catalog(layer, dir)
+    return ok(svc.catalog(layer, dir))
 
 
 @router.get("/{layer}/recall", summary="目录渲染成可注入 agent 的文本")
 def recall(layer: str, dir: str = "", svc: CollectionsService = Depends(collections)):
-    return svc.recall_text(layer, dir)
+    return ok(svc.recall_text(layer, dir))
 
 
-@router.post("/{layer}/{path:path}", response_model=Obj, status_code=201, summary="建一个对象(一个 [layer] 提交)")
+@router.post("/{layer}/{path:path}", response_model=Result[Obj], status_code=201, summary="建一个对象(一个 [layer] 提交)")
 def create(layer: str, path: str, req: ObjCreate, svc: CollectionsService = Depends(collections), c: Ctx = Depends(ctx)):
     data = req.content if svc.layer(layer).format == "raw" else (req.data or {})
-    return svc.create(layer, path, data, req.reason, c)
+    return ok(svc.create(layer, path, data, req.reason, c))
 
 
-@router.get("/{layer}/{path:path}", response_model=Obj, summary="读一个对象(rev= 读历史版本)")
+@router.get("/{layer}/{path:path}", response_model=Result[Obj], summary="读一个对象(rev= 读历史版本)")
 def get(layer: str, path: str, rev: str | None = Query(None), svc: CollectionsService = Depends(collections)):
-    return svc.get(layer, path, rev)
+    return ok(svc.get(layer, path, rev))
 
 
-@router.put("/{layer}/{path:path}", response_model=Obj, summary="改一个对象(字段合并;origin 整体替换)")
+@router.put("/{layer}/{path:path}", response_model=Result[Obj], summary="改一个对象(字段合并;origin 整体替换)")
 def update(layer: str, path: str, req: ObjUpdate, svc: CollectionsService = Depends(collections), c: Ctx = Depends(ctx)):
     patch = req.content if svc.layer(layer).format == "raw" else (req.data or {})
-    return svc.update(layer, path, patch, req.reason, c)
+    return ok(svc.update(layer, path, patch, req.reason, c))
 
 
 @router.delete("/{layer}/{path:path}", summary="删一个对象(历史在 git)")
 def delete(layer: str, path: str, reason: str = "", svc: CollectionsService = Depends(collections), c: Ctx = Depends(ctx)):
     svc.delete(layer, path, reason, c)
+    return ok()

memorytalk-5.0.4/memorytalk/backend/controllers/system.py

@@ -0,0 +1,18 @@
+from memorytalk.backend.models.result import Result, ok
+from fastapi import APIRouter, Request
+
+router = APIRouter(prefix="/api/system", tags=["system"])
+
+
+@router.get("/health", summary="健康检查", response_model=Result[dict])
+def health():
+    return ok({"ok": True})
+
+
+@router.get("/info", summary="运行信息:路径、存储 provider、tmux socket、有没有窗", response_model=Result[dict])
+def info(request: Request):
+    cfg, rt = request.app.state.config, request.app.state.runtime
+    store = request.app.state.store.provider
+    return ok({"home": str(cfg.home), "collections": str(cfg.collections_dir),
+               "store": {"family": store.family, "backend": type(store).__name__},
+               "workspace": str(rt.workspace), "tmux_socket": rt.tmux_socket, "ttyd_url": rt.ttyd_url})

memorytalk-5.0.4/memorytalk/backend/controllers/users.py

@@ -0,0 +1,39 @@
+"""/api/users —— user 是注册的顶层对象:注册、档案、清单、我是谁。不做权限。"""
+from __future__ import annotations
+
+from memorytalk.backend.models.result import Result, ok
+from fastapi import APIRouter, Depends, Header, Request
+
+from memorytalk.backend.models.users import User, UserCreate, UserProfile, UserUpdate, UserView
+from memorytalk.backend.services.users import UserService
+
+router = APIRouter(prefix="/api/users", tags=["users"])
+
+
+def users(request: Request) -> UserService:
+    return request.app.state.users
+
+
+@router.get("", response_model=Result[list[UserView]], summary="所有注册的 user,带活动统计,按最近活动倒序")
+def list_users(svc: UserService = Depends(users)):
+    return ok(svc.list())
+
+
+@router.post("", response_model=Result[User], status_code=201, summary="注册一个 user(name 唯一;之后请求头 X-Memory-Talk-User 用它)")
+def register(req: UserCreate, svc: UserService = Depends(users)):
+    return ok(svc.register(req))
+
+
+@router.get("/me", response_model=Result[UserProfile | None], summary="我是谁:X-Memory-Talk-User 对应的 user 档案(没带 → null)")
+def me(svc: UserService = Depends(users), x_memory_talk_user: str | None = Header(None, alias="X-Memory-Talk-User")):
+    return ok(svc.profile(x_memory_talk_user) if x_memory_talk_user else None)
+
+
+@router.get("/{name}", response_model=Result[UserProfile], summary="一个 user 的档案 + 建的 / 动过的 work、最近的提交")
+def get_user(name: str, svc: UserService = Depends(users)):
+    return ok(svc.profile(name))
+
+
+@router.put("/{name}", response_model=Result[User], summary="改档案(display_name / email)")
+def update_user(name: str, req: UserUpdate, svc: UserService = Depends(users)):
+    return ok(svc.update(name, req))

{memorytalk-5.0.2 → memorytalk-5.0.4}/memorytalk/backend/controllers/works.py

@@ -1,6 +1,7 @@
 """/api/works —— 树、画布、会话(attach = 经 server 建现场)、痕迹、事件、召回。"""
 from __future__ import annotations
 
+from memorytalk.backend.models.result import Result, ok
 from fastapi import APIRouter, Depends, Header, Query, Request
 
 from memorytalk.backend.models.collections import InboxItem
@@ -28,38 +29,38 @@ def user(request: Request, x_memory_talk_user: str | None = Header(None, alias="
     return x_memory_talk_user
 
 
-@router.get("", response_model=list[WorkNode], summary="work 树(森林;root= 只看一棵;created_by= 只看某人建的)")
+@router.get("", response_model=Result[list[WorkNode]], summary="work 树(森林;root= 只看一棵;created_by= 只看某人建的)")
 def forest(root: str | None = None, created_by: str | None = None, svc: WorkService = Depends(works)):
-    return svc.forest(root, created_by)
+    return ok(svc.forest(root, created_by))
 
 
-@router.get("/servers", response_model=list[WorkServerInfo],
+@router.get("/servers", response_model=Result[list[WorkServerInfo]],
             summary="有哪些 work server(bash / claude / codex / kimi / http / default)及各自响应的协议;attach 时按协议去找它们")
 def servers(request: Request):
-    return request.app.state.work_servers.list()
+    return ok(request.app.state.work_servers.list())
 
 
-@router.post("", response_model=Work, status_code=201, summary="开工:建一个 work(parent= 挂到树上)")
+@router.post("", response_model=Result[Work], status_code=201, summary="开工:建一个 work(parent= 挂到树上)")
 def create(req: WorkCreate, svc: WorkService = Depends(works), who: str | None = Depends(user)):
-    return svc.create(req, created_by=who)
+    return ok(svc.create(req, created_by=who))
 
 
-@router.get("/{work_id}", response_model=Work, summary="读一个 work(带身份 = 打开它,记一笔在操作)")
+@router.get("/{work_id}", response_model=Result[Work], summary="读一个 work(带身份 = 打开它,记一笔在操作)")
 def get(work_id: str, svc: WorkService = Depends(works), who: str | None = Depends(user)):
     svc.touch(work_id, who)
-    return svc.get(work_id)
+    return ok(svc.get(work_id))
 
 
-@router.patch("/{work_id}", response_model=Work,
+@router.patch("/{work_id}", response_model=Result[Work],
               summary="改目标 / 状态;done 要求子 work 全完;结束后会话冻结")
 def update(work_id: str, req: WorkUpdate, svc: WorkService = Depends(works), who: str | None = Depends(user)):
     svc.touch(work_id, who)
-    return svc.update(work_id, req)
+    return ok(svc.update(work_id, req))
 
 
-@router.get("/{work_id}/events", response_model=list[Event], summary="work 自己的时间线")
+@router.get("/{work_id}/events", response_model=Result[list[Event]], summary="work 自己的时间线")
 def events(work_id: str, svc: WorkService = Depends(works)):
-    return svc.history(work_id)
+    return ok(svc.history(work_id))
 
 
 @router.get("/{work_id}/recall",
@@ -67,81 +68,82 @@ def events(work_id: str, svc: WorkService = Depends(works)):
 def recall(work_id: str, dir: str = "", layer: str = "card", svc: WorkService = Depends(works),
            c: CollectionsService = Depends(collections)):
     svc.get(work_id)
-    return c.recall_text(layer, dir)
+    return ok(c.recall_text(layer, dir))
 
 
-@router.get("/{work_id}/inbox", response_model=list[InboxItem],
+@router.get("/{work_id}/inbox", response_model=Result[list[InboxItem]],
             summary="收件箱:被 manager.json 路由过来的变动(Collections 的对象、子 work 的状态)")
 def inbox(work_id: str, svc: WorkService = Depends(works)):
-    return svc.read_inbox(work_id)
+    return ok(svc.read_inbox(work_id))
 
 
-@router.get("/{work_id}/manager", summary="这个 work 的变动打给谁:manager.json,没有则父 work")
+@router.get("/{work_id}/manager", summary="这个 work 的变动打给谁:manager.json,没有则父 work", response_model=Result[dict])
 def get_manager(work_id: str, svc: WorkService = Depends(works)) -> dict:
-    return {"work": svc.manager_of(work_id)}
+    return ok({"work": svc.manager_of(work_id)})
 
 
-@router.put("/{work_id}/manager", summary="改写默认:这棵子树的变动打给指定 work(null = 删掉,回到父)")
+@router.put("/{work_id}/manager", summary="改写默认:这棵子树的变动打给指定 work(null = 删掉,回到父)", response_model=Result[dict])
 def put_manager(work_id: str, req: dict, svc: WorkService = Depends(works)) -> dict:
-    return {"work": svc.set_manager(work_id, req.get("work"))}
+    return ok({"work": svc.set_manager(work_id, req.get("work"))})
 
 
-@router.get("/{work_id}/users", response_model=WorkUsers,
+@router.get("/{work_id}/users", response_model=Result[WorkUsers],
             summary="user:谁当前正在操作(current)、谁历史操作过(history)。只做可见性,不做权限")
 def users(work_id: str, svc: WorkService = Depends(works)):
-    return svc.list_users(work_id)
+    return ok(svc.list_users(work_id))
 
 
-@router.post("/{work_id}/users/touch", response_model=WorkUsers, summary="我在操作这个 work(心跳;身份来自 X-Memory-Talk-User)")
+@router.post("/{work_id}/users/touch", response_model=Result[WorkUsers], summary="我在操作这个 work(心跳;身份来自 X-Memory-Talk-User)")
 def touch(work_id: str, svc: WorkService = Depends(works), who: str | None = Depends(user)):
     svc.touch(work_id, who)
-    return svc.list_users(work_id)
+    return ok(svc.list_users(work_id))
 
 
-@router.get("/{work_id}/canvas", response_model=Canvas, summary="画布(视图,随时可重排)")
+@router.get("/{work_id}/canvas", response_model=Result[Canvas], summary="画布(视图,随时可重排)")
 def get_canvas(work_id: str, svc: WorkService = Depends(works)):
-    return svc.get_canvas(work_id)
+    return ok(svc.get_canvas(work_id))
 
 
-@router.put("/{work_id}/canvas", response_model=Canvas, summary="全量写画布(version 乐观锁)")
+@router.put("/{work_id}/canvas", response_model=Result[Canvas], summary="全量写画布(version 乐观锁)")
 def put_canvas(work_id: str, req: CanvasPut, svc: WorkService = Depends(works), who: str | None = Depends(user)):
     svc.touch(work_id, who)
-    return svc.put_canvas(work_id, req)
+    return ok(svc.put_canvas(work_id, req))
 
 
-@router.get("/{work_id}/sessions", response_model=list[SessionView], summary="会话清单(含活没活着)")
+@router.get("/{work_id}/sessions", response_model=Result[list[SessionView]], summary="会话清单(含活没活着)")
 def sessions(work_id: str, svc: WorkService = Depends(works)):
-    return svc.list_sessions(work_id)
+    return ok(svc.list_sessions(work_id))
 
 
-@router.post("/{work_id}/sessions", response_model=SessionView, status_code=201,
+@router.post("/{work_id}/sessions", response_model=Result[SessionView], status_code=201,
              summary="在 work 里打开一个块:协议 → server 建现场,登记会话,交回窗 + 把手")
 def attach(work_id: str, req: SessionCreate, svc: WorkService = Depends(works), who: str | None = Depends(user)):
     svc.touch(work_id, who)
-    return svc.attach(work_id, req.uri)
+    return ok(svc.attach(work_id, req.uri))
 
 
-@router.post("/{work_id}/sessions/{session_id}/attach", response_model=SessionView,
+@router.post("/{work_id}/sessions/{session_id}/attach", response_model=Result[SessionView],
              summary="重入:幂等取回同一个现场")
 def reattach(work_id: str, session_id: str, svc: WorkService = Depends(works), who: str | None = Depends(user)):
     svc.touch(work_id, who)
-    return svc.reattach(work_id, session_id)
+    return ok(svc.reattach(work_id, session_id))
 
 
 @router.delete("/{work_id}/sessions/{session_id}", summary="关闭即回收:销毁现场 + 删登记")
 def detach(work_id: str, session_id: str, svc: WorkService = Depends(works), who: str | None = Depends(user)):
     svc.touch(work_id, who)
     svc.detach(work_id, session_id)
+    return ok()
 
 
 @router.get("/{work_id}/sessions/{session_id}/capture",
             summary="观测:抓终端屏幕(把手 capture)")
 def capture(work_id: str, session_id: str, lines: int = Query(200, ge=1, le=5000),
             svc: WorkService = Depends(works)):
-    return svc.capture(work_id, session_id, lines)
+    return ok(svc.capture(work_id, session_id, lines))
 
 
-@router.get("/{work_id}/sessions/{session_id}/rounds", response_model=list[Round],
+@router.get("/{work_id}/sessions/{session_id}/rounds", response_model=Result[list[Round]],
             summary="痕迹:agent 会话的 round(先从把手同步新 round,再读 rounds.jsonl)")
 def rounds(work_id: str, session_id: str, svc: WorkService = Depends(works)):
-    return svc.rounds(work_id, session_id)
+    return ok(svc.rounds(work_id, session_id))

{memorytalk-5.0.2 → memorytalk-5.0.4}/memorytalk/backend/main.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
 
-from memorytalk.backend.envelope import EnvelopeMiddleware, envelope
+from memorytalk.backend.models.result import fail
 
 from memorytalk.backend.config import Config, RuntimeConfig, load_config, load_runtime_config
 from memorytalk.backend.controllers import collections, system, users, works
@@ -35,11 +35,10 @@ def create_app(config: Config | None = None, runtime: RuntimeConfig | None = Non
 
     for r in (system.router, works.router, users.router, collections.router):
         app.include_router(r)
-    app.add_middleware(EnvelopeMiddleware)         # 所有 /api/* 响应包成 {"data", "message"[, "error"]}
 
     def _err(status: int, code: str):
         async def handler(_: Request, exc: Exception):
-            return JSONResponse(envelope(None, str(exc), code), status_code=status)
+            return JSONResponse(fail(code, str(exc)), status_code=status)
         return handler
 
     for exc_type in (WorkNotFound, SessionNotFound, UserNotFound):
@@ -49,11 +48,11 @@ def create_app(config: Config | None = None, runtime: RuntimeConfig | None = Non
 
     @app.exception_handler(CollectionsError)
     async def _collect(_: Request, exc: CollectionsError):
-        return JSONResponse(envelope(None, str(exc), exc.code), status_code=exc.status)
+        return JSONResponse(fail(exc.code, str(exc)), status_code=exc.status)
 
     @app.exception_handler(WorkServerError)
     async def _server(_: Request, exc: WorkServerError):
         status = {"bad_uri": 400, "cmd_not_found": 400, "no_server": 400, "platform": 502}.get(exc.code, 500)
-        return JSONResponse(envelope(None, str(exc), exc.code), status_code=status)
+        return JSONResponse(fail(exc.code, str(exc)), status_code=status)
 
     return app

memorytalk-5.0.4/memorytalk/backend/models/result.py

@@ -0,0 +1,30 @@
+"""统一响应信封:所有 /api/* 端点返回 Result[T] = {"data": T, "message": "ok"};出错时 data 为 null、多一个 error 机器码。
+显式写在每个端点的 response_model 上,OpenAPI 文档和实际响应一致。"""
+from __future__ import annotations
+
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel, Field, model_serializer
+
+T = TypeVar("T")
+
+
+class Result(BaseModel, Generic[T]):
+    data: T | None = None
+    message: str = "ok"
+    error: str | None = Field(None, description="出错时的机器码;成功时没有")
+
+    @model_serializer(mode="wrap")
+    def _drop_empty_error(self, handler):
+        out = handler(self)
+        if out.get("error") is None:
+            out.pop("error", None)            # 成功时就是 {"data", "message"},没有 error 键
+        return out
+
+
+def ok(data=None, message: str = "ok") -> dict:
+    return {"data": data, "message": message}
+
+
+def fail(error: str, message: str) -> dict:
+    return {"data": None, "message": message, "error": error}

{memorytalk-5.0.2 → memorytalk-5.0.4}/memorytalk/cli/__init__.py

@@ -1,5 +1,6 @@
 """memory.talk 命令行:本地 API 的客户端,不含业务逻辑(docs/cli/v5)。
 
+    memory.talk version                                                    → 版本号
     memory.talk server      start | stop | restart | status | daemon        → cli/server.py
     memory.talk work        create | list | show | set | attach | …          → cli/work.py
     memory.talk user        add | list | show | set | whoami                 → cli/user.py
@@ -12,6 +13,8 @@ from __future__ import annotations
 import argparse
 import os
 
+from memorytalk import __version__
+
 from . import collection, server, user, work
 from ._common import DEFAULT_SERVER, Api
 
@@ -22,7 +25,9 @@ def build_parser() -> argparse.ArgumentParser:
     ap.add_argument("--user", default=os.environ.get("MEMORY_TALK_USER"), help="我是谁(须注册过)")
     ap.add_argument("--work", default=os.environ.get("MEMORY_TALK_WORK"), help="在哪个 work 里操作")
     ap.add_argument("--json", action="store_true", help="结构化输出")
+    ap.add_argument("-V", "--version", action="version", version=f"memory.talk {__version__}")
     top = ap.add_subparsers(dest="cmd", required=True)
+    top.add_parser("version", help="版本号").set_defaults(local=lambda a: print(f"memory.talk {__version__}"))
     for group in (server, work, user, collection):
         group.register(top)
     return ap

{memorytalk-5.0.2 → memorytalk-5.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "memorytalk"
-version = "5.0.2"
+version = "5.0.4"
 description = "memory.talk v5 — work / collections / user 三个顶层对象的工作台:跑 code agent 的 work 树,git 分层的认知层,注册的团队成员"
 readme = "README.md"
 requires-python = ">=3.10"

{memorytalk-5.0.2 → memorytalk-5.0.4}/tests/conftest.py

@@ -18,7 +18,7 @@ _orig_json = httpx.Response.json
 def _unwrap(self, **kw):
     """API 响应是 {data, message[, error]} 信封:成功时 .json() 直接给 data,出错时给整个信封(测试看 error 码)。"""
     body = _orig_json(self, **kw)
-    if isinstance(body, dict) and "data" in body and "message" in body and "error" not in body:
+    if isinstance(body, dict) and "data" in body and "message" in body and not body.get("error"):
         return body["data"]
     return body
 

memorytalk-5.0.2/memorytalk/backend/controllers/system.py

@@ -1,17 +0,0 @@
-from fastapi import APIRouter, Request
-
-router = APIRouter(prefix="/api/system", tags=["system"])
-
-
-@router.get("/health", summary="健康检查")
-def health():
-    return {"ok": True}
-
-
-@router.get("/info", summary="运行信息:路径、存储 provider、tmux socket、有没有窗")
-def info(request: Request):
-    cfg, rt = request.app.state.config, request.app.state.runtime
-    store = request.app.state.store.provider
-    return {"home": str(cfg.home), "collections": str(cfg.collections_dir),
-            "store": {"family": store.family, "backend": type(store).__name__},
-            "workspace": str(rt.workspace), "tmux_socket": rt.tmux_socket, "ttyd_url": rt.ttyd_url}

memorytalk-5.0.2/memorytalk/backend/controllers/users.py

@@ -1,38 +0,0 @@
-"""/api/users —— user 是注册的顶层对象:注册、档案、清单、我是谁。不做权限。"""
-from __future__ import annotations
-
-from fastapi import APIRouter, Depends, Header, Request
-
-from memorytalk.backend.models.users import User, UserCreate, UserProfile, UserUpdate, UserView
-from memorytalk.backend.services.users import UserService
-
-router = APIRouter(prefix="/api/users", tags=["users"])
-
-
-def users(request: Request) -> UserService:
-    return request.app.state.users
-
-
-@router.get("", response_model=list[UserView], summary="所有注册的 user,带活动统计,按最近活动倒序")
-def list_users(svc: UserService = Depends(users)):
-    return svc.list()
-
-
-@router.post("", response_model=User, status_code=201, summary="注册一个 user(name 唯一;之后请求头 X-Memory-Talk-User 用它)")
-def register(req: UserCreate, svc: UserService = Depends(users)):
-    return svc.register(req)
-
-
-@router.get("/me", response_model=UserProfile | None, summary="我是谁:X-Memory-Talk-User 对应的 user 档案(没带 → null)")
-def me(svc: UserService = Depends(users), x_memory_talk_user: str | None = Header(None, alias="X-Memory-Talk-User")):
-    return svc.profile(x_memory_talk_user) if x_memory_talk_user else None
-
-
-@router.get("/{name}", response_model=UserProfile, summary="一个 user 的档案 + 建的 / 动过的 work、最近的提交")
-def get_user(name: str, svc: UserService = Depends(users)):
-    return svc.profile(name)
-
-
-@router.put("/{name}", response_model=User, summary="改档案(display_name / email)")
-def update_user(name: str, req: UserUpdate, svc: UserService = Depends(users)):
-    return svc.update(name, req)

memorytalk-5.0.2/memorytalk/backend/envelope.py

@@ -1,44 +0,0 @@
-"""统一响应信封:所有 /api/* 的响应都是 {"data": …, "message": …};出错时多一个 "error"(机器码)。
-
-- JSON 响应 → data = 原来的 body;
-- 纯文本响应(recall / capture)→ data = 那段文本;
-- 204 → 200,data = null;
-- 已经是信封的(错误处理器直接产出的)原样放行;/docs /openapi.json 不碰。
-"""
-from __future__ import annotations
-
-import json
-
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from starlette.responses import JSONResponse, Response
-
-
-def envelope(data, message: str = "ok", error: str | None = None) -> dict:
-    body = {"data": data, "message": message}
-    if error:
-        body["error"] = error
-    return body
-
-
-def is_envelope(obj) -> bool:
-    return isinstance(obj, dict) and "data" in obj and "message" in obj and set(obj) <= {"data", "message", "error"}
-
-
-class EnvelopeMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next) -> Response:
-        response = await call_next(request)
-        if not request.url.path.startswith("/api/"):
-            return response
-        raw = b"".join([chunk async for chunk in response.body_iterator])
-        ctype = response.headers.get("content-type", "")
-        status = 200 if response.status_code == 204 else response.status_code
-        if status == 204 or not raw:
-            payload = envelope(None)
-        elif ctype.startswith("application/json"):
-            obj = json.loads(raw)
-            payload = obj if is_envelope(obj) else envelope(obj)
-        else:
-            payload = envelope(raw.decode("utf-8", "replace"))
-        headers = {k: v for k, v in response.headers.items() if k.lower() not in ("content-length", "content-type")}
-        return JSONResponse(payload, status_code=status, headers=headers)