kimi-mcp-hub 0.1.0 → 0.2.0

package/README.md

@@ -1,24 +1,35 @@
 # Kimi MCP Hub
 
-One-click MCP server and skills manager for **Kimi CLI** -- like `claude-mem` but for connecting 23 MCP servers (Jira, GitHub, Slack, Datadog, Perplexity, Stripe, GitLab, DBHub, etc.), 34 AI skills (6 core + 28 optional), persistent memory, and Claude Desktop import.
+One-click MCP server and skills manager for **Kimi CLI** -- like `claude-mem` but for connecting 24 MCP servers (Jira, GitHub, Slack, Obsidian, Datadog, Perplexity, Stripe, GitLab, DBHub, etc.), 57 AI skills (7 core + 50 optional), persistent memory, and Claude Desktop import.
 
 ---
 
 ## Table of Contents
 
 - [Install](#install)
-  - [One-liner (no clone)](#one-liner-no-clone)
-  - [From GitHub (pip)](#from-github-pip)
-  - [Clone + Install](#clone--install)
+  - [One-liner with npx (recommended)](#one-liner-with-npx-recommended)
+  - [One-liner (curl / PowerShell)](#one-liner-curl-powershell)
+  - [From GitHub (pip) inside a venv](#from-github-pip-inside-a-venv)
+  - [From PyPI (when published)](#from-pypi-when-published)
+  - [Clone + Install (development)](#clone-install-development)
+  - [Requirements](#requirements)
   - [Verify](#verify)
+  - [Run the wizard](#run-the-wizard)
 - [Uninstall](#uninstall)
 - [Quick Start](#quick-start)
+- [Update](#update)
+- [Managing MCP Servers and Skills](#managing-mcp-servers-and-skills)
+- [Obsidian Local Memory](#obsidian-local-memory)
+- [Install Claude/Codex Plugins](#install-claudecodex-plugins)
+- [Project-Level MCP Configuration](#project-level-mcp-configuration)
+- [Remote MCP Server Setup](docs/remote-mcp-server-setup.md)
 - [OAuth Auto-Browser](#oauth-auto-browser)
+- [CLAUDE.md Compatibility](#claudemd-compatibility)
 - [All Commands](#all-commands)
-- [MCP Servers](#17-mcp-servers)
-- [Skills](#34-skills)
+- [Testing](#testing)
+- [MCP Servers](#24-mcp-servers)
+- [Skills](#57-skills)
 - [Architecture](#architecture)
-- [Ideas from Claude-Mem](#-ideas-from-claude-mem)
 
 ---
 
@@ -27,11 +38,10 @@ One-click MCP server and skills manager for **Kimi CLI** -- like `claude-mem` bu
 ### One-liner with npx (recommended)
 
 ```bash
-# macOS / Linux / Windows
 npx kimi-mcp-hub install
 ```
 
-This creates an isolated Python virtual environment in `~/.kimi-mcp-hub/venv`, installs the package, and runs the interactive setup wizard.
+This creates an isolated Python virtual environment at `~/.kimi-mcp-hub/.venv`, installs the package, and runs the interactive setup.
 
 ### One-liner (curl / PowerShell)
 
@@ -39,24 +49,37 @@ This creates an isolated Python virtual environment in `~/.kimi-mcp-hub/venv`, i
 # macOS / Linux (curl + pip from GitHub)
 curl -fsSL https://raw.githubusercontent.com/KalimeroMK/kimi-mcp-hub/main/install/install.sh | bash
 
+# macOS / Linux with auto CLAUDE.md support
+curl -fsSL https://raw.githubusercontent.com/KalimeroMK/kimi-mcp-hub/main/install/install.sh | bash -s -- -y
+
+# macOS / Linux with Obsidian local memory
+curl -fsSL https://raw.githubusercontent.com/KalimeroMK/kimi-mcp-hub/main/install/install.sh | bash -s -- --with-obsidian
+
 # Windows (PowerShell)
 iwr -useb https://raw.githubusercontent.com/KalimeroMK/kimi-mcp-hub/main/install/install.ps1 | iex
+
+# Windows with auto CLAUDE.md support
+iwr -useb https://raw.githubusercontent.com/KalimeroMK/kimi-mcp-hub/main/install/install.ps1 | & ([scriptblock]::create($_)) -Yes
+
+# Windows with Obsidian local memory
+iwr -useb https://raw.githubusercontent.com/KalimeroMK/kimi-mcp-hub/main/install/install.ps1 | & ([scriptblock]::create($_)) -Yes -WithObsidian
 ```
 
-### From GitHub (pip)
+### From GitHub (pip) inside a venv
 
 ```bash
 # Direct from GitHub -- no clone needed
-pip install --user git+https://github.com/KalimeroMK/kimi-mcp-hub.git
-
-# Upgrade
-pip install --user --upgrade git+https://github.com/KalimeroMK/kimi-mcp-hub.git
+python3 -m venv ~/.kimi-mcp-hub/.venv
+~/.kimi-mcp-hub/.venv/bin/pip install --upgrade git+https://github.com/KalimeroMK/kimi-mcp-hub.git
+ln -s ~/.kimi-mcp-hub/.venv/bin/kimi-mcp-hub ~/.local/bin/kimi-mcp-hub
 ```
 
 ### From PyPI (when published)
 
 ```bash
-pip install --user kimi-mcp-hub
+python3 -m venv ~/.kimi-mcp-hub/.venv
+~/.kimi-mcp-hub/.venv/bin/pip install --upgrade kimi-mcp-hub
+ln -s ~/.kimi-mcp-hub/.venv/bin/kimi-mcp-hub ~/.local/bin/kimi-mcp-hub
 ```
 
 ### Clone + Install (development)
@@ -64,6 +87,8 @@ pip install --user kimi-mcp-hub
 ```bash
 git clone https://github.com/KalimeroMK/kimi-mcp-hub.git
 cd kimi-mcp-hub
+python3 -m venv .venv
+source .venv/bin/activate
 pip install -e .
 ```
 
@@ -84,17 +109,17 @@ kimi-mcp-hub --version
 On first run you'll see:
 
 ```
-Kimi MCP Hub v0.1.0 e uspeshno instaliran!
+Kimi MCP Hub v0.1.0 installed successfully!
 
-23 MCP serveri dostapni
-34 AI skills za podobro kodiranje
-1  Persistent memory sistem
+24 MCP servers available
+57 AI skills for better coding
+1  Persistent memory system
 
-Za da zapochnesh:
-  kimi-mcp-hub init    -- interaktiven wizard
-  kimi-mcp-hub welcome -- detalen pregled
-  kimi-mcp-hub status  -- status proverka
-  kimi-mcp-hub doctor  -- zdravje na sistemot
+To get started:
+  kimi-mcp-hub init    -- interactive wizard
+  kimi-mcp-hub welcome -- detailed overview
+  kimi-mcp-hub status  -- status check
+  kimi-mcp-hub doctor  -- system health check
 ```
 
 ### Run the wizard
@@ -104,21 +129,23 @@ kimi-mcp-hub init
 ```
 
 This walks you through:
-1. **MCP Servers** -- pick which services to connect
+1. **MCP Servers** -- Chrome DevTools, Context7, and Playwright are auto-installed if `npx` is available; pick additional services manually
 2. **Skills** -- install AI behavior patterns
 3. **Memory** -- enable persistent cross-session memory
 
+
 ---
 
 ## Uninstall
 
 ```bash
 # Full reset
-pip uninstall kimi-mcp-hub
-rm -f ~/.kimi/mcp.json
-rm -rf ~/.kimi/skills/
-rm -rf ~/.kimi/mcp-hub/
+rm -f ~/.kimi-code/mcp.json
+rm -rf ~/.kimi-code/skills/
+rm -rf ~/.kimi-mcp-hub/
 rm -rf ~/.config/kimi-mcp-hub/
+rm -f ~/.local/bin/kimi-mcp-hub
+rm -f ~/.local/bin/kmcp
 
 # Or use the CLI
 kimi-mcp-hub remove jira      # remove one server
@@ -128,9 +155,8 @@ kimi-mcp-hub remove github    # remove another
 **Complete reinstall:**
 
 ```bash
-pip uninstall kimi-mcp-hub
-rm -rf ~/.kimi/mcp.json ~/.kimi/skills/ ~/.kimi/mcp-hub/
-pip install --user git+https://github.com/KalimeroMK/kimi-mcp-hub.git
+rm -rf ~/.kimi-code/mcp.json ~/.kimi-code/skills/ ~/.kimi-mcp-hub/
+bash -c "$(curl -fsSL https://raw.githubusercontent.com/KalimeroMK/kimi-mcp-hub/main/install/install.sh)"
 kimi-mcp-hub init
 ```
 
@@ -148,9 +174,18 @@ kimi-mcp-hub doctor
 # Full interactive setup
 kimi-mcp-hub init
 
+# Non-interactive setup (auto-installs core + frontend skills, memory, and claude-compat)
+kimi-mcp-hub init --yes
+
+# Auto-load CLAUDE.md and CLAUDE.local.md at every session start
+kimi-mcp-hub claude-compat
+kimi-mcp-hub claude-compat --yes
+
 # Add servers individually
 kimi-mcp-hub add jira
 kimi-mcp-hub add github
+kimi-mcp-hub add slack
+kimi-mcp-hub add supabase
 kimi-mcp-hub add perplexity
 kimi-mcp-hub add gitlab
 kimi-mcp-hub add stripe
@@ -159,20 +194,35 @@ kimi-mcp-hub add desktop-commander
 kimi-mcp-hub add dbhub
 kimi-mcp-hub add mobile
 
-# Or use npx without installing Node package globally:
-# npx kimi-mcp-hub status
+# Update to the latest version
+kimi-mcp-hub update
 
-# Auth with auto-browser (OAuth) -- like Claude Code CLI
-kimi-mcp-hub auth github
-kimi-mcp-hub auth slack
-kimi-mcp-hub auth figma
-kimi-mcp-hub auth gitlab
-kimi-mcp-hub auth stripe
+# Add and authorize OAuth servers -- like Claude Code CLI
+kimi-mcp-hub add github   # choose oauth-device to configure and authorize
+kimi-mcp-hub add figma
+
+# GitLab and Stripe are official remote MCP servers; authorize via Kimi CLI:
+# kimi mcp auth gitlab
+# kimi mcp auth stripe
+
+# For other official remote MCP servers, Kimi CLI handles the popup:
+# /mcp-config login jira
+# /mcp-config login linear
+# /mcp-config login confluence
+# /mcp-config login supabase
 
 # See everything configured
 kimi-mcp-hub list
 kimi-mcp-hub status
 kimi-mcp-hub welcome
+kimi-mcp-hub notify
+
+# Fix broken configs after package updates
+kimi-mcp-hub repair
+
+# Per-project MCP configuration
+kimi-mcp-hub add --project linear   # save to ./.kimi/mcp.json
+kimi-mcp-hub sync                   # merge project config into global config
 
 # Import from Claude Desktop
 kimi-mcp-hub import-claude
@@ -183,6 +233,232 @@ kimi-mcp-hub install-skill docker-pro
 
 # Test a server
 kimi-mcp-hub test github
+
+# Manage Obsidian vaults for local memory
+kimi-mcp-hub obsidian status
+kimi-mcp-hub obsidian add ~/Documents/MyVault
+kimi-mcp-hub obsidian list
+kimi-mcp-hub obsidian remove myvault
+kimi-mcp-hub obsidian sync-templates myvault
+kimi-mcp-hub obsidian sync-templates --templates-dir ./templates myvault
+```
+
+---
+
+## Update
+
+Update `kimi-mcp-hub` to the latest version in the isolated venv:
+
+```bash
+kimi-mcp-hub update
+```
+
+This upgrades the package from GitHub (preferred) or PyPI and refreshes the `~/.local/bin` symlinks. Development installs (git checkouts) are detected and skipped.
+
+---
+
+## Managing MCP Servers and Skills
+
+### Skills
+
+Skills are toggled **inside Kimi CLI**:
+
+```text
+/skill:caveman
+/skill:headroom
+/skill:code-review
+```
+
+- Core skills (`karpathy`, `superpowers`, `caveman`, `headroom`, `context-mode`, `cybersecurity`, `kimi-mcp-hub-status`) activate automatically on every Kimi start.
+- Install more skills from the terminal:
+  ```bash
+  kimi-mcp-hub install-skill docker-pro
+  ```
+
+### MCP Servers
+
+MCP servers are enabled **outside Kimi CLI**, in your regular terminal:
+
+```bash
+# Stdio / API-key servers
+kimi-mcp-hub add github   # choose PAT or oauth-device
+kimi-mcp-hub add slack
+
+# Official remote OAuth servers can also be connected inside Kimi:
+# /mcp-config login linear
+# /mcp-config login jira
+# /mcp-config login supabase
+```
+
+`linear` also supports an API-key stdio mode via `kimi-mcp-hub add linear` → choose `api-key`.
+
+When you add an `npx`-based server for the first time, `kimi-mcp-hub` checks if the package is already installed and prompts to install it globally. This prevents the 30-second timeout that can happen when Kimi CLI tries to launch a not-yet-cached npx package.
+
+After adding a server, **restart Kimi CLI** (`exit` → `kimi`) so it picks up the new config.
+
+For a detailed walkthrough of official remote OAuth servers (Linear, Jira, Confluence, Supabase, Figma, Stripe, GitLab), see [Remote MCP Server Setup](docs/remote-mcp-server-setup.md).
+
+---
+
+## Obsidian Local Memory
+
+Obsidian vaults can be used as local memory and knowledge bases. The `obsidian` command group manages vault paths without needing the full `init` wizard.
+
+```bash
+# Show configured vaults and their status
+kimi-mcp-hub obsidian status
+
+# Add a vault path (scaffolds the vault if needed)
+kimi-mcp-hub obsidian add ~/Documents/MyVault
+
+# List configured vaults
+kimi-mcp-hub obsidian list
+
+# Remove a vault from the config by slug (files are kept)
+kimi-mcp-hub obsidian remove myvault
+
+# Copy built-in templates into a vault
+kimi-mcp-hub obsidian sync-templates myvault
+
+# Copy custom templates into a vault
+kimi-mcp-hub obsidian sync-templates --templates-dir ./templates myvault
+```
+
+The first vault added is set as the default memory vault. After adding a vault, restart Kimi CLI so the Obsidian MCP server picks it up.
+
+---
+
+## Install Claude/Codex Plugins
+
+Kimi CLI now supports lifecycle hooks (`PreToolUse`, `PostToolUse`, `Stop`, etc.) via `~/.kimi-code/config.toml`. Because Kimi uses the same JSON wire protocol as Claude Code and Codex, plugins written for those agents can be adapted automatically.
+
+```bash
+# Install Ponytail (reduces over-engineering)
+kimi-mcp-hub install-plugin DietrichGebert/ponytail
+
+# From a full URL
+kimi-mcp-hub install-plugin https://github.com/DietrichGebert/ponytail
+
+# From a local checkout
+kimi-mcp-hub install-plugin ./ponytail
+
+# Non-interactive reinstall/update
+kimi-mcp-hub install-plugin DietrichGebert/ponytail --yes
+```
+
+`install-plugin` does the following:
+
+1. Clones the repo to `~/.config/kimi-mcp-hub/plugins/<name>/` (or copies a local directory)
+2. Discovers the plugin manifest among supported formats:
+   - `hooks.json` / `hooks/hooks.json` / `hooks/claude-codex-hooks.json`
+   - `.claude/settings.json`
+   - `.codex/hooks.json`
+   - `.claude-plugin/plugin.json` (Claude marketplace format)
+   - `gemini-extension.json`
+3. Converts discovered hooks to Kimi `[[hooks]]` entries in `~/.kimi-code/config.toml`
+4. Expands `${PLUGIN_ROOT}`, `${CLAUDE_PLUGIN_ROOT}`, and `${CLAUDE_CODE_PLUGIN_ROOT}` to the install directory
+5. Relativizes hardcoded absolute paths that still point inside the plugin directory so commands stay portable
+6. Merges the plugin's `AGENTS.md` into `~/.kimi-code/AGENTS.md` (idempotent by marker)
+7. Copies plugin skills into `~/.kimi-code/skills/`
+
+**What this unlocks**
+
+1. **Ponytail** works immediately — reduces over-engineering in every project.
+2. **Security hooks** — block edits to `.env` files or dangerous `rm` commands.
+3. **Auto-format / auto-lint** hooks after every `WriteFile`.
+4. **Stop hooks** — verify tests passed before the session ends.
+5. `kimi-mcp-hub` becomes a hub for agent extensions, not just an MCP manager.
+
+**Tool-name mapping**
+
+| Claude/Codex | Kimi matcher |
+|--------------|--------------|
+| `Write` | `WriteFile\|StrReplaceFile` |
+| `Edit` | `Edit\|StrReplaceFile` |
+| `Read` | `ReadFile` |
+| `Bash` | `Shell\|Bash` |
+
+After installing a plugin, **restart Kimi CLI** for the hooks to take effect.
+
+### Managing installed plugins
+
+Plugins installed from GitHub can be updated and removed through the CLI:
+
+```bash
+# Pull latest changes for a git plugin, or re-copy a local plugin
+kimi-mcp-hub update-plugin ponytail
+
+# Remove a plugin completely
+kimi-mcp-hub uninstall-plugin ponytail
+```
+
+`update-plugin` re-runs the install merge, so new hooks, skills, and `AGENTS.md` sections are applied automatically. `uninstall-plugin` removes the plugin directory, deletes its hooks from `~/.kimi-code/config.toml`, removes any skills it installed, and removes its section from `~/.kimi-code/AGENTS.md`.
+
+---
+
+## Project-Level MCP Configuration
+
+If you work on multiple projects that need different MCP accounts, you can store MCP servers inside each project. The example below adds Linear's official remote OAuth server:
+
+```bash
+cd my-project
+kimi-mcp-hub add --project linear   # choose the default "official-oauth" mode
+kimi-mcp-hub sync
+```
+
+This creates:
+
+```text
+my-project/
+└── .kimi/
+    ├── mcp.json          # server config
+    └── mcp.env           # only needed for API-key / stdio servers (add this to .gitignore)
+```
+
+`.kimi/mcp.json` example (Linear official remote OAuth — no `env`):
+
+```json
+{
+  "mcpServers": {
+    "linear": {
+      "transport": "http",
+      "url": "https://mcp.linear.app/mcp",
+      "auth": "oauth"
+    }
+  }
+}
+```
+
+`.kimi/mcp.env` is only required for servers that store secrets in environment variables (for example, API-key stdio servers such as Perplexity or a GitHub PAT). OAuth servers like Linear keep tokens inside Kimi CLI's own secure storage and do not need a project `.env` file.
+
+### Switching between projects
+
+When you switch projects, run `sync` to rewrite the global `~/.kimi-code/mcp.json` with that project's servers:
+
+```bash
+cd project-a && kimi-mcp-hub sync   # global config now uses project-a's Linear
+cd project-b && kimi-mcp-hub sync   # global config now uses project-b's Linear
+```
+
+Project servers override global servers with the same name. Global servers that are not overridden remain available.
+
+### Commands with --project
+
+```bash
+kimi-mcp-hub init --project          # save wizard servers to current project
+kimi-mcp-hub add --project perplexity # add API-key server to current project
+kimi-mcp-hub add --project linear    # add official remote OAuth server to current project
+kimi-mcp-hub auth --project figma    # authorize and save an OAuth server to current project
+kimi-mcp-hub remove --project perplexity # remove server from current project
+kimi-mcp-hub sync                    # merge current project into global config
+kimi-mcp-hub sync /path/to/project   # merge a specific project
+```
+
+
+If you have **Desktop Commander** installed, you can also ask Kimi to run the command for you:
+
+```text
+run kimi-mcp-hub add linear in the terminal
 ```
 
 ---
@@ -213,19 +489,43 @@ GitHub authorized successfully!
 ```
 
 | Server | Method | Auto-browser |
-|--------|--------|:------------:|
+|--------|------|:-----:|
 | **GitHub** | Device Flow (or PAT fallback) | Yes |
-| **Jira** | API Token or Official MCP OAuth | Yes |
-| **Confluence** | API Token or Official MCP OAuth | Yes |
-| **Slack** | Bot Token or OAuth 2.0 | Yes |
+| **Jira** | Official MCP OAuth or API token | Yes* |
+| **Confluence** | Official MCP OAuth or API token | Yes* |
+| **Slack** | Bot/User token (`slack-mcp-server`) | Yes |
 | **Figma** | Official OAuth 2.1, PAT or custom OAuth 2.0 | Yes* |
 | **Gmail** | Google OAuth 2.0 or npx | Yes |
 | **Linear** | Official OAuth 2.1 or API key | Yes* |
 | **Stripe** | Official OAuth 2.1 or restricted API key | Yes* |
 | **GitLab** | Official OAuth 2.1 or PAT | Yes* |
+| **Supabase** | Official remote OAuth or access-token stdio | Yes* |
 | **Datadog** | API + App keys | No (manual) |
 
-\* Linear/Figma/Stripe/GitLab OAuth 2.1 се иницира од Kimi CLI (`kimi mcp auth <server>`) откако ќе го додадете официјалниот remote MCP сервер.
+\* Official remote OAuth 2.1 is initiated by Kimi CLI (`kimi mcp auth <server>` or `/mcp-config login <server>`) after you add the official remote MCP server. For Slack, run `kimi-mcp-hub auth slack` to start the browser-based OAuth flow.
+
+---
+
+## CLAUDE.md Compatibility
+
+If you are migrating from Claude Code or want Kimi to automatically read project instructions, apply the `claude-compat` patch:
+
+```bash
+# Interactive
+kimi-mcp-hub claude-compat
+
+# Non-interactive (useful in install scripts)
+kimi-mcp-hub claude-compat --yes
+```
+
+This appends a block to `~/.kimi-code/AGENTS.md` that tells Kimi to check for two files at the start of every session:
+
+| Priority | File | Purpose |
+|----------|------|---------|
+| 1 | `CLAUDE.local.md` | Local overrides — machine-specific, gitignored |
+| 2 | `CLAUDE.md` | Project-wide instructions — committed to the repo |
+
+`CLAUDE.local.md` takes precedence over `CLAUDE.md` when they conflict.
 
 ---
 
@@ -235,23 +535,43 @@ GitHub authorized successfully!
 |---------|-------------|
 | `kimi-mcp-hub` | Show welcome banner and status |
 | `kimi-mcp-hub --version` | Show version |
-| `kimi-mcp-hub install` | Install/update from PyPI/GitHub |
+| `kimi-mcp-hub install` | Install or update Kimi MCP Hub |
+| `kimi-mcp-hub update` | Update to the latest version |
 | `kimi-mcp-hub init` | Full interactive wizard |
+| `kimi-mcp-hub init --yes` | Non-interactive setup with defaults |
+| `kimi-mcp-hub claude-compat` | Patch AGENTS.md for CLAUDE.md auto-load |
+| `kimi-mcp-hub claude-compat --yes` | Apply patch without confirmation |
 | `kimi-mcp-hub status` | Version, servers, skills, memory |
 | `kimi-mcp-hub welcome` | Detailed welcome banner |
+| `kimi-mcp-hub notify` | Short startup notification for shell wrappers |
 | `kimi-mcp-hub add <server>` | Add an MCP server |
+| `kimi-mcp-hub add obsidian` | Add Obsidian vault as local memory |
+| `kimi-mcp-hub add --project <server>` | Add an MCP server to the current project |
 | `kimi-mcp-hub remove <server>` | Remove an MCP server |
+| `kimi-mcp-hub remove --project <server>` | Remove an MCP server from the current project |
 | `kimi-mcp-hub auth <server>` | OAuth with auto-browser |
+| `kimi-mcp-hub auth --project <server>` | OAuth and save to the current project |
+| `kimi-mcp-hub sync` | Merge project `.kimi/mcp.json` into global config |
+| `kimi-mcp-hub repair` | Fix broken/outdated server configs |
 | `kimi-mcp-hub import-claude` | Import from Claude Desktop |
+| `kimi-mcp-hub install-plugin <repo>` | Install Claude/Codex plugin into Kimi |
+| `kimi-mcp-hub install-plugin <repo> --yes` | Install plugin without confirmation |
+| `kimi-mcp-hub update-plugin <name>` | Update an installed plugin |
+| `kimi-mcp-hub uninstall-plugin <name>` | Remove an installed plugin and its artifacts |
 | `kimi-mcp-hub list` | All servers + skills + memory |
-| `kimi-mcp-hub list-skills` | All 34 available skills |
+| `kimi-mcp-hub list-skills` | All 57 available skills |
 | `kimi-mcp-hub install-skill <name>` | Install a skill |
-| `kimi-mcp-hub test <server>` | Test if server responds |
+| `kimi-mcp-hub test <server>` | Check if server binary/HTTP endpoint is configured |
 | `kimi-mcp-hub doctor` | System health check |
+| `kimi-mcp-hub obsidian status` | Show configured Obsidian vaults |
+| `kimi-mcp-hub obsidian add <path>` | Add an Obsidian vault path |
+| `kimi-mcp-hub obsidian list` | List configured Obsidian vaults |
+| `kimi-mcp-hub obsidian remove <slug>` | Remove an Obsidian vault from config |
+| `kimi-mcp-hub obsidian sync-templates [--templates-dir PATH] <vault-slug>` | Copy templates into a vault |
 
 ---
 
-## 23 MCP Servers
+## 24 MCP Servers
 
 | Server | Auth | Tools | Best for |
 |--------|------|:-----:|----------|
@@ -259,8 +579,9 @@ GitHub authorized successfully!
 | **Linear** | Official OAuth 2.1 or API key | 6 | Issues, projects, teams |
 | **Confluence** | OAuth or API token | 5 | Docs, wiki, pages |
 | **GitHub** | Device Flow / PAT | 6 | Repos, PRs, issues, code |
-| **Slack** | OAuth or token | 7 | Channels, DMs, search |
-| **Datadog** | API + App keys | 12 | Metrics, logs, monitors, APM |
+| **Slack** | Bot/User token (`slack-mcp-server`) | 5 | Channels, DMs, search |
+| **Obsidian** | STDIO (npx) — vault path | 4 | Local memory, notes, knowledge base |
+| **Datadog** | Official remote MCP (API + App keys) | 12 | Metrics, logs, monitors, APM |
 | **Figma** | Official OAuth 2.1, PAT or custom OAuth | 9 | Designs, tokens, components |
 | **Figma Context** | Figma API access token | 3 | Design-to-code implementation |
 | **GitLab** | Official OAuth 2.1 or PAT | 8 | Repos, MRs, issues, CI/CD pipelines |
@@ -276,69 +597,141 @@ GitHub authorized successfully!
 | **Playwright** | STDIO (Node.js) | 8 | Browser automation, E2E testing, screenshots |
 | **Sentry** | Auth token + org | 6 | Error tracking, issue triage, stack traces |
 | **Context7** | STDIO (npx) | 4 | Live library docs, version-aware API lookup |
-| **Supabase** | URL + API key | 6 | Database, auth, storage, realtime, edge functions |
-| **Perplexity** | **API key (free tier)** | **3** | **Real-time web search with AI summaries + citations** |
+| **Supabase** | Official remote OAuth or access-token stdio | 6 | Database, auth, storage, realtime, edge functions |
+| **Perplexity** | **API key (paid, $5 trial credit)** | **3** | **Real-time web search with AI summaries + citations** |
 
 ---
 
-## 34 Skills
+## 57 Skills
 
 ### Core Skills (installed by default)
 
-| Skill | Description | Trigger |
-|-------|-------------|---------|
-| **karpathy** | Clean, simple, readable code | Any code generation |
-| **superpowers** | 14 agentic dev skills (plan, debug, test, deploy...) | "plan", "debug", "architect" |
-| **headroom** | Compress tool outputs (save tokens) | Large outputs, "compress" |
-| **context-mode** | Context window optimization | "context limit", "token budget" |
-| **cybersecurity** | Security expert (OWASP, cloud, IR, pentest) | "security", "hack", "OWASP" |
-| **kimi-mcp-hub-status** | Shows MCP Hub version/status in Kimi CLI | Session start |
-
-### Optional Skills
-
-| Skill | Description | Trigger |
-|-------|-------------|---------|
-| **caveman** | Terse mode (75% token reduction) | "caveman", "terse", "brief" |
-| **ecc** | Engineering Competence (perf, security, research) | "optimize", "secure", "research" |
-| **ui-ux-pro-max** | Design intelligence (Tailwind, accessibility) | "design", "UI", "CSS" |
-| **visual-explainer** | HTML diagrams and slides | "visualize", "diagram" |
-| **task-master** | Task management system | "task", "todo", "backlog" |
-| **gitnexus** | Code knowledge graph (git blame, blast radius) | "who wrote this", "impact" |
-| **ralph** | Autonomous loop with stop-hooks | "keep going", "continue" |
-| **security-audit** | Security review checklist | "security", "audit", "vulnerability" |
-| **security-guidance** | 3-layer security scanning (Anthropic-style) | File edits, "security scan" |
-| **research-mode** | Research-driven development | "research", "compare", "benchmark" |
-| **perf-optimization** | Performance profiling and fixes | "slow", "profile", "benchmark" |
-| **memory-palace** | Advanced context management | "remember", "previous session" |
-| **code-reviewer** | Code review assistant | "review", "CR", "feedback" |
-| **code-review-anthropic** | Multi-agent PR review (sub-agents) | "PR review", "deep review" |
-| **api-designer** | REST/GraphQL API design | "API", "endpoint", "REST" |
-| **docker-pro** | Docker and Kubernetes best practices | "docker", "container", "k8s" |
-| **database-expert** | Database design and optimization | "database", "SQL", "schema" |
-| **backend-architect** | Backend architecture (API, DB, scale) | "design API", "system design" |
-| **python-engineer** | Python specialist (FastAPI, Django, async) | "Python", "FastAPI", "Django" |
-| **react-coder** | React 19 specialist (RSC, hooks) | "React", "component", "Next.js" |
-| **ts-coder** | TypeScript specialist (strict, generics) | "TypeScript", "TS", "generic" |
-| **ui-engineer** | UI/UX engineer (Tailwind, a11y, responsive) | "UI", "Tailwind", "responsive" |
-| **laravel-engineer** | Laravel specialist (Eloquent, Blade, Livewire, Queues) | "Laravel", "Eloquent", "PHP" |
-| **find-skills** | Discover and install agent skills from the open ecosystem | "find skill", "install skill" |
+| Skill | Description |
+|-------|-------------|
+| **karpathy** | Clean, simple, readable code discipline |
+| **superpowers** | 14 agentic workflows (plan, debug, test, deploy...) |
+| **headroom** | Compress large tool outputs to save tokens |
+| **context-mode** | Context window optimization and token budget |
+| **cybersecurity** | Cybersecurity expert (OWASP, cloud, IR, pentest) |
+| **caveman** | Ultra-compressed caveman communication mode |
+| **kimi-mcp-hub-status** | Show MCP Hub version and status |
+
+### Frontend Skills (installed as a stack by default)
+
+| Skill | Description |
+|-------|-------------|
+| **react-coder** | React 19 specialist (RSC, hooks) |
+| **ts-coder** | TypeScript specialist (strict, generics) |
+| **ui-engineer** | UI component implementation (Tailwind, a11y) |
+| **ui-ux-pro-max** | UI/UX design intelligence and design systems |
+| **vercel-react-best-practices** | React/Next.js performance optimization |
+| **web-design-guidelines** | Audit UI code against Vercel guidelines |
+| **agent-browser** | Browser automation for web tasks and testing |
+
+### Code Quality & Review Skills
+
+| Skill | Description |
+|-------|-------------|
+| **code-reviewer** | Quick single-agent code review |
+| **code-review** | Multi-agent code review (explore/coder/plan) |
+| **surgical-refactoring** | Surgical code refactoring without behavior change |
+| **tdd** | Test-driven development with red-green-refactor |
+| **perf-optimization** | Performance profiling and optimization |
+| **security-audit** | Security review checklist |
+| **security-guidance** | 3-layer security scanning guidance |
+
+### Architecture & Design Skills
+
+| Skill | Description |
+|-------|-------------|
+| **api-designer** | REST/GraphQL API design |
+| **backend-architect** | Backend architecture and system design |
+| **backend-typescript-architect** | TypeScript/Bun backend architecture |
+| **codebase-design** | Design deep modules and testable interfaces |
+| **domain-modeling** | Build domain models and ubiquitous language |
+| **database-expert** | Database design and optimization |
+| **design-system** | Design tokens, component specs, and systematic design systems |
+| **api-design** | REST API design patterns |
+
+### DevOps & Deployment Skills
+
+| Skill | Description |
+|-------|-------------|
+| **docker-pro** | Docker and Kubernetes best practices |
+| **gitnexus** | Code knowledge graph and blast radius |
+| **resolving-merge-conflicts** | Resolve git merge/rebase conflicts |
+| **deployment-patterns** | CI/CD and deployment best practices |
+
+### Language / Framework Skills
+
+| Skill | Description |
+|-------|-------------|
+| **python-engineer** | Python specialist (FastAPI, Django, async) |
+| **laravel-engineer** | Laravel specialist (Eloquent, Blade, Livewire) |
+| **php-pro** | Senior PHP development (strict typing, Laravel/Symfony, PSR) |
+| **wp-plugin-development** | WordPress plugin development with hooks and Settings API |
+| **react-coder** | React 19 specialist (RSC, hooks) |
+| **ts-coder** | TypeScript specialist (strict, generics) |
+| **ui-engineer** | UI component implementation (Tailwind, a11y) |
+| **ui-ux-pro-max** | UI/UX design intelligence and design systems |
+
+### Data & Migrations Skills
+
+| Skill | Description |
+|-------|-------------|
+| **database-migrations** | Safe database migration patterns |
+
+### Testing & Browser Skills
+
+| Skill | Description |
+|-------|-------------|
+| **playwright-best-practices** | Playwright testing best practices |
+| **chrome-devtools-skill** | Chrome DevTools MCP debugging and automation |
+
+### Research & Automation Skills
+
+| Skill | Description |
+|-------|-------------|
+| **search-first** | Research-before-coding workflow |
+| **regex-vs-llm-structured-text** | Regex vs LLM parsing decision framework |
+
+### Productivity & Meta Skills
+
+| Skill | Description |
+|-------|-------------|
+| **claude-compat** | Auto-load CLAUDE.md and CLAUDE.local.md at session start |
+| **caveman-review** | Ultra-compressed code review comments |
+| **caveman-commit** | Ultra-compressed Conventional Commits messages |
+| **memory-palace** | Advanced memory and context retrieval |
+| **hindsight** | Memory that learns from past decisions |
+| **task-master** | Task management system |
+| **ralph** | Autonomous loop with stop-hooks |
+| **grill-me** | Stress-test a plan or design |
+| **visual-explainer** | HTML diagrams and slides |
+| **research-mode** | Research-driven development |
+| **ecc** | Engineering competence (perf, security, research) |
+| **skill-creator** | Create and optimize agent skills |
+| **agent-automation-recommender** | Recommend agent automations for codebases |
+| **find-skills** | Discover and install agent skills |
+
+### Integration Skills
+
+| Skill | Description |
+|-------|-------------|
+| **stripe-best-practices** | Stripe integration best practices |
 
 ---
 
-## Ideas from Claude-Mem
+## Testing
 
-Features we adopted from the 81k-star `claude-mem` project:
+The test suite lives in `tests/`:
+
+```bash
+pytest -q
+```
 
-| Feature | Claude-Mem | Kimi MCP Hub |
-|---------|-----------|-------------|
-| **One-line install** | `npx claude-mem install` | `curl .../install.sh \| bash` |
-| **Auto-detect CLI** | `--ide gemini-cli`, `--ide opencode` | Auto-detect `kimi` CLI |
-| **Persistent memory** | AI-compressed observations | SQLite + FTS5 |
-| **Web viewer UI** | `http://localhost:37777` | Coming soon |
-| **Skills / memory search** | `mem-search` skill | Built-in `memory_palace` skill |
-| **Privacy tags** | `<private>` content exclusion | Planned |
-| **Plugin hooks** | `.claude/`, `.codex/` hooks | `~/.kimi/skills/` directory |
-| **Import from other tools** | - | Claude Desktop import |
+- `tests/test_integration.py` covers end-to-end flows such as `init --yes`, server `add`, `remove`, and `test`.
+- Unit tests cover config handling, Obsidian vault management, and the plugin installer.
 
 ---
 
@@ -351,21 +744,29 @@ Features we adopted from the 81k-star `claude-mem` project:
 |  |  (no args) -> welcome banner    |    |
 |  |  install -> PyPI/GitHub update  |    |
 |  |  init -> interactive wizard     |    |
-|  |  add  -> writes ~/.kimi/mcp.json|    |
+|  |  add  -> writes ~/.kimi-code/...|    |
+|  |  add --project -> writes ./.kimi|    |
+|  |  sync -> merge project + global |    |
 |  |  auth -> OAuth + auto browser   |    |
+|  |  repair -> fix broken configs   |    |
 |  |  import-claude -> migrate config|    |
 |  |  list -> pretty table of tools  |    |
 |  |  status -> version + health     |    |
 |  |  welcome -> full info display   |    |
+|  |  notify -> startup notification |    |
 |  +---------------------------------+    |
 |              |                          |
 |  +---------------------------------+    |
-|  |  ~/.kimi/mcp.json               |    |
-|  |  ~/.kimi-code/skills/ (34 skills) |    |
-|  |  ~/.kimi/mcp-hub/memory.db      |    |
+|  |  Global: ~/.kimi-code/mcp.json  |    |
+|  |  Project: ./.kimi/mcp.json      |    |
+|  |  Project secrets: ./.kimi/mcp.env|   |
+|  |  ~/.kimi-code/skills/ (57 skills)|    |
+|  |  <config-dir>/kimi-mcp-hub/     |    |
+|  |    tokens.json + memory.db      |    |
 |  +---------------------------------+    |
 |              |                          |
-|  First-run welcome message (auto)       |
+|  Optional shell wrapper prints notify   |
+|  on every `kimi` start                  |
 |              |                          |
 |         Kimi CLI reads config           |
 |              |                          |
@@ -379,9 +780,10 @@ Features we adopted from the 81k-star `claude-mem` project:
 
 ## Security Notes
 
-- OAuth tokens are stored as plain JSON in `~/.config/kimi-mcp-hub/tokens.json`. This keeps the tool dependency-free, but means anyone with access to your user account can read them.
+- On macOS and Linux, sensitive files (`tokens.json`, `memory.db`, and `~/.kimi-code/mcp.json`) are written with `chmod 600` (owner read/write only).
+- Run `kimi-mcp-hub doctor` to detect and fix overly permissive files.
+- OAuth tokens are still stored as plain JSON inside those files. This keeps the tool dependency-free, but a process running as your user can read them while Kimi CLI is active.
 - By default GitHub authentication uses a public OAuth app (`kimi-mcp-hub`). You can supply your own GitHub/Atlassian OAuth Client ID when running `kimi-mcp-hub auth <server>`.
-- API keys and PATs are written to `~/.kimi/mcp.json`. Protect that file accordingly.
 
 ---
 

package/install/install.ps1

@@ -1,37 +1,60 @@
 # Kimi MCP Hub - One-line installer for Windows (PowerShell)
-# Usage: iwr -useb https://raw.githubusercontent.com/KalimeroMK/kimi-mcp-hub/main/install/install.ps1 | iex
+# Usage:
+#   iwr -useb https://raw.githubusercontent.com/KalimeroMK/kimi-mcp-hub/main/install/install.ps1 | iex
+#   iwr -useb https://raw.githubusercontent.com/KalimeroMK/kimi-mcp-hub/main/install/install.ps1 | & ([scriptblock]::create($_)) -Yes
+#   iwr -useb https://raw.githubusercontent.com/KalimeroMK/kimi-mcp-hub/main/install/install.ps1 | & ([scriptblock]::create($_)) -Yes -WithObsidian
+
+[CmdletBinding()]
+param(
+    [switch]$Yes,
+    [switch]$WithObsidian,
+    [string]$ObsidianVault = "$env:USERPROFILE\Documents\Kimi-Memory"
+)
 
 $REPO = "KalimeroMK/kimi-mcp-hub"
 $INSTALL_DIR = if ($env:KIMI_MCP_HUB_DIR) { $env:KIMI_MCP_HUB_DIR } else { "$env:USERPROFILE\.kimi-mcp-hub" }
+$VENV_DIR = "$INSTALL_DIR\.venv"
 
 function Write-Header {
     Write-Host ""
     Write-Host "  KIMI MCP HUB" -ForegroundColor Cyan -NoNewline
     Write-Host " - One-click MCP server & skills manager" -ForegroundColor Gray
-    Write-Host "  23 MCP Servers | 34 AI Skills | Persistent Memory" -ForegroundColor DarkGray
+    Write-Host "  24 MCP Servers | 57 AI Skills | Persistent Memory" -ForegroundColor DarkGray
     Write-Host ""
 }
 
 function Check-Requirements {
     Write-Host "Checking requirements..." -ForegroundColor Cyan
     
-    # Check Python
-    if (Get-Command python -ErrorAction SilentlyContinue) {
-        $pyVersion = (python --version 2>&1).ToString().Split()[1]
-        Write-Host "  Python $pyVersion found" -ForegroundColor Green
-    } elseif (Get-Command python3 -ErrorAction SilentlyContinue) {
-        $pyVersion = (python3 --version 2>&1).ToString().Split()[1]
-        Write-Host "  Python $pyVersion found" -ForegroundColor Green
-    } else {
+    # Check Python (prefer 3.10+)
+    $PYTHON = $null
+    foreach ($py in @("python3.13", "python3.12", "python3.11", "python3.10", "python", "python3")) {
+        if (Get-Command $py -ErrorAction SilentlyContinue) {
+            $verStr = (& $py --version 2>&1).ToString()
+            if ($verStr -match "Python (\d+)\.(\d+)") {
+                $major = [int]$matches[1]
+                $minor = [int]$matches[2]
+                if ($major -gt 3 -or ($major -eq 3 -and $minor -ge 10)) {
+                    $PYTHON = $py
+                    $pyVersion = "$major.$minor"
+                    break
+                }
+            }
+        }
+    }
+    
+    if (-not $PYTHON) {
         Write-Host "  Python 3.10+ is required. Install from https://python.org/downloads" -ForegroundColor Red
         exit 1
     }
+    $script:PYTHON = $PYTHON
+    Write-Host "  Python $pyVersion found" -ForegroundColor Green
     
     # Check pip
-    if (python -m pip --version -ErrorAction SilentlyContinue) {
+    if (& $PYTHON -m pip --version -ErrorAction SilentlyContinue) {
         Write-Host "  pip found" -ForegroundColor Green
     } else {
-        Write-Host "  pip not found. Run: python -m ensurepip --upgrade" -ForegroundColor Red
+        Write-Host "  pip not found. Run: $PYTHON -m ensurepip --upgrade" -ForegroundColor Red
         exit 1
     }
     
@@ -44,6 +67,29 @@ function Check-Requirements {
     }
 }
 
+function New-VirtualEnvironment {
+    Write-Host "Ensuring isolated Python environment..." -ForegroundColor Cyan
+    New-Item -ItemType Directory -Force -Path $INSTALL_DIR | Out-Null
+    if (Test-Path $VENV_DIR) {
+        Remove-Item -Recurse -Force $VENV_DIR
+    }
+    & $script:PYTHON -m venv $VENV_DIR
+    & "$VENV_DIR\Scripts\python.exe" -m pip install --upgrade pip setuptools wheel
+    Write-Host "  Virtual environment ready" -ForegroundColor Green
+}
+
+function Add-ToPath {
+    $venvScripts = "$VENV_DIR\Scripts"
+    $currentPath = [Environment]::GetEnvironmentVariable("Path", "User")
+    if ($currentPath -notlike "*$venvScripts*") {
+        [Environment]::SetEnvironmentVariable("Path", "$venvScripts;$currentPath", "User")
+        Write-Host "  Added $venvScripts to user PATH" -ForegroundColor Green
+        Write-Host "  Restart your terminal for PATH changes to take effect." -ForegroundColor Yellow
+    }
+    # Also add to current process PATH so the rest of the script can use it
+    $env:Path = "$venvScripts;$env:Path"
+}
+
 function Install-FromGitHub {
     Write-Host "Installing from GitHub..." -ForegroundColor Cyan
     
@@ -55,14 +101,17 @@ function Install-FromGitHub {
     git clone --depth 1 "https://github.com/$REPO.git" $INSTALL_DIR
     Write-Host "  Cloned to $INSTALL_DIR" -ForegroundColor Green
     
-    Set-Location $INSTALL_DIR
-    python -m pip install --upgrade --user -e .
+    New-VirtualEnvironment
+    & "$VENV_DIR\Scripts\pip.exe" install --upgrade -e $INSTALL_DIR
+    Add-ToPath
     Write-Host "  Package installed" -ForegroundColor Green
 }
 
 function Install-PipGit {
     Write-Host "Installing directly from GitHub (pip)..." -ForegroundColor Cyan
-    python -m pip install --upgrade --user "git+https://github.com/$REPO.git"
+    New-VirtualEnvironment
+    & "$VENV_DIR\Scripts\pip.exe" install --upgrade "git+https://github.com/$REPO.git"
+    Add-ToPath
     Write-Host "  Installed from GitHub" -ForegroundColor Green
 }
 
@@ -83,10 +132,86 @@ function Show-Welcome {
     Write-Host "  /mcp       # List available tools"
     Write-Host "  /skills    # List installed skills"
     Write-Host ""
+    if ($Yes) {
+        Write-Host "Install with auto CLAUDE.md support:" -ForegroundColor Cyan
+        Write-Host "  iwr -useb .../install.ps1 | & ([scriptblock]::create(`$_)) -Yes"
+        Write-Host ""
+    }
+    if ($WithObsidian) {
+        Write-Host "Install with Obsidian local memory:" -ForegroundColor Cyan
+        Write-Host "  iwr -useb .../install.ps1 | & ([scriptblock]::create(`$_)) -Yes -WithObsidian"
+        Write-Host ""
+    }
+}
+
+function Apply-ClaudeCompat {
+    Write-Host "Applying claude-compat patch (auto-load CLAUDE.md and CLAUDE.local.md)..." -ForegroundColor Cyan
+    $kimi = Get-Command kimi-mcp-hub -ErrorAction SilentlyContinue
+    if ($kimi) {
+        & kimi-mcp-hub claude-compat --yes
+    } else {
+        Write-Host "  kimi-mcp-hub not found in PATH. Skipping claude-compat patch." -ForegroundColor Yellow
+        Write-Host "  Run manually after adding it to PATH: kimi-mcp-hub claude-compat --yes" -ForegroundColor Gray
+    }
+}
+
+function Setup-ObsidianMcp {
+    Write-Host "Setting up Obsidian as local memory..." -ForegroundColor Cyan
+    
+    if (-not $Yes -and [console]::IsInputRedirected -eq $false) {
+        $inputVault = Read-Host "Obsidian vault path [$ObsidianVault]"
+        if ($inputVault) { $ObsidianVault = $inputVault }
+    }
+    
+    New-Item -ItemType Directory -Force -Path "$ObsidianVault\.obsidian" | Out-Null
+
+    # obsidian-mcp requires at least app.json to consider this a valid vault
+    if (-not (Test-Path "$ObsidianVault\.obsidian\app.json")) {
+        '{}' | Set-Content -Path "$ObsidianVault\.obsidian\app.json" -Encoding UTF8
+    }
+
+    if (-not (Test-Path "$ObsidianVault\README.md")) {
+        @"
+# Kimi Memory Vault
+
+This vault is used by Kimi CLI as local memory.
+
+- Notes created by Kimi are stored here.
+- Open this folder in Obsidian to browse and edit.
+- Source: https://obsidian.md
+"@ | Set-Content -Path "$ObsidianVault\README.md" -Encoding UTF8
+    }
+    
+    $mcpJson = "$env:USERPROFILE\.kimi-code\mcp.json"
+    New-Item -ItemType Directory -Force -Path (Split-Path $mcpJson) | Out-Null
+    $data = @{ mcpServers = @{} }
+    if (Test-Path $mcpJson) {
+        try {
+            $data = Get-Content $mcpJson -Raw | ConvertFrom-Json -AsHashtable
+        } catch {
+            $data = @{ mcpServers = @{} }
+        }
+    }
+    if (-not $data.ContainsKey("mcpServers")) { $data["mcpServers"] = @{} }
+    $data["mcpServers"]["obsidian"] = @{
+        command = "npx"
+        args = @("-y", "obsidian-mcp", $ObsidianVault)
+        env = @{}
+    }
+    $data | ConvertTo-Json -Depth 10 | Set-Content -Path $mcpJson -Encoding UTF8
+    
+    Write-Host "  Obsidian vault ready: $ObsidianVault" -ForegroundColor Green
+    Write-Host "  Install Obsidian from https://obsidian.md and open this vault." -ForegroundColor Gray
 }
 
 # Main
 Write-Header
 Check-Requirements
 Install-PipGit
+if ($Yes) {
+    Apply-ClaudeCompat
+}
+if ($WithObsidian) {
+    Setup-ObsidianMcp
+}
 Show-Welcome

package/install/install.sh

@@ -1,12 +1,15 @@
 #!/usr/bin/env bash
 # Kimi MCP Hub - One-line installer
 # Usage: curl -fsSL https://raw.githubusercontent.com/KalimeroMK/kimi-mcp-hub/main/install/install.sh | bash
+# Usage with Obsidian: curl -fsSL .../install.sh | bash -s -- --with-obsidian
 
 set -e
 
 REPO="KalimeroMK/kimi-mcp-hub"
 INSTALL_DIR="${KIMI_MCP_HUB_DIR:-$HOME/.kimi-mcp-hub}"
+VENV_DIR="$INSTALL_DIR/.venv"
 BIN_DIR="${KIMI_MCP_HUB_BIN:-$HOME/.local/bin}"
+DEFAULT_VAULT="$HOME/Documents/Kimi-Memory"
 
 # Colors
 RED='\033[0;31m'
@@ -19,7 +22,7 @@ NC='\033[0m'
 print_header() {
     echo ""
     echo -e "${CYAN}  KIMI MCP HUB${NC} - One-click MCP server & skills manager"
-    echo -e "${DIM}  23 MCP Servers | 34 AI Skills | Persistent Memory${NC}"
+    echo -e "${DIM}  24 MCP Servers | 57 AI Skills | Persistent Memory${NC}"
     echo ""
 }
 
@@ -42,18 +45,27 @@ print_error() {
 check_requirements() {
     print_info "Checking requirements..."
     
-    # Check Python
-    if command -v python3 &>/dev/null; then
-        PYTHON="python3"
-    elif command -v python &>/dev/null; then
-        PYTHON="python"
-    else
+    # Check Python (prefer 3.10+ specifically)
+    PYTHON=""
+    for py in python3.13 python3.12 python3.11 python3.10 python3 python; do
+        if command -v "$py" &>/dev/null; then
+            ver=$($py --version 2>&1 | cut -d' ' -f2)
+            major=$(echo "$ver" | cut -d'.' -f1)
+            minor=$(echo "$ver" | cut -d'.' -f2)
+            if [ "$major" -gt 3 ] || { [ "$major" -eq 3 ] && [ "$minor" -ge 10 ]; }; then
+                PYTHON="$py"
+                PYTHON_VERSION="$ver"
+                break
+            fi
+        fi
+    done
+    
+    if [ -z "$PYTHON" ]; then
         print_error "Python 3.10+ is required but not found."
         echo "   Install from: https://python.org/downloads"
         exit 1
     fi
     
-    PYTHON_VERSION=$($PYTHON --version 2>&1 | cut -d' ' -f2)
     print_success "Python $PYTHON_VERSION found"
     
     # Check pip
@@ -119,9 +131,31 @@ add_to_path() {
     fi
 }
 
+create_venv() {
+    print_info "Ensuring isolated Python environment..."
+    mkdir -p "$INSTALL_DIR"
+    if [ ! -d "$VENV_DIR/bin" ]; then
+        $PYTHON -m venv "$VENV_DIR"
+    fi
+    "$VENV_DIR/bin/pip" install --upgrade pip setuptools wheel
+    print_success "Virtual environment ready"
+}
+
+link_binaries() {
+    mkdir -p "$BIN_DIR"
+    if [ -f "$VENV_DIR/bin/kimi-mcp-hub" ]; then
+        ln -sf "$VENV_DIR/bin/kimi-mcp-hub" "$BIN_DIR/kimi-mcp-hub"
+    fi
+    if [ -f "$VENV_DIR/bin/kmcp" ]; then
+        ln -sf "$VENV_DIR/bin/kmcp" "$BIN_DIR/kmcp"
+    fi
+}
+
 install_from_pypi() {
     print_info "Installing kimi-mcp-hub from PyPI..."
-    $PYTHON -m pip install --upgrade --user kimi-mcp-hub
+    create_venv
+    "$VENV_DIR/bin/pip" install --upgrade kimi-mcp-hub
+    link_binaries
     print_success "Installed from PyPI"
 }
 
@@ -137,31 +171,30 @@ install_from_github() {
     print_success "Cloned to $INSTALL_DIR"
     
     print_info "Installing package..."
-    cd "$INSTALL_DIR"
-    $PYTHON -m pip install --upgrade --user -e .
+    create_venv
+    "$VENV_DIR/bin/pip" install --upgrade -e "$INSTALL_DIR"
+    link_binaries
     print_success "Package installed"
 }
 
 install_pip_git() {
     print_info "Installing directly from GitHub (pip)..."
-    $PYTHON -m pip install --upgrade --user "git+https://github.com/$REPO.git"
+    create_venv
+    "$VENV_DIR/bin/pip" install --upgrade "git+https://github.com/$REPO.git"
+    link_binaries
     print_success "Installed from GitHub"
 }
 
 post_install() {
     print_info "Running post-install setup..."
     
-    # Ensure bin directory exists
-    mkdir -p "$BIN_DIR"
+    # Ensure binaries are linked
+    link_binaries
     
     # Check if kimi-mcp-hub is in PATH
     if ! command -v kimi-mcp-hub &>/dev/null; then
-        # Try to find the installed script
-        USER_BASE=$($PYTHON -m site --user-base 2>/dev/null || echo "$HOME/.local")
-        SCRIPT_DIR="$USER_BASE/bin"
-        
-        if [ -f "$SCRIPT_DIR/kimi-mcp-hub" ]; then
-            print_info "Found kimi-mcp-hub at $SCRIPT_DIR"
+        if [ -f "$BIN_DIR/kimi-mcp-hub" ]; then
+            print_info "Found kimi-mcp-hub at $BIN_DIR"
             add_to_path
         fi
     fi
@@ -172,6 +205,63 @@ post_install() {
     print_success "Setup complete"
 }
 
+setup_obsidian_mcp() {
+    print_info "Setting up Obsidian as local memory..."
+    
+    local vault_path="${OBSIDIAN_VAULT:-$DEFAULT_VAULT}"
+    
+    if [ "$AUTO_YES" = false ] && [ -t 0 ]; then
+        read -rp "Obsidian vault path [$vault_path]: " input
+        [ -n "$input" ] && vault_path="$input"
+    fi
+    
+    vault_path="$(eval echo "$vault_path")"
+    mkdir -p "$vault_path/.obsidian"
+
+    # obsidian-mcp requires at least app.json to consider this a valid vault
+    if [ ! -f "$vault_path/.obsidian/app.json" ]; then
+        echo '{}' > "$vault_path/.obsidian/app.json"
+    fi
+
+    if [ ! -f "$vault_path/README.md" ]; then
+        cat > "$vault_path/README.md" << 'EOF'
+# Kimi Memory Vault
+
+This vault is used by Kimi CLI as local memory.
+
+- Notes created by Kimi are stored here.
+- Open this folder in Obsidian to browse and edit.
+- Source: https://obsidian.md
+EOF
+    fi
+    
+    # Add Obsidian MCP server to mcp.json via Python
+    "$VENV_DIR/bin/python" - << PY
+import json
+from pathlib import Path
+
+mcp_json = Path.home() / ".kimi-code" / "mcp.json"
+mcp_json.parent.mkdir(parents=True, exist_ok=True)
+data = {"mcpServers": {}}
+if mcp_json.exists():
+    try:
+        data = json.loads(mcp_json.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        pass
+data.setdefault("mcpServers", {})
+data["mcpServers"]["obsidian"] = {
+    "command": "npx",
+    "args": ["-y", "obsidian-mcp", "$vault_path"],
+    "env": {}
+}
+mcp_json.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+print("Obsidian MCP server configured")
+PY
+    
+    print_success "Obsidian vault ready: $vault_path"
+    print_info "Install Obsidian from https://obsidian.md and open this vault."
+}
+
 show_welcome() {
     echo ""
     echo -e "${GREEN}╔══════════════════════════════════════════════════════════╗${NC}"
@@ -192,6 +282,12 @@ show_welcome() {
     echo "  /mcp       # List available tools"
     echo "  /skills    # List installed skills"
     echo ""
+    echo -e "${CYAN}Install with auto CLAUDE.md support:${NC}"
+    echo "  curl -fsSL .../install.sh | bash -s -- -y"
+    echo ""
+    echo -e "${CYAN}Install with Obsidian local memory:${NC}"
+    echo "  curl -fsSL .../install.sh | bash -s -- --with-obsidian"
+    echo ""
     echo -e "${DIM}Need help? Run: kimi-mcp-hub --help${NC}"
     echo ""
 }
@@ -201,7 +297,35 @@ main() {
     check_requirements
     
     # Parse arguments
-    METHOD="${1:-auto}"
+    AUTO_YES=false
+    WITH_OBSIDIAN=false
+    OBSIDIAN_VAULT="$DEFAULT_VAULT"
+    METHOD="auto"
+    
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            -y|--yes)
+                AUTO_YES=true
+                shift
+                ;;
+            --with-obsidian)
+                WITH_OBSIDIAN=true
+                shift
+                ;;
+            --obsidian-vault)
+                OBSIDIAN_VAULT="$2"
+                shift 2
+                ;;
+            --pip|--clone|--pypi|pip|clone|pypi)
+                METHOD="$1"
+                shift
+                ;;
+            *)
+                print_warning "Unknown argument: $1"
+                shift
+                ;;
+        esac
+    done
     
     case "$METHOD" in
         --pip|pip)
@@ -215,7 +339,8 @@ main() {
             ;;
         *)
             # Try PyPI first, fallback to pip+git
-            if $PYTHON -m pip install --dry-run kimi-mcp-hub &>/dev/null 2>&1; then
+            create_venv
+            if "$VENV_DIR/bin/pip" install --dry-run kimi-mcp-hub &>/dev/null 2>&1; then
                 install_from_pypi
             else
                 print_info "PyPI package not found, installing from GitHub..."
@@ -225,6 +350,23 @@ main() {
     esac
     
     post_install
+    
+    # Auto-apply claude-compat patch when -y is passed
+    if [ "$AUTO_YES" = true ]; then
+        if command -v kimi-mcp-hub &>/dev/null; then
+            print_info "Applying claude-compat patch (auto-load CLAUDE.md and CLAUDE.local.md)..."
+            kimi-mcp-hub claude-compat --yes
+        else
+            print_warning "kimi-mcp-hub not found in PATH. Skipping claude-compat patch."
+            print_info "Run manually after adding it to PATH: kimi-mcp-hub claude-compat --yes"
+        fi
+    fi
+    
+    # Setup Obsidian MCP server
+    if [ "$WITH_OBSIDIAN" = true ]; then
+        OBSIDIAN_VAULT="$OBSIDIAN_VAULT" setup_obsidian_mcp
+    fi
+    
     show_welcome
 }
 

package/install/npm-wrapper.js

@@ -11,7 +11,7 @@ const REPO = "KalimeroMK/kimi-mcp-hub";
 const PYPI_NAME = "kimi-mcp-hub";
 const PYTHON_MODULE = "kimi_mcp_hub";
 const INSTALL_DIR = path.join(os.homedir(), ".kimi-mcp-hub");
-const VENV_DIR = process.env.KIMI_MCP_HUB_VENV || path.join(INSTALL_DIR, "venv");
+const VENV_DIR = process.env.KIMI_MCP_HUB_VENV || path.join(INSTALL_DIR, ".venv");
 const LOCAL_REPO_DIR = path.resolve(path.join(__dirname, ".."));
 
 function log(...args) {
@@ -104,7 +104,7 @@ function installPackage(python) {
   // Prefer PyPI when the package is published and not running from a local repo.
   let installArgs;
   if (installSpec === LOCAL_REPO_DIR) {
-    installArgs = ["-m", "pip", "install", "--upgrade", installSpec];
+    installArgs = ["-m", "pip", "install", "--no-cache-dir", "--force-reinstall", "--upgrade", installSpec];
   } else {
     const pypiDry = spawnSync(
       venvPy,
@@ -113,8 +113,8 @@ function installPackage(python) {
     );
     installArgs =
       pypiDry.status === 0
-        ? ["-m", "pip", "install", "--upgrade", PYPI_NAME]
-        : ["-m", "pip", "install", "--upgrade", installSpec];
+        ? ["-m", "pip", "install", "--no-cache-dir", "--force-reinstall", "--upgrade", PYPI_NAME]
+        : ["-m", "pip", "install", "--no-cache-dir", "--force-reinstall", "--upgrade", installSpec];
   }
 
   const installResult = run(venvPy, installArgs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kimi-mcp-hub",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "One-click MCP server and skills manager for Kimi CLI",
   "main": "install/npm-wrapper.js",
   "bin": {