mindnet 0.2.0__tar.gz → 0.3.0__tar.gz

{mindnet-0.2.0 → mindnet-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mindnet
-Version: 0.2.0
+Version: 0.3.0
 Summary: mindnet — a reverse knowledge base. The index is you.
 Project-URL: Homepage, https://mindnet.tatoao.com
 License: MIT

mindnet-0.3.0/src/mindnet/__init__.py

@@ -0,0 +1,5 @@
+"""mindnet —— a reverse knowledge base. The index is you.
+
+单入口 CLI（发行面真相源 docs/方案-mindnet-cli合一-v1.md）：四件散装收编成 `mindnet` 子命令。
+"""
+__version__ = "0.3.0"   # 0.3.0：bridge 多轮 thread（--resume 原生续聊·映射 ~/.mindnet/bot/threads/·丢了退 replay 重建）+ answer_chunk 逐字流式上行（老服务端/老帧向后兼容）

{mindnet-0.2.0 → mindnet-0.3.0}/src/mindnet/bot.py

@@ -4,6 +4,8 @@
 两个角色（同一条 WS·/agent/channel）：
   · 内脑通道（原 bridge）：网页门 /ask 路由到你本地 agent 答（零计费）。
   · **空间 bot（新）**：同空间成员 @ 你的 bot → 云端推问题过来 → 本地 agent 答 → 带署名回对话流。
+多轮 thread（智能体升级 v1·契约 §4）：ask 帧带 thread_id → `claude -p --resume` 原生续聊
+（映射落 ~/.mindnet/bot/threads/）+ answer_chunk 逐字流式上行；老服务端/老帧全向后兼容。
 
 用法（mindnet 单入口·原 bridge/mindnet_bot.py 收编）：
   mindnet login                          # device-code 网页授权，存 token（顶层收拢·mindnet bot login 同效）
@@ -35,6 +37,7 @@ import shutil
 import subprocess
 import sys
 import tempfile
+import threading
 import time
 import urllib.parse
 import urllib.request
@@ -84,9 +87,14 @@ def select_exec_mode(capability: str) -> str:
 
 
 # ── 执行路径（claude 后端）──
-def _claude_cmd(prompt: str, system: str, extra: list, model: str | None = None) -> list:
+def _claude_cmd(prompt: str, system: str, extra: list, model: str | None = None,
+                resume: str | None = None, output_format: str = "json") -> list:
     """拼 claude CLI 命令（纯函数·可单测）。model 显式给了才 --model 透传（真选执行模型·署名诚实底线）。
 
+    多轮 thread 路（契约 §4）：resume=session_id → `--resume` 原生续聊；
+    output_format="stream-json" → 逐字流式（成对带 --include-partial-messages --verbose，
+    print 模式下 stream-json 必须 --verbose 才吐行）。默认参数下形状与老单发路完全一致。
+
     --setting-sources project = 隐私洞修换轨（洞=TATOAO 07-09 真机坐实：claude -p 默认注入主人
     ~/.claude/CLAUDE.md 等个人配置，bot 会说给空间成员听）。原修用 --safe-mode，但它把工作区
     .claude/skills/ 也一并剥（勘察档 2026-07-10 实测死碰撞）；换「只认项目级设置源」后四项全对：
@@ -94,17 +102,22 @@ def _claude_cmd(prompt: str, system: str, extra: list, model: str | None = None)
     不可用。三级（L0/L1/L2）共用本函数 = 全盖（L0 空 cwd 无项目源，效果等同全剥）。
     注意：邮箱/日期等环境注入 flag 层堵不掉（勘察档遗留①）——靠系统词硬约束兜（件6）。
     """
-    cmd = ["claude", "-p", prompt, "--output-format", "json",
+    cmd = ["claude", "-p", prompt, "--output-format", output_format,
            "--system-prompt", system or DEFAULT_SYS,
            "--exclude-dynamic-system-prompt-sections",
            "--setting-sources", "project"]
+    if output_format == "stream-json":
+        cmd += ["--include-partial-messages", "--verbose"]
+    if resume:
+        cmd += ["--resume", resume]
     if model:
         cmd += ["--model", model]
     return cmd + list(extra)
 
 
-def _claude(prompt: str, system: str, cwd: str, extra: list, timeout: float,
-            model: str | None = None) -> str:
+def _claude_json(prompt: str, system: str, cwd: str, extra: list, timeout: float,
+                 model: str | None = None) -> dict:
+    """单发跑 claude，返完整输出 dict（result 文本 + session_id 等）。失败抛 RuntimeError。"""
     cmd = _claude_cmd(prompt, system, extra, model)
     p = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True, timeout=timeout)
     if p.returncode != 0:
@@ -112,7 +125,12 @@ def _claude(prompt: str, system: str, cwd: str, extra: list, timeout: float,
     out = json.loads(p.stdout)
     if out.get("is_error"):
         raise RuntimeError(str(out.get("result"))[:300])
-    return (out.get("result") or "").strip()
+    return out
+
+
+def _claude(prompt: str, system: str, cwd: str, extra: list, timeout: float,
+            model: str | None = None) -> str:
+    return str(_claude_json(prompt, system, cwd, extra, timeout, model).get("result") or "").strip()
 
 
 def _snapshot_workspace(workspace: str, cwd: str) -> None:
@@ -121,8 +139,16 @@ def _snapshot_workspace(workspace: str, cwd: str) -> None:
 
 
 def _answer_claude(prompt: str, system: str, mode: str, log, timeout: float = 180,
-                   model: str | None = None, workspace: str | None = None) -> str:
-    """workspace=空间工作区根（外脑镜像+技能·件4）。L0 不吃 workspace（v1.1 钉·维持测试档）。"""
+                   model: str | None = None, workspace: str | None = None,
+                   thread_id: str | None = None, replay=None, on_chunk=None) -> str:
+    """workspace=空间工作区根（外脑镜像+技能·件4）。L0 不吃 workspace（v1.1 钉·维持测试档）。
+
+    thread_id 有值=多轮 thread 路（契约 §4：--resume 续聊 + answer_chunk 逐字上行）；
+    无值=老单发路，行为一字不变（老帧向后兼容）。
+    """
+    if thread_id:
+        return _answer_claude_thread(prompt, system, mode, log, timeout, model, workspace,
+                                     thread_id, replay, on_chunk)
     if mode == "l0":
         log("  · L0 纯问答（空 cwd·禁全部工具）")
         with tempfile.TemporaryDirectory() as cwd:
@@ -153,9 +179,16 @@ def _codex_cmd(full: str, sandbox: str, cwd: str, model: str | None = None) -> l
 
 
 def _answer_codex(prompt: str, system: str, mode: str, log, timeout: float = 180,
-                  model: str | None = None, workspace: str | None = None) -> str:
+                  model: str | None = None, workspace: str | None = None,
+                  thread_id: str | None = None, replay=None, on_chunk=None) -> str:
     """codex exec 非交互作答。L0=沙箱只读（不吃 workspace·v1.1）；L1=workspace-write 快照临时 cwd；
-    L2=danger 全权·空间工作区真目录（警示）。工作区说明走 cwd 的 AGENTS.md（codex 原生注入·勘实）。"""
+    L2=danger 全权·空间工作区真目录（警示）。工作区说明走 cwd 的 AGENTS.md（codex 原生注入·勘实）。
+
+    多轮对称（契约 §4）：thread_id 有值 → 每轮 replay 重放重建（codex exec 无稳定 session 续聊面，
+    诚实不硬凑映射）；整段一次回=服务端当单 chunk（on_chunk 不用），不炸不装流。
+    """
+    if thread_id:
+        prompt = format_replay(replay, prompt)
     full = (system or DEFAULT_SYS) + "\n\n【问题】\n" + prompt
     if mode == "l0":
         log("  · L0 纯问答（codex·只读沙箱）")
@@ -180,6 +213,183 @@ def make_answerer(backend: str):
     return _answer_codex if backend == "codex" else _answer_claude
 
 
+# ── 多轮 thread（智能体升级 v1·契约 §4）──
+# ask 帧扩 thread_id + replay（服务端已裁窗）；bridge 维护 thread_id→本地 session 映射
+# （状态文件 ~/.mindnet/bot/threads/sessions.json + per-thread 稳定 cwd——claude session
+# 按项目目录归档，cwd 不稳 --resume 找不到）。映射在=--resume 原生续聊（订阅侧免重放，
+# 零计费路再白拿一次）；映射丢/resume 报错=弃映射退 replay 重放重建，功能不减。
+
+def _bot_threads_dir() -> Path:
+    return Path(os.environ.get("MINDNET_BOT_THREADS_DIR",
+                               str(Path.home() / ".mindnet" / "bot" / "threads")))
+
+
+def _safe_thread_key(thread_id: str) -> str:
+    """thread_id 落盘前消毒（云侧数据不全信·与 _ws_safe_rel 同纪律）：只留字母数字与 -_。"""
+    key = "".join(c for c in (thread_id or "") if c.isalnum() or c in "-_")
+    if not key:
+        raise ValueError(f"非法 thread_id：{thread_id!r}")
+    return key
+
+
+def load_thread_sessions() -> dict:
+    p = _bot_threads_dir() / "sessions.json"
+    try:
+        return json.loads(p.read_text()) if p.exists() else {}
+    except Exception:
+        return {}   # 状态文件坏=当空表：丢的只是 --resume 优化，replay 重建兜底
+
+
+def save_thread_session(thread_id: str, entry: dict) -> None:
+    d = _bot_threads_dir()
+    d.mkdir(parents=True, exist_ok=True)
+    s = load_thread_sessions()
+    s[thread_id] = entry
+    (d / "sessions.json").write_text(json.dumps(s, ensure_ascii=False))
+
+
+def drop_thread_session(thread_id: str) -> None:
+    s = load_thread_sessions()
+    if thread_id in s:
+        del s[thread_id]
+        (_bot_threads_dir() / "sessions.json").write_text(json.dumps(s, ensure_ascii=False))
+
+
+def thread_cwd(thread_id: str) -> Path:
+    p = _bot_threads_dir() / _safe_thread_key(thread_id)
+    p.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def format_replay(replay, prompt: str) -> str:
+    """映射丢失的重建路（纯函数）：把服务端重放的中立历史嵌进单发 prompt。空 replay=原 prompt。"""
+    if not replay:
+        return prompt
+    lines = [("用户" if m.get("role") == "user" else "助手") + "：" + str(m.get("content") or "")
+             for m in replay]
+    return ("【此前对话（服务端重放·你就是其中的助手，接着聊）】\n" + "\n\n".join(lines)
+            + "\n\n【当前问题】\n" + prompt)
+
+
+def parse_stream_line(line: str):
+    """claude `--output-format stream-json` 单行 → ("chunk", 增量文本) / ("result", {text,
+    session_id, is_error}) / ("other", None)。纯函数·可单测；坏行一律 other 不炸。"""
+    try:
+        d = json.loads(line)
+    except Exception:
+        return ("other", None)
+    t = d.get("type")
+    if t == "stream_event":
+        ev = d.get("event") or {}
+        if ev.get("type") == "content_block_delta":
+            delta = ev.get("delta") or {}
+            if delta.get("type") == "text_delta" and delta.get("text"):
+                return ("chunk", delta["text"])
+        return ("other", None)
+    if t == "result":
+        return ("result", {"text": str(d.get("result") or "").strip(),
+                           "session_id": d.get("session_id"),
+                           "is_error": bool(d.get("is_error"))})
+    return ("other", None)
+
+
+def _claude_stream(prompt: str, system: str, cwd: str, extra: list, timeout: float,
+                   model: str | None = None, resume: str | None = None,
+                   on_chunk=None) -> tuple:
+    """流式跑 claude（thread 路）：stream-json 逐字回调 on_chunk，返 (整段文本, session_id)。
+
+    · resume 报错**上抛**（调用方弃映射退 replay 重试）——绝不静默退单发，那会丢上下文；
+    · 非 resume 且 CLI 接不住 stream-json（旧版无 flag）→ 退老单发 json 整段（诚实单 chunk，
+      session_id 也从 json 输出里拿，多轮照样建映射）。
+    """
+    cmd = _claude_cmd(prompt, system, extra, model, resume=resume, output_format="stream-json")
+    chunks: list = []
+    result = None
+    p = subprocess.Popen(cmd, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    killer = threading.Timer(timeout, p.kill)   # 行读没有 run(timeout=) 可用，watchdog 兜死等
+    killer.start()
+    try:
+        for line in p.stdout:
+            kind, payload = parse_stream_line(line)
+            if kind == "chunk":
+                chunks.append(payload)
+                if on_chunk:
+                    try:
+                        on_chunk(payload)
+                    except Exception:
+                        pass                    # 上行帧失败不打断作答：终帧 answer 仍是完整文本
+            elif kind == "result":
+                result = payload
+        rc = p.wait()
+    finally:
+        killer.cancel()
+        try:
+            p.kill()
+        except Exception:
+            pass
+    if result is not None:
+        if result["is_error"]:
+            raise RuntimeError((result["text"] or "claude 报错")[:300])
+        return result["text"] or "".join(chunks), result.get("session_id")
+    stderr = (p.stderr.read() or "")[:300] if p.stderr else ""
+    if resume:
+        raise RuntimeError(stderr or f"claude --resume 失败（退出码 {rc}）")
+    # 旧 CLI 接不住 stream-json → 单发 json 兜底（整段=answer 终帧一次回，服务端当单 chunk）
+    out = _claude_json(prompt, system, cwd, extra, timeout, model)
+    text = str(out.get("result") or "").strip()
+    if on_chunk and text:
+        try:
+            on_chunk(text)
+        except Exception:
+            pass
+    return text, out.get("session_id")
+
+
+def _chunk_sender(ws, loop, request_id: str):
+    """answer_chunk 上行帧回调（契约 §4）。answerer 跑在工作线程（asyncio.to_thread），
+    经 run_coroutine_threadsafe 投回事件循环发帧；发不出不致命（终帧 answer=完整文本兜底，
+    老服务端收到未知帧忽略不炸=向后兼容）。"""
+    def cb(text: str) -> None:
+        if not text:
+            return
+        frame = json.dumps({"type": "answer_chunk", "request_id": request_id, "text": text})
+        try:
+            asyncio.run_coroutine_threadsafe(ws.send(frame), loop)
+        except Exception:
+            pass
+    return cb
+
+
+def _answer_claude_thread(prompt: str, system: str, mode: str, log, timeout: float,
+                          model: str | None, workspace: str | None,
+                          thread_id: str, replay, on_chunk) -> str:
+    """多轮 thread 的 claude 路：稳定 per-thread cwd + 映射 --resume；丢了退 replay 重建。"""
+    extra = (["--disallowed-tools", *_ALL_TOOLS] if mode == "l0"
+             else ["--disallowed-tools", *_L1_DISALLOW] if mode == "l1_restricted" else [])
+    cwd = Path(workspace) if (mode == "l2" and workspace) else thread_cwd(thread_id)
+    if workspace and mode == "l1_restricted":
+        _snapshot_workspace(workspace, str(cwd))
+    sess = load_thread_sessions().get(thread_id) or {}
+    sid = sess.get("session_id") if sess.get("backend", "claude") == "claude" else None
+    if sid:
+        try:
+            log(f"  · thread {thread_id[:16]} --resume 原生续聊")
+            text, new_sid = _claude_stream(prompt, system, str(sess.get("cwd") or cwd), extra,
+                                           timeout, model, resume=sid, on_chunk=on_chunk)
+            save_thread_session(thread_id, {"session_id": new_sid or sid,
+                                            "backend": "claude", "cwd": str(cwd)})
+            return text
+        except Exception as e:
+            log(f"  ⚠ resume 失败（{str(e)[:80]}），弃映射退重放重建")
+            drop_thread_session(thread_id)
+    text, new_sid = _claude_stream(format_replay(replay, prompt), system, str(cwd), extra,
+                                   timeout, model, on_chunk=on_chunk)
+    if new_sid:
+        save_thread_session(thread_id, {"session_id": new_sid, "backend": "claude",
+                                        "cwd": str(cwd)})
+    return text
+
+
 # ── bot 工作区（件3 云→本地拉·manifest 下行）──
 # 工作区布局（方向档 §一）：~/.mindnet/bot/spaces/<space_id>/{外脑/, .claude/skills/, .pull-manifest.json}
 BRAIN_DIR = "外脑"
@@ -429,8 +639,14 @@ async def run(exposed_caps: dict, backend: str, model: str, once: bool = False,
             workspace = None
             if space_id and mode != "l0":                 # L0 不吃工作区（v1.1 钉·测试档）
                 workspace = await asyncio.to_thread(_workspace_for, space_id, token, log)
+            # 多轮 thread（契约 §4·仅有值才走）：--resume 续聊 + answer_chunk 逐字上行
+            thread_id = msg.get("thread_id")
+            on_chunk = (_chunk_sender(ws, asyncio.get_running_loop(), rid)
+                        if thread_id else None)
             text = await asyncio.to_thread(answerer, msg.get("prompt", ""), system,
-                                           mode, log, model=exec_model, workspace=workspace)
+                                           mode, log, model=exec_model, workspace=workspace,
+                                           thread_id=thread_id, replay=msg.get("replay"),
+                                           on_chunk=on_chunk)
             await ws.send(json.dumps({"type": "answer", "request_id": rid, "ok": True, "text": text}))
             log(f"  ✓ 答了（{len(text)} 字）")
         except Exception as e:

mindnet-0.2.0/src/mindnet/__init__.py

@@ -1,5 +0,0 @@
-"""mindnet —— a reverse knowledge base. The index is you.
-
-单入口 CLI（发行面真相源 docs/方案-mindnet-cli合一-v1.md）：四件散装收编成 `mindnet` 子命令。
-"""
-__version__ = "0.2.0"   # 0.2.0：space-pull 下行同步（语义四条+快照统一 .mindnet-sync.json+status 双向）+ 图片进白名单