loom-memory-mcp 0.2.1__tar.gz

loom_memory_mcp-0.2.1/.gitignore

@@ -0,0 +1,41 @@
+# ── 依赖（各语言各目录的 node_modules / venv）──
+node_modules/
+**/node_modules/
+.venv/
+**/.venv/
+__pycache__/
+**/__pycache__/
+*.egg-info/
+
+# ── 物化产物 / 工作目录（运行时生成，不入库）──
+.work/
+**/.next/
+**/generated/
+*.sqlite
+*.tsbuildinfo
+
+# ── 环境与密钥（绝不上传）──
+.env
+.env.*
+!.env.example
+*.key
+*-key.txt
+secrets.*
+
+# ── OMC / 会话 / 缓存 ──
+.omc/
+.claude/state/
+.claude/worktrees/
+
+# ── 锁文件（保留 pnpm-lock 但忽略大体积可重生成的）──
+# pnpm-lock.yaml 保留（可复现安装）
+
+# ── 系统 ──
+.DS_Store
+Thumbs.db
+*.log
+
+# PyInstaller 打包产物
+platform/build/
+platform/dist/
+platform/*.spec

loom_memory_mcp-0.2.1/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: loom-memory-mcp
+Version: 0.2.1
+Summary: Loom MCP — AI 编程的肌肉记忆,从你自己的代码库检索-组装新项目
+Project-URL: Homepage, https://github.com/ailiheizi/loom
+Project-URL: Repository, https://github.com/ailiheizi/loom
+Author: ailiheizi
+License: MIT
+Keywords: ai-coding,code-assembly,create-t3-app,mcp,scaffolding
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.12
+Requires-Dist: anthropic>=0.40
+Requires-Dist: faiss-cpu>=1.14.3
+Requires-Dist: fastembed>=0.8.0
+Requires-Dist: mcp>=1.2
+Requires-Dist: openai>=1.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: tokenizers==0.22.2
+Requires-Dist: tree-sitter-typescript>=0.23.2
+Requires-Dist: tree-sitter>=0.25.2
+Description-Content-Type: text/markdown
+
+# loom-mcp
+
+**AI 编程的肌肉记忆** —— 一个持续学习的代码组装 MCP server。
+
+把你写过的代码自动收录为可复用组件，下次碰到类似需求，AI 直接从你自己的组件库里挑着用，越用越强。
+
+## 安装
+
+需要 [uv](https://docs.astral.sh/uv/)。在 Claude Code / Cursor 等 MCP agent 里配：
+
+```jsonc
+// .mcp.json
+{ "mcpServers": { "loom": { "command": "uvx", "args": ["loom-mcp"] } } }
+```
+
+或：`claude mcp add loom -- uvx loom-mcp`
+
+首次运行自动在 `~/.loom/` 初始化个人组件库（内置种子候选）。
+
+## 工具
+
+- `loom_propose(idea_json)` — 对想法返回每个能力 seam 的 2-3 个候选 + 架构取舍
+- `loom_plan_from_choices(idea_json, choices_json)` — 选择 → 装配计划
+- `loom_get_files(plan_json)` — 物化成完整 create-t3-app 项目文件
+- `loom_ingest(paths, seam_hint?, description?)` — 收录你写的代码进组件库
+
+## 工作流
+
+说想法 → propose 给候选梯度（agent 帮你挑，不确定才问）→ get_files 返回完整项目
+→ 写盘 + `pnpm install` + 填 `.env` + `pnpm dev`。写完新代码 `loom_ingest` 收录，越用越强。
+
+全程本地、零网络、零 key（检索/物化不调 LLM）。信任飞轮：常用的候选浮顶，久不用的沉底。
+
+详见 [项目主页](https://github.com/ailiheizi/loom)。
+
+## 许可
+
+MIT

loom_memory_mcp-0.2.1/README.md

@@ -0,0 +1,38 @@
+# loom-mcp
+
+**AI 编程的肌肉记忆** —— 一个持续学习的代码组装 MCP server。
+
+把你写过的代码自动收录为可复用组件，下次碰到类似需求，AI 直接从你自己的组件库里挑着用，越用越强。
+
+## 安装
+
+需要 [uv](https://docs.astral.sh/uv/)。在 Claude Code / Cursor 等 MCP agent 里配：
+
+```jsonc
+// .mcp.json
+{ "mcpServers": { "loom": { "command": "uvx", "args": ["loom-mcp"] } } }
+```
+
+或：`claude mcp add loom -- uvx loom-mcp`
+
+首次运行自动在 `~/.loom/` 初始化个人组件库（内置种子候选）。
+
+## 工具
+
+- `loom_propose(idea_json)` — 对想法返回每个能力 seam 的 2-3 个候选 + 架构取舍
+- `loom_plan_from_choices(idea_json, choices_json)` — 选择 → 装配计划
+- `loom_get_files(plan_json)` — 物化成完整 create-t3-app 项目文件
+- `loom_ingest(paths, seam_hint?, description?)` — 收录你写的代码进组件库
+
+## 工作流
+
+说想法 → propose 给候选梯度（agent 帮你挑，不确定才问）→ get_files 返回完整项目
+→ 写盘 + `pnpm install` + 填 `.env` + `pnpm dev`。写完新代码 `loom_ingest` 收录，越用越强。
+
+全程本地、零网络、零 key（检索/物化不调 LLM）。信任飞轮：常用的候选浮顶，久不用的沉底。
+
+详见 [项目主页](https://github.com/ailiheizi/loom)。
+
+## 许可
+
+MIT

loom_memory_mcp-0.2.1/_mycomp_test.ts

@@ -0,0 +1,3 @@
+export function MyCustomTable({ columns, rows }: { columns: {key:string;header:string}[]; rows: Record<string,unknown>[] }) {
+  return <table className="my-special-table">{/* 我自己写的特殊表格 */}</table>;
+}

loom_memory_mcp-0.2.1/_paths.py

@@ -0,0 +1,34 @@
+"""统一路径解析：兼容"仓库内运行"和"uvx/pip 安装后运行"两种场景。
+
+- 开发(仓库内)：core.json 在 ../core/loom.core.json
+- 发布(uvx 装)：打进包的 loom_seed/loom.core.json
+优先用包内副本(发布场景),回退仓库路径(开发场景)。
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+_HERE = Path(__file__).resolve().parent          # platform/
+_REPO_ROOT = _HERE.parent                         # 仓库根(开发时)
+_SEED_DIR = _HERE / "loom_seed"                   # 包内数据
+
+
+def core_json_path() -> Path:
+    """loom.core.json 路径：包内优先,回退仓库。"""
+    packaged = _SEED_DIR / "loom.core.json"
+    if packaged.exists():
+        return packaged
+    return _REPO_ROOT / "core" / "loom.core.json"
+
+
+def seed_data_path() -> Path:
+    """seed_data.json 路径(只在包内)。"""
+    return _SEED_DIR / "seed_data.json"
+
+
+def base_dir() -> Path:
+    """t3-base 源目录：包内优先(loom_seed/t3-base),回退仓库(core/t3-base)。"""
+    packaged = _SEED_DIR / "t3-base"
+    if packaged.exists():
+        return packaged
+    return _REPO_ROOT / "core" / "t3-base"

loom_memory_mcp-0.2.1/analyze_repo.py

@@ -0,0 +1,194 @@
+"""仓库分析入口（loom.analyze_repo）—— 飞轮自举的"前人种树"入口。
+
+输入一个真实 repo 目录 → 扫 TS/TSX 源 → tree-sitter 抽 export 签名 →
+AI（deepseek）判断每个文件对齐到哪个 loom 接缝（或 skip）→ 对齐的走 ingest 入池
+（provenance=user，高初始信任）。入池前每个候选过 verify_candidates 质量门（防垃圾）。
+
+"前人种树后人乘凉"：一个人贡献一个 repo，AI 自动拆成接缝级候选，
+后来的想法就能 pick 到这些现成组件 → 池靠社区贡献自增长。
+
+最小真实版（一轮可做完可测）：
+  - 单语言 TS/TSX，对齐到现有 6 个 core 接缝
+  - AI 单轮 JSON 输出对齐决策（复用 run_select 的 deepseek 路径）
+诚实推迟：多语言、跨文件依赖分析、新接缝自动发现、大规模 repo。
+
+用法：
+  LOOM_LLM_PROVIDER=deepseek LOOM_LLM_API_KEY=sk-... \
+    uv run python analyze_repo.py <repo_dir> [--dry-run]
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8")
+
+from ingest import extract_exports, ingest_file
+
+ROOT = Path(__file__).resolve().parent.parent
+CANDIDATES = ROOT / "candidates"
+
+# 扫描时跳过的目录
+SKIP_DIRS = {"node_modules", ".next", "generated", ".git", "dist", "build", ".work"}
+
+
+def scan_ts_files(repo_dir: Path, max_files: int = 40) -> list[Path]:
+    """扫 repo 下的 TS/TSX 源文件（跳过依赖/产物目录）。"""
+    out: list[Path] = []
+    for p in sorted(repo_dir.rglob("*.ts")) + sorted(repo_dir.rglob("*.tsx")):
+        if any(part in SKIP_DIRS for part in p.parts):
+            continue
+        if p.name.endswith(".d.ts") or p.name.endswith(".test.ts"):
+            continue
+        out.append(p)
+        if len(out) >= max_files:
+            break
+    return out
+
+
+def _seam_catalog() -> list[dict]:
+    core = json.loads((ROOT / "core" / "loom.core.json").read_text(encoding="utf-8"))
+    return [{"seam_id": s["seam_id"], "signature": s.get("signature", "")} for s in core["seams"]]
+
+
+def align_files_to_seams(files: list[Path], repo_dir: Path) -> list[dict]:
+    """AI 判断每个文件对齐到哪个接缝（或 skip）。单轮 JSON 输出。"""
+    from openai import OpenAI
+
+    base = os.environ.get("LOOM_LLM_BASE_URL", "https://api.deepseek.com")
+    key = os.environ["LOOM_LLM_API_KEY"]
+    model = os.environ.get("LOOM_LLM_MODEL", "deepseek-chat")
+    client = OpenAI(api_key=key, base_url=base)
+
+    seams = _seam_catalog()
+    # 给 AI 每个文件的 export 签名摘要（不喂全文，省 input）
+    file_digests = []
+    for i, f in enumerate(files):
+        try:
+            exports = extract_exports(f.read_text(encoding="utf-8"))
+        except Exception:
+            exports = []
+        sig = "; ".join(f"{e.kind} {e.name}: {e.signature}" for e in exports[:3]) or "(无 export)"
+        file_digests.append(f"  [{i}] {f.relative_to(repo_dir)} → {sig[:150]}")
+
+    sys_prompt = (
+        "你是 Loom 的仓库分析器。给定一个 repo 的文件 export 签名清单和 Loom 的接缝(seam)目录，"
+        "判断每个文件**对齐到哪个接缝**（该文件实现了那个接缝的能力），或 skip（不对齐任何接缝）。\n"
+        "只在签名明确匹配接缝能力时对齐；拿不准就 skip。\n"
+        "【接缝目录】\n" + "\n".join(f"  {s['seam_id']}: {s['signature']}" for s in seams) + "\n\n"
+        '【输出】JSON：{"alignments":[{"file_index":0,"seam_id":"...或null(skip)",'
+        '"ref":"建议候选名(kebab-case)","summary":"一句话能力摘要","confidence":0.0-1.0}]}'
+    )
+    user_msg = "仓库文件清单（index 文件 → export 签名）:\n" + "\n".join(file_digests)
+
+    resp = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "system", "content": sys_prompt}, {"role": "user", "content": user_msg}],
+        response_format={"type": "json_object"},
+        max_tokens=4096,
+    )
+    print(f"[analyze] AI 对齐 input={resp.usage.prompt_tokens} output={resp.usage.completion_tokens} tok")
+    return json.loads(resp.choices[0].message.content).get("alignments", [])
+
+
+# 接缝 → 物化目标目录（与 loom.core.json 的 target 对齐）
+SEAM_TARGET_DIR = {
+    "auth.oauth_provider": "src/server/auth/providers/",
+    "data.crud_resource": "src/server/api/routers/",
+    "ui.data_table": "src/app/_components/",
+    "report.custom_export": "src/server/export/",
+    "content.markdown_render": "src/app/_components/",
+    "data.bulk_import": "src/server/import/",
+}
+
+
+def main() -> None:
+    args = [a for a in sys.argv[1:] if not a.startswith("--")]
+    dry_run = "--dry-run" in sys.argv
+    if not args:
+        print("用法: analyze_repo.py <repo_dir> [--dry-run]")
+        return
+    repo_dir = Path(args[0]).resolve()
+    if not repo_dir.is_dir():
+        print(f"✗ 不是目录: {repo_dir}")
+        return
+
+    files = scan_ts_files(repo_dir)
+    print(f"=== analyze_repo: {repo_dir.name} ({len(files)} 个 TS 文件) ===")
+    if not files:
+        print("无可分析的 TS 文件")
+        return
+
+    alignments = align_files_to_seams(files, repo_dir)
+    aligned = [a for a in alignments if a.get("seam_id")]
+    print(f"\nAI 对齐结果：{len(aligned)}/{len(files)} 文件对齐到接缝\n")
+
+    ingested = []
+    for a in aligned:
+        idx = a["file_index"]
+        if idx >= len(files):
+            continue
+        f = files[idx]
+        seam = a["seam_id"]
+        ref = a.get("ref") or f.stem
+        target_dir = SEAM_TARGET_DIR.get(seam)
+        if not target_dir:
+            print(f"  [skip] {f.name}: 未知接缝 {seam}")
+            continue
+        target = target_dir + f.name
+        print(f"  [{a.get('confidence',0):.2f}] {f.relative_to(repo_dir)} → {seam} (ref={ref})")
+        if dry_run:
+            continue
+        # 入池：provenance=user（贡献者，高初始信任），过 verify 门见下方提示
+        meta_path = ingest_file(
+            f, seam, ref, a.get("summary", f"来自 {repo_dir.name} 的贡献"),
+            target, CANDIDATES,
+        )
+        # ingest 默认 provenance=platform，这里改成 user（贡献者）
+        meta = json.loads(meta_path.read_text(encoding="utf-8"))
+        meta["registry_item"]["meta_loom"]["provenance"] = "user"
+        meta["l0"]["provenance"] = "user"
+        meta_path.write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")
+        ingested.append(f"{seam}/{ref}")
+
+    if dry_run:
+        print(f"\n[dry-run] 不入池。去掉 --dry-run 实际 ingest。")
+        return
+
+    print(f"\n入池 {len(ingested)} 个候选（provenance=user），跑质量门自检…")
+    # 飞轮防污染闭环：入池后立即过 verify 门，不过 t3 gate 的自动撤回（前人种坏树自动被拔）
+    import subprocess
+
+    proc = subprocess.run(
+        ["uv", "run", "python", str(Path(__file__).parent / "verify_candidates.py")],
+        capture_output=True, text=True, encoding="utf-8", errors="replace",
+        cwd=str(Path(__file__).parent),
+    )
+    out = (proc.stdout or "") + "\n" + (proc.stderr or "")
+    # 解析 verify 输出，找新入池候选里没过门的（[✗] seam/ref）
+    failed = []
+    for line in out.splitlines():
+        if "[✗]" in line:
+            tag = line.split("[✗]")[1].strip().split()[0]  # seam/ref
+            if tag in ingested:
+                failed.append(tag)
+    kept = [c for c in ingested if c not in failed]
+    for tag in failed:
+        seam, ref = tag.split("/", 1)
+        d = CANDIDATES / seam / ref
+        if d.exists():
+            import shutil
+            shutil.rmtree(d)
+    print(f"\n✓ 质量门把关完成：")
+    print(f"  留池（过 t3 gate）：{kept}")
+    if failed:
+        print(f"  自动撤回（未过门，AI 误判/不合格）：{failed}")
+    print(f"  → 飞轮防污染：贡献被 AI 拆解入池，质量门自动拦截毒树。")
+
+
+if __name__ == "__main__":
+    main()

loom_memory_mcp-0.2.1/backfill_tradeoffs.py

@@ -0,0 +1,101 @@
+"""一次性：给候选 meta.json 的 meta_loom 回填 tradeoffs（架构取舍）字段。
+
+第二步「候选级梯度呈现」配套：目标用户是架构师，挑候选时要看依赖/复杂度/适用场景。
+只在 registry_item.meta_loom 里加 tradeoffs，不动任何其他字段。幂等。
+
+用法：cd platform && uv run python backfill_tradeoffs.py [--dry-run]
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8")
+
+ROOT = Path(__file__).resolve().parent.parent
+CAND = ROOT / "candidates"
+
+# 候选 ref → tradeoffs（基于实际源码理解写，不瞎编能力）
+TRADEOFFS: dict[str, str] = {
+    # ── ui.data_table ──
+    "simple-data-table": "零外部依赖，原生 table。功能基础（无排序/分页/筛选）。适合快速展示小数据量，不适合大数据或需交互的场景。",
+    "tanstack-data-table": "依赖 @tanstack/react-table（需装包），支持排序等高级能力。适合复杂交互表格，代价是引入运行时依赖与学习成本。",
+    "paginated-data-table": "零依赖，客户端分页（可选 pageSize）。适合中等数据量分页浏览；纯客户端分页，超大数据集仍需服务端分页。",
+    "sortable-data-table": "零依赖，点击表头排序（localeCompare 数字感知）。适合需排序但不想引 tanstack 的场景；排序在客户端，大数据量有性能上限。",
+    "filterable-data-table": "零依赖，顶部全局文本筛选（跨列子串匹配）。适合带搜索的列表；仅文本包含匹配，无高级筛选条件。",
+    "compact-data-table": "零依赖，紧凑只读（小行距、无阴影圆角）。适合 dashboard 卡片内密集展示；纯展示无交互。",
+    "selectable-data-table": "零依赖，多选行（复选框列 + 全选 + 已选计数）。适合批量操作场景；选择状态在组件内，需自行接批量动作。",
+    "striped-numeric-data-table": "零依赖，斑马纹 + 数字列自动右对齐。适合财务/报表只读展示；按值类型判断对齐，纯展示无交互。",
+    # ── report.custom_export ──
+    "csv-export-fn": "零依赖，浏览器原生 CSV（处理逗号/引号/换行转义）。通用导出首选；Excel 打开中文可能乱码（用 excel-csv 版）。",
+    "excel-csv-export-fn": "零依赖，带 UTF-8 BOM 的 CSV，解决 Excel 中文乱码。面向 Excel 用户首选；纯文本/程序消费场景用普通 csv 即可。",
+    "json-export-fn": "零依赖，pretty JSON + 列投影。适合程序间数据交换/调试；不适合给非技术用户。",
+    "tsv-export-fn": "零依赖，制表符分隔。Excel/Sheets 粘贴友好、少引号转义问题；字段内含制表符会被替换为空格。",
+    "clipboard-export-fn": "零依赖，复制 CSV 到剪贴板（navigator.clipboard）。适合快速复制粘贴；依赖浏览器剪贴板权限，需 https/用户手势。",
+    "markdown-export-fn": "零依赖，GFM 表格。适合贴进 README/issue/文档；不适合数据量大或需机器解析的场景。",
+    # ── auth.oauth_provider ──
+    "google-oauth": "NextAuth Google provider，接 authConfig.providers[]。覆盖最广的消费级登录；需配 Google OAuth 凭据。",
+    "github-oauth": "NextAuth GitHub provider。面向开发者/技术产品的登录首选；非技术用户覆盖不如 Google。",
+    "credentials-auth": "NextAuth Credentials（账号密码）。无第三方依赖、自主可控；需自行管理密码安全/哈希，安全责任更重。",
+    # ── data.crud_resource ──
+    "project-crud-router": "tRPC router，专为 Project 资源的完整 CRUD（list/get/create/update/delete）。需对应 prisma model；最贴合标准 CRUD 需求。",
+    "generic-crud-factory": "泛型 CRUD 工厂，按资源名生成 router。适合多资源复用、减少样板；抽象层带来理解成本，定制单点逻辑较绕。",
+    "readonly-list": "只读列表 router（仅 list/get）。适合纯展示/报表类资源；不支持写操作，需要增删改时不适用。",
+    "post-router": "tRPC router，Post 资源 CRUD（t3 经典示例）。适合博客/内容类；字段固定为 Post 语义，其他资源需改写。",
+    # ── 其他 ──
+    "markdown-view": "Markdown 渲染组件。适合内容展示；具体依赖见 deps，注意 XSS（渲染不可信内容需 sanitize）。",
+    "table-markdown-view": "支持 GFM 表格的 markdown 渲染。适合带表格的文档/笔记；inline 渲染走 dangerouslySetInnerHTML，不可信内容需 sanitize。",
+    "code-block-markdown-view": "支持 ``` 代码块的 markdown 渲染，代码原样转义。适合技术博客/文档；无语法高亮（要高亮需引 highlight.js 等）。",
+    "minimal-markdown-view": "极简 markdown，只渲染标题+段落、不解析 inline。最安全最轻；功能也最少，适合可信度低或只需基础排版。",
+    "csv-contacts-import": "CSV 批量导入，字段固定 name/description（Contact 语义）。适合通讯录类；其他实体需改字段映射。",
+    "generic-csv-import": "通用 CSV 解析，首行表头→Record<string,string>，不绑定实体。适合任意表格导入；调用方自行映射到 model。",
+    "json-import": "JSON 数组批量导入，值转字符串。适合从 API/导出的 JSON 导入；非数组/非法 JSON 返回空。",
+    "tsv-import": "TSV 制表符分隔导入。适合 Excel/Sheets 复制粘贴；字段含制表符会错列。",
+    # ── file.upload（新 seam）──
+    "data-url-upload": "base64 data URL 上传，零后端零依赖。适合 MVP/头像等小文件预览；不持久化、大文件会撑爆内存。",
+    "presigned-url-upload": "PUT 到预签名 URL（S3/R2/OSS）。适合生产对象存储；需后端先签发 URL，本函数只管上传动作。",
+    # ── ui.form ──
+    "simple-form": "基础受控表单，纯 text 输入。最简单，适合快速录入；无校验、无字段类型，复杂表单不够用。",
+    "validated-form": "带必填校验的表单，空必填字段阻止提交。适合需基础校验的创建/编辑；仅必填校验，无格式/异步校验。",
+    "typed-form": "多字段类型（text/textarea/select）。适合字段多样的实体编辑；类型有限，无日期/文件等高级控件。",
+    # ── ui.layout ──
+    "sidebar-layout": "侧边栏布局，左导航+右内容。适合后台管理（多入口）；窄屏需自行处理折叠。",
+    "topbar-layout": "顶栏布局，水平导航+居中内容。适合内容站/营销页/少入口应用；入口多会挤。",
+    # ── ui.detail ──
+    "field-list-detail": "字段列表式（dl/dt/dd）详情。紧凑、适合多字段；纯展示无操作按钮。",
+    "card-detail": "卡片式详情，带标题网格布局。视觉更突出、适合单条资源；字段极多时网格会很长。",
+    # ── auth 扩展 ──
+    "magic-link": "邮箱+验证码登录（Credentials 实现，零依赖）。适合无第三方 OAuth 的自主登录；验证码校验是骨架，生产需接邮件服务+存储。",
+}
+
+
+def main() -> None:
+    dry = "--dry-run" in sys.argv
+    done = 0
+    missing: list[str] = []
+    for meta_path in sorted(CAND.rglob("meta.json")):
+        data = json.loads(meta_path.read_text(encoding="utf-8"))
+        ml = data.get("registry_item", {}).get("meta_loom")
+        if ml is None:
+            continue
+        ref = data.get("l0", {}).get("ref") or meta_path.parent.name
+        tr = TRADEOFFS.get(ref)
+        if tr is None:
+            missing.append(ref)
+            continue
+        ml["tradeoffs"] = tr
+        if not dry:
+            meta_path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        print(f"  {'[dry] ' if dry else '✓ '}{ref}")
+        done += 1
+
+    print(f"\n回填 {done} 个候选{'（dry-run）' if dry else ''}。")
+    if missing:
+        print(f"⚠ 无 tradeoffs 文案的 ref（需补 TRADEOFFS 表）：{missing}")
+
+
+if __name__ == "__main__":
+    main()

loom_memory_mcp-0.2.1/bench_remote.py

@@ -0,0 +1,66 @@
+"""实测：用 loom.alhz.org 远程 server 做一个项目，省多少 token。
+
+测的是宿主 AI 的 OUTPUT token（最贵的部分）：
+- 用 Loom：AI 看 propose 候选 → 输出"选哪个"（极小）；代码由 get_files 返回，AI 不生成
+- 不用 Loom：AI 从零写每个组件文件（auth/crud/table…），全是 AI output
+
+用真 tiktoken(cl100k_base) 计 token，经公网真实调用。
+"""
+import httpx, json, tiktoken
+
+URL = "https://loom.alhz.org/mcp"
+H = {"Content-Type": "application/json", "Accept": "application/json, text/event-stream"}
+enc = tiktoken.get_encoding("cl100k_base")
+tok = lambda s: len(enc.encode(s))
+
+
+def parse(t):
+    for line in t.splitlines():
+        if line.startswith("data: "):
+            return json.loads(line[6:])
+
+
+with httpx.Client(timeout=40) as c:
+    r = c.post(URL, headers=H, json={"jsonrpc": "2.0", "id": 1, "method": "initialize",
+        "params": {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "bench", "version": "1"}}})
+    H["mcp-session-id"] = r.headers.get("mcp-session-id")
+    c.post(URL, headers=H, json={"jsonrpc": "2.0", "method": "notifications/initialized"})
+
+    # 1. propose：server 返回候选梯度（这是 AI 的 INPUT，读它来选）
+    idea = open("../ideas/saas-admin-with-google-auth.json", encoding="utf-8").read()
+    r = c.post(URL, headers=H, json={"jsonrpc": "2.0", "id": 2, "method": "tools/call",
+        "params": {"name": "loom_propose", "arguments": {"idea_json": idea}}})
+    prop = parse(r.text)["result"]["content"][0]["text"]
+
+    # 2. get_files：拿到选中候选的真实代码（= AI 免于生成的代码量）
+    plan = json.dumps({"idea_id": "saas", "core_ref": "create-t3-app@7.39.x", "seams": [
+        {"seam_id": "auth.oauth_provider", "action": "pick", "ref": "google-oauth", "confidence": 1, "why": "x"},
+        {"seam_id": "data.crud_resource", "action": "pick", "ref": "project-crud-router", "confidence": 1, "why": "x"},
+        {"seam_id": "ui.data_table", "action": "pick", "ref": "simple-data-table", "confidence": 1, "why": "x"},
+    ], "synthesized": [], "budget": {"input_tok": 0, "output_tok": 0}})
+    r = c.post(URL, headers=H, json={"jsonrpc": "2.0", "id": 3, "method": "tools/call",
+        "params": {"name": "loom_get_files", "arguments": {"plan_json": plan}}})
+    gf = json.loads(parse(r.text)["result"]["content"][0]["text"])
+
+# 选中候选的代码（AI 不用自己写的）
+cand_keys = ["providers/google.ts", "routers/project.ts", "_components/data-table.tsx"]
+cand_files = [f for f in gf["files"] if any(k in f["path"] for k in cand_keys)]
+cand_code = "\n".join(f["content"] for f in cand_files)
+
+# ── 用 Loom：AI 的 output = 选择决策（3 个 seam，每个就是 "选 X 因为 Y"）
+loom_output = '选择：auth→google-oauth（精确匹配Google登录）；crud→project-crud-router（专为Project的完整CRUD）；table→simple-data-table（零依赖）。'
+loom_out_tok = tok(loom_output)
+
+# ── 不用 Loom：AI 要从零写这些组件代码（output = 这些代码本身）
+fromzero_out_tok = tok(cand_code)
+
+print("=== 实测：经 loom.alhz.org 做一个 SaaS 后台（auth+CRUD+表格 3 组件）===")
+print(f"propose 候选梯度大小（AI 读的 input）: {tok(prop)} tok")
+print(f"get_files 返回代码: {sum(tok(f['content']) for f in cand_files)} tok（{len(cand_files)} 个候选文件）")
+print()
+print(f"【用 Loom】AI output（只输出选择）: {loom_out_tok} tok")
+print(f"【不用 Loom】AI output（从零写这 3 个组件）: {fromzero_out_tok} tok")
+saved = (1 - loom_out_tok / fromzero_out_tok) * 100
+print(f"→ AI output 省: {saved:.0f}%（{fromzero_out_tok} → {loom_out_tok}）")
+print()
+print("注：只算 3 个 pick 组件。真实项目组件更多，省得更多；但从零写也可能更省字(AI偷工)，故此为量级参考。")

loom_memory_mcp-0.2.1/bench_report.py

@@ -0,0 +1,45 @@
+"""读 .work/bench-archive 的多样本双臂 metrics，汇总成诚实的实测报告。"""
+from __future__ import annotations
+import json, statistics, sys
+from pathlib import Path
+from collections import defaultdict
+
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8")
+
+ARCHIVE = Path(__file__).resolve().parent.parent / ".work" / "bench-archive"
+
+# data[idea][arm] = list of (output_tok, converged)
+data: dict[str, dict[str, list]] = defaultdict(lambda: defaultdict(list))
+for f in sorted(ARCHIVE.glob("*.json")):
+    # 文件名：<arm>-<idea>-run<N>.json，arm 可能含下划线(from_zero)
+    name = f.stem
+    arm = "from_zero" if name.startswith("from_zero") else "assembly"
+    rest = name[len(arm) + 1:]  # 去掉 arm- 前缀
+    idea = rest.rsplit("-run", 1)[0]
+    d = json.loads(f.read_text(encoding="utf-8"))
+    data[idea][arm].append((d["total_output_tok"], d["converged"]))
+
+print("=== Loom 双臂对照实测（多样本）===\n")
+print(f"{'想法':<34} {'臂':<10} {'样本':>4} {'out中位':>8} {'out范围':>14} {'收敛率':>8}")
+print("-" * 84)
+
+all_asm_out, all_fz_out = [], []
+for idea in sorted(data):
+    for arm in ("assembly", "from_zero"):
+        runs = data[idea].get(arm, [])
+        if not runs:
+            continue
+        outs = [r[0] for r in runs]
+        convs = [r[1] for r in runs]
+        med = int(statistics.median(outs))
+        conv_rate = f"{sum(convs)}/{len(convs)}"
+        print(f"{idea:<34} {arm:<10} {len(runs):>4} {med:>8} {f'{min(outs)}-{max(outs)}':>14} {conv_rate:>8}")
+        (all_asm_out if arm == "assembly" else all_fz_out).extend(outs)
+
+print("-" * 84)
+if all_asm_out and all_fz_out:
+    am, fm = statistics.median(all_asm_out), statistics.median(all_fz_out)
+    print(f"\n全样本 output 中位数：assembly={am}  from_zero={fm}")
+    print(f"量级比：from_zero / assembly ≈ {fm/am:.1f}×（组装省 AI 输出 ≈ {(1-am/fm)*100:.0f}%）")
+    print(f"样本量：assembly {len(all_asm_out)} 次，from_zero {len(all_fz_out)} 次")