wenlan-mcp 0.9.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,285 @@
+<p align="center">
+  <img src="./docs/assets/social-preview.png" alt="Wenlan: a living personal knowledge library for the AI-native age." width="100%">
+</p>
+
+[![CI](https://github.com/7xuanlu/wenlan/actions/workflows/ci.yml/badge.svg?branch=main&event=push)](https://github.com/7xuanlu/wenlan/actions/workflows/ci.yml?query=branch%3Amain)
+[![Release](https://img.shields.io/github/v/release/7xuanlu/wenlan?sort=semver)](https://github.com/7xuanlu/wenlan/releases/latest)
+[![npm: wenlan](https://img.shields.io/npm/v/wenlan?label=wenlan)](https://www.npmjs.com/package/wenlan)
+[![npm: wenlan-mcp](https://img.shields.io/npm/v/wenlan-mcp?label=wenlan-mcp)](https://www.npmjs.com/package/wenlan-mcp)
+[![MCP Server](https://img.shields.io/badge/MCP-server-blue)](https://modelcontextprotocol.io)
+[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](#license)
+
+<p align="center">
+  <img alt="macOS" src="https://img.shields.io/badge/macOS-arm64%20%7C%20x64-A2AAAD?logo=apple&logoColor=white">
+  <img alt="Linux" src="https://img.shields.io/badge/Linux-x64%20%7C%20arm64-FCC624?logo=linux&logoColor=black">
+  <img alt="Windows" src="https://img.shields.io/badge/Windows-x64-0078D6?logo=windows&logoColor=white">
+</p>
+
+<p align="center">
+  <a href="#claude-code-in-30-seconds"><img alt="Claude Code" src="https://img.shields.io/badge/Claude%20Code-plugin-5D4E75"></a>
+  <a href="#mcp-only-setup"><img alt="OpenAI Codex" src="https://img.shields.io/badge/OpenAI%20Codex-MCP-111827"></a>
+  <a href="#mcp-only-setup"><img alt="Cursor" src="https://img.shields.io/badge/Cursor-MCP-111111"></a>
+  <a href="#mcp-only-setup"><img alt="VS Code" src="https://img.shields.io/badge/VS%20Code-MCP-007ACC"></a>
+  <a href="#mcp-only-setup"><img alt="Claude Desktop" src="https://img.shields.io/badge/Claude%20Desktop-MCP-D97757"></a>
+  <a href="#mcp-only-setup"><img alt="Gemini CLI" src="https://img.shields.io/badge/Gemini%20CLI-MCP-4285F4"></a>
+  <a href="#what-you-get"><img alt="Obsidian" src="https://img.shields.io/badge/Obsidian-Markdown%20pages-7C3AED"></a>
+</p>
+
+**A living personal knowledge library for the AI-native age, built by your agents and grounded in its sources.**
+
+Wenlan (文瀾) takes its name from an imperial library that held one of China's largest book collections. Your agents capture what they learn as they work, and you add the pages and sources you already trust, so the library grows from the bottom up and the top down. Wenlan keeps it current on its own, distilling both into source-cited wiki pages.
+
+Each session opens with a brief and closes with a handoff, so the thread carries forward instead of restarting.
+
+Unlike a static llm-wiki, it keeps evolving between sessions. Unlike a black-box memory, every page shows its sources, so you can read, trust, or correct it.
+
+[![Watch the Wenlan demo](./docs/assets/demo-preview.gif)](https://youtu.be/k37gjWVPHwI)
+
+---
+
+## What makes Wenlan distinct
+
+1. **Evolves on its own.** Most memory tools just hand back what you put in. Wenlan keeps working between sessions: it dedupes, links, and clusters your captures into source-cited wiki pages that feed retrieval alongside the atomic notes they came from. Unlike a static llm-wiki, the library stays current without you maintaining it.
+2. **One home, locked to none.** Every MCP client queries the same local daemon, so context built in one tool shows up in the next. Obsidian is one optional view you can symlink in, not where your work lives.
+3. **Sourced, so you can trust it.** Every page cites the memories it came from, and the daemon refuses unsourced pages rather than letting hallucinated summaries in. Low-confidence captures and contradictions surface for you to confirm or correct, but the everyday flow never stops for approval. Fix something once and Wenlan supersedes the old fact instead of serving both.
+4. **Real git versioning.** Memory, page, and session writes commit into `~/.wenlan/.git/`, so you can inspect, diff, revert, or branch the Markdown artifacts.
+   ```text
+   a1b2c3d page: embedding-retrieval refreshed (4 sources)
+   9f8e7d6 session: handoff embedding-work
+   5a4b3c2 capture: decision mem_abc123
+   ```
+
+---
+
+## Quickstart
+
+### Claude Code in 30 seconds
+
+```text
+/plugin marketplace add 7xuanlu/claude-plugins
+/plugin install origin@7xuanlu
+/init
+```
+
+If Claude Code asks for a restart after installing, restart once, then run `/init`. The plugin handles daemon setup, MCP wiring, local memory setup, and the first round-trip check.
+
+Then try `/brief`, `/capture <decision>`, or `/handoff` inside Claude Code.
+
+Plugin details and daily commands: [plugin/](plugin/.claude-plugin/README.md).
+
+### MCP-only setup
+
+Use this if you want Wenlan tools in Claude Code without the plugin, or in Codex, Cursor, Claude Desktop, VS Code, or Gemini CLI.
+
+```bash
+npx -y wenlan setup
+~/.wenlan/bin/wenlan mcp add claude-code      # or: codex, cursor, claude-desktop, vscode, gemini
+```
+
+MCP-only gives agents tools for capture, recall, context, doctor, and page distillation. It does not install Claude Code slash skills like `/brief`, `/handoff`, `/distill`, or `/init`.
+
+### Terminal runtime setup
+
+Set up the local Wenlan runtime:
+
+```bash
+npx -y wenlan setup
+```
+
+Then start with `~/.origin/bin/origin status`, `~/.origin/bin/origin recall <query>`, or `~/.origin/bin/origin store <text>`. CLI details: [crates/wenlan-cli](crates/wenlan-cli/README.md).
+
+Service management:
+
+```bash
+origin install            # register + start the daemon (stops a running one first)
+origin restart            # stop + start the daemon -- run this after upgrading
+origin status
+origin uninstall
+```
+
+After upgrading Wenlan (`npx -y wenlan setup` or `install.sh`), the new binary is on disk but the already-running daemon keeps serving the old code until you restart it. `wenlan install` now restarts automatically; if you upgraded another way, run `wenlan restart`.
+
+---
+
+## How Wenlan works
+
+The same loop runs every session: capture while you work, let the daemon refine between sessions, and return with the knowledge already in context.
+
+```text
+      ┌──────── loops back · /handoff closes each pass ─────────┐
+      ▼                                                         │
+┌─────┴─────┐    ┌─────────────┐    ┌────────────────┐    ┌─────┴─────┐
+│ CAPTURE   │    │ DAEMON      │    │ ONE STORE      │    │ RECALL +  │
+│  in flow  │ ─▶ │  refines    │ ─▶ │  (local)       │ ─▶ │  BRIEF    │
+│  /capture │    │  between    │    │  · memories    │    │  next     │
+│           │    │  sessions   │    │  · wiki pages  │    │  session  │
+│           │    │  dedup·link │    │  · graph       │    │  /recall  │
+│           │    │  /distill   │    │                │    │  /brief   │
+└───────────┘    └─────────────┘    └────────────────┘    └───────────┘
+   one local daemon · one store · every MCP client reads it
+   Claude Code · Cursor · Codex · Claude Desktop · VS Code · Gemini
+```
+
+Each pass leaves the store sharper. Captures that would sit as loose snippets elsewhere get deduped, linked to the people and projects they touch, and distilled into source-citing pages, so the next session brings back knowledge, not raw history. That is the compounding the loop is named for.
+
+These five verbs drive it:
+
+1. **Session starts.** `/brief [topic]` loads project status, identity, preferences, and topic-relevant memories so the agent walks in with context.
+2. **During work.** `/capture <thing>` saves a decision, lesson, gotcha, or project fact in flow. `/recall <query>` looks anything up.
+3. **Session ends.** `/handoff` writes what changed, what's still open, and where to continue, so the next run picks up cleanly.
+4. **Between sessions.** The daemon deduplicates overlapping captures and links related ideas in the background. `/distill` synthesizes wiki pages from clusters of related memories when you want a deliberate pass.
+5. **Next session.** `/brief` brings it back in the Claude Code plugin; MCP-only clients call the `context` tool for the same memory. Recall pulls the relevant slice, not your whole history, so the context window goes to the work.
+
+Full skill reference: [plugin/skills](plugin/skills/README.md).
+
+Works fully local with no API key, cloud account, or signup. Capture, recall, hybrid search, and graph context need nothing external; add a local model or API key only for automatic page distillation. No telemetry.
+
+---
+
+## What you get
+
+- **Atomic memory layer**: every capture is stored first as a typed memory with source agent, confidence, stability, and supersession metadata.
+- **Source-backed pages**: pages keep source memory IDs, stale reasons, and revision state so distillation can refresh them without losing provenance.
+- **Hybrid retrieval on libSQL**: memories, pages, FTS5 text, vector embeddings, and graph context in one local store your MCP clients can query, fused with reciprocal-rank fusion. An optional local cross-encoder reranker sharpens the top results.
+- **Connected recall**: people, projects, tools, and decisions come back linked, so a memory arrives with the context around it instead of alone.
+- **Distill cycles**: run `/distill` manually today, or add a local model/API key for background extraction, page refreshes, recaps, and richer graph links.
+- **Stays fresh on its own**: background passes link entities, grow matching pages, and update each memory's effective confidence from type, access, and age, so recent and load-bearing memories surface while stale ones fade.
+- **Review before trust**: low-confidence captures, pending revisions, contradictions, and supersessions can surface instead of silently entering context.
+- **Explicit spaces**: tag memories, pages, and recalls with `space=work | personal | client-X` so a day-job capture never bleeds into a side-project brief. Auto-detected from the current repo or workspace when no space is set; overridable always.
+- **You own the data**: everything is plain Markdown under `~/.wenlan/`, versioned in git. Grep it, symlink it into Obsidian, or walk away with the files anytime. No lock-in.
+
+### Spaces
+
+Memories belong to a **space** like `wenlan`, `career`, or
+`ideas`. Set the active space per shell:
+
+    WENLAN_SPACE=career claude
+
+Or declaratively via `~/.wenlan/spaces.toml` (see
+`plugin/examples/spaces.toml`). To manage spaces from the CLI:
+
+    wenlan space list
+    wenlan space add ideas --default
+    wenlan space show ideas
+    wenlan space move scratch career
+
+`origin doctor` prints the current resolver state so you can see exactly
+which layer chose the active space.
+
+---
+
+## Evaluation
+
+**Hybrid retrieval, transparent eval.** BGE-Base-EN-v1.5-Q + FTS5 + Reciprocal Rank Fusion; local BGE-Reranker-Base cross-encoder rerank is the default path when enabled, with BGE-Reranker-V2-M3 available as a higher-quality option. The table below is retrieval-only, not end-to-end answer quality. ~168 tokens per recall query. Eval harness at [`crates/wenlan-core/src/eval/`](crates/wenlan-core/src/eval/). Run it yourself.
+
+Update workflow in [docs/eval](docs/eval/README.md).
+
+
+<!-- EVAL_SNAPSHOT_START -->
+| Benchmark | Recall@5 | MRR | NDCG@10 |
+|---|---:|---:|---:|
+| LongMemEval (oracle, 500 Q) | 93.6% | 0.857 | 0.883 |
+| LoCoMo (locomo10) | 70.0% | 0.647 | 0.684 |
+<!-- EVAL_SNAPSHOT_END -->
+
+
+---
+
+## Repo Map
+
+Wenlan is daemon-first. `wenlan-server` owns the local database, embeddings, distill cycles, knowledge graph, and HTTP API on `127.0.0.1:7878`. The plugin, MCP server, CLI, and local tools are thin clients over that daemon.
+
+
+| Path                                                   | What lives there                                                                                                                                                                                           |
+| ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [crates/wenlan-core](crates/wenlan-core/README.md)     | Storage, search, embeddings, distill cycles, graph, pages, export, eval.                                                                                                                                   |
+| [crates/wenlan-server](crates/wenlan-server/README.md) | Local daemon and HTTP API.                                                                                                                                                                                 |
+| [crates/wenlan-mcp](crates/wenlan-mcp/README.md)       | MCP server, tools, npm package.                                                                                                                                                                            |
+| [crates/wenlan-cli](crates/wenlan-cli/README.md)       | User CLI for setup, service management, search, recall, store, list, agents, model/key setup, and doctor.                                                                                                  |
+| [plugin/](plugin/.claude-plugin/README.md)             | Claude Code plugin (`plugin.json`, skills, hooks, `.mcp.json`).                                                                                                                                           |
+| [docs/eval](docs/eval/README.md)                       | Benchmark workflow and methodology.                                                                                                                                                                        |
+
+
+Full contributor map: [CLAUDE.md](CLAUDE.md).
+
+---
+
+## Build from source
+
+Wenlan builds natively on macOS (Apple Silicon + Intel), Linux (x86_64 + ARM64; glibc), and Windows (x86_64). The npm wrapper (`wenlan`, `wenlan-mcp`) and `install.sh` auto-detect your platform and pull the matching prebuilt release. Most users should install through the Claude Code plugin or `npx`. For local development:
+
+```bash
+git clone https://github.com/7xuanlu/wenlan.git
+cd wenlan
+cargo build --workspace
+cargo run -p wenlan-server
+```
+
+Build details for the daemon, MCP server, CLI, and core crates live in the crate READMEs linked above. Cross-platform specifics (service registration, paths, Windows install limitation) live in [AGENTS.md](AGENTS.md#cross-platform).
+
+---
+
+## Learn more
+
+Longer-form writing on AI work memory and how Wenlan compares lives at [useorigin.app/learn](https://useorigin.app/learn):
+
+**Concepts**
+- [What is AI work memory?](https://useorigin.app/learn/ai-work-memory): the shape of the problem Wenlan solves
+- [MCP memory server](https://useorigin.app/learn/mcp-memory-server): how Wenlan exposes memory through the Model Context Protocol
+- [Local-first AI memory](https://useorigin.app/learn/local-first-ai-memory): data, privacy, and control
+- [Markdown + local index](https://useorigin.app/learn/markdown-local-index-ai-memory): the storage model
+- [AI agent handoff loop](https://useorigin.app/learn/ai-agent-handoff-loop): session-end discipline that prevents context loss
+
+**Comparisons**
+- [Wenlan vs Basic Memory](https://useorigin.app/learn/origin-vs-basic-memory): Markdown knowledge base vs AI work-session memory
+- [Wenlan vs claude-mem](https://useorigin.app/learn/origin-vs-claude-mem): observer-style Claude Code memory vs MCP-first cross-tool memory
+- [Wenlan vs Superlocal Memory](https://useorigin.app/learn/origin-vs-superlocal-memory): includes the honest LoCoMo benchmark concession
+
+**Docs**
+- [Get started](https://useorigin.app/docs/get-started): install + verify the first local memory loop
+- [Daily workflow](https://useorigin.app/docs/daily-workflow): capture, handoff, distill
+- [MCP clients](https://useorigin.app/docs/mcp-clients): connect Claude Code, Cursor, Codex, Claude Desktop, Gemini CLI
+
+---
+
+## What Wenlan is NOT
+
+- **Not a Life OS.** No habits, calendar, journal, or life-management modules. Wenlan scopes to AI work artifacts only. If you want a full personal OS, look at [PAI](https://github.com/danielmiessler/PAI).
+- **Not a workflow suite.** ~30 MCP tools across one daemon. If you want 30+ skills, 8+ agents, and an auto-research loop bundled, look at [pro-workflow](https://github.com/rohitg00/pro-workflow). Wenlan trades breadth for focus.
+- **Not a memory infrastructure SDK.** For people using AI daily, not as a backend for other apps building memory features.
+- **Not for one-off chats.** Best when work spans sessions, projects, and weeks.
+
+---
+
+## Contributing
+
+Bug fixes, eval cases, docs, and features are welcome. Start with [CONTRIBUTING.md](CONTRIBUTING.md). Architecture and development rules are in [CLAUDE.md](CLAUDE.md). Security reports: [SECURITY.md](SECURITY.md). Please also read the [Code of Conduct](CODE_OF_CONDUCT.md).
+
+---
+
+## License
+
+Wenlan is licensed under **Apache-2.0**. This includes the local runtime, CLI, MCP server, shared types, and Claude Code plugin files in this repo.
+
+The permissive license keeps the daemon boundary usable for MCP clients and downstream local tools.
+
+---
+
+## Acknowledgments
+
+Predecessors:
+
+- [Karpathy's LLM-wiki note](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f). Raw-to-wiki distillation pattern.
+- Claude Code's `MEMORY.md`. The simplest version of the idea.
+
+Peers:
+
+- [agentmemory](https://github.com/rohitg00/agentmemory). Agent-side memory framework.
+- [basic-memory](https://github.com/basicmachines-co/basic-memory). Local-first knowledge management for Claude.
+- [obsidian-mind](https://github.com/breferrari/obsidian-mind). Obsidian-native memory and review loop for coding agents.
+- [pro-workflow](https://github.com/rohitg00/pro-workflow). Claude Code productivity suite.
+- [mcp-memory-service](https://github.com/doobidoo/mcp-memory-service). Memory service for MCP.
+- [Memoria](https://github.com/matrixorigin/Memoria). "Git for AI Agent Memory" via Copy-on-Write.
+- [OpenMemory](https://github.com/CaviraOSS/OpenMemory), [claude-memory-compiler](https://github.com/coleam00/claude-memory-compiler), [PAI](https://github.com/danielmiessler/PAI), Palinode. Adjacent shapes.
+
+Different shapes of the same problem. Try the one that fits.

package/install.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+"use strict";
+
+const { existsSync, mkdirSync, chmodSync } = require("fs");
+const { join } = require("path");
+const { spawnSync } = require("child_process");
+const https = require("https");
+const http = require("http");
+const os = require("os");
+const fs = require("fs");
+const path = require("path");
+
+const VERSION = require("./package.json").version;
+const REPO = "7xuanlu/wenlan";
+
+// Maps Node platform-arch to the release bundle filename shipped by release.yml.
+// Each bundle contains wenlan, wenlan-server, and wenlan-mcp (or .exe on Windows).
+const ASSETS = {
+  "darwin-arm64": { file: "wenlan-darwin-arm64.tar.gz",  archive: "tar.gz" },
+  "linux-arm64":  { file: "wenlan-linux-arm64.tar.gz",   archive: "tar.gz" },
+  "linux-x64":    { file: "wenlan-linux-x64.tar.gz",     archive: "tar.gz" },
+  "win32-x64":    { file: "wenlan-windows-x64.zip",      archive: "zip"    },
+};
+
+const key = `${process.platform}-${process.arch}`;
+const asset = ASSETS[key];
+
+if (!asset) {
+  console.error(`Unsupported platform: ${key}`);
+  console.error(`Supported: ${Object.keys(ASSETS).join(", ")}`);
+  process.exit(1);
+}
+
+const isWindows = process.platform === "win32";
+const binaryName = isWindows ? "wenlan-mcp.exe" : "wenlan-mcp";
+const installName = isWindows ? "wenlan-mcp.exe" : "wenlan-mcp";
+
+const binDir = join(__dirname, "bin");
+const dest = join(binDir, installName);
+
+mkdirSync(binDir, { recursive: true });
+
+const downloadUrl = `https://github.com/${REPO}/releases/download/v${VERSION}/${asset.file}`;
+
+console.log(`Downloading wenlan-mcp ${VERSION} for ${key}...`);
+
+function download(url, dest, redirects = 0) {
+  return new Promise((resolve, reject) => {
+    if (redirects > 10) {
+      return reject(new Error("Too many redirects"));
+    }
+    const mod = url.startsWith("https") ? https : http;
+    mod.get(url, { headers: { "User-Agent": "wenlan-mcp-npm" } }, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return download(res.headers.location, dest, redirects + 1).then(resolve, reject);
+      }
+      if (res.statusCode !== 200) {
+        return reject(new Error(`Download failed: HTTP ${res.statusCode}\nURL: ${url}`));
+      }
+      const file = fs.createWriteStream(dest);
+      res.pipe(file);
+      file.on("finish", () => {
+        file.close();
+        resolve();
+      });
+      file.on("error", reject);
+    }).on("error", reject);
+  });
+}
+
+function extractBinary(archivePath, archiveType, outputDir) {
+  if (archiveType === "tar.gz") {
+    // tar is available on macOS, all Linux, and Windows 10 1803+ / Server 2019+.
+    const result = spawnSync(
+      "tar",
+      ["-xzf", archivePath, "-C", outputDir, binaryName],
+      { stdio: "inherit" }
+    );
+    if (result.error) throw result.error;
+    if (result.status !== 0) throw new Error(`tar exited with status ${result.status}`);
+  } else if (archiveType === "zip") {
+    // bsdtar ships with Windows 10 1803+ and can read zip files.
+    const result = spawnSync(
+      "tar",
+      ["-xf", archivePath, "-C", outputDir, binaryName],
+      { stdio: "inherit" }
+    );
+    if (result.error) throw result.error;
+    if (result.status !== 0) throw new Error(`tar (zip) exited with status ${result.status}`);
+  } else {
+    throw new Error(`Unknown archive type: ${archiveType}`);
+  }
+}
+
+async function install() {
+  const tmpDir = os.tmpdir();
+  const archivePath = path.join(tmpDir, asset.file);
+
+  try {
+    await download(downloadUrl, archivePath);
+    extractBinary(archivePath, asset.archive, binDir);
+
+    if (!isWindows) {
+      chmodSync(dest, 0o755);
+    }
+
+    console.log(`wenlan-mcp installed successfully (${key})`);
+  } finally {
+    // Clean up downloaded archive regardless of success or failure.
+    try {
+      if (existsSync(archivePath)) {
+        fs.unlinkSync(archivePath);
+      }
+    } catch (_) {
+      // Best-effort cleanup; ignore errors.
+    }
+  }
+}
+
+install().catch((err) => {
+  console.error(`Failed to install wenlan-mcp: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "wenlan-mcp",
+  "version": "0.9.0",
+  "description": "Local-first memory layer for AI agents - MCP server",
+  "keywords": [
+    "mcp",
+    "ai-memory",
+    "llm-wiki",
+    "long-term-memory",
+    "local-first",
+    "wiki",
+    "memory",
+    "ai",
+    "llm",
+    "agents",
+    "claude",
+    "chatgpt",
+    "origin"
+  ],
+  "homepage": "https://github.com/7xuanlu/wenlan#readme",
+  "bugs": {
+    "url": "https://github.com/7xuanlu/wenlan/issues"
+  },
+  "author": "7xuanlu <h164654156465@gmail.com>",
+  "license": "Apache-2.0",
+  "bin": {
+    "wenlan-mcp": "run.js"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "arm64",
+    "x64"
+  ],
+  "files": [
+    "install.js",
+    "run.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/7xuanlu/wenlan",
+    "directory": "crates/wenlan-mcp/npm"
+  }
+}

package/run.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawn } = require("child_process");
+const { join } = require("path");
+
+const binaryName = process.platform === "win32" ? "wenlan-mcp.exe" : "wenlan-mcp";
+const bin = join(__dirname, "bin", binaryName);
+const child = spawn(bin, process.argv.slice(2), { stdio: "inherit" });
+
+child.on("exit", (code) => process.exit(code ?? 1));
+process.on("SIGTERM", () => child.kill("SIGTERM"));
+process.on("SIGINT", () => child.kill("SIGINT"));