# Vibe Coding Mcp

> Auto-document vibe coding sessions - collect, summarize, and publish

- **Type:** MCP server
- **Install:** `agentstack add mcp-muse-code-space-vibe-coding-mcp`
- **Verified:** Pending review
- **Seller:** [MUSE-CODE-SPACE](https://agentstack.voostack.com/s/muse-code-space)
- **Installs:** 0
- **Latest version:** 2.12.1
- **License:** MIT
- **Upstream author:** [MUSE-CODE-SPACE](https://github.com/MUSE-CODE-SPACE)
- **Source:** https://github.com/MUSE-CODE-SPACE/vibe-coding-mcp

## Install

```sh
agentstack add mcp-muse-code-space-vibe-coding-mcp
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# vibe-coding-mcp

> Auto-documents your AI coding sessions — wire it as a Claude Code hook and your daily README / design-decision log / refactor-PR description writes itself.

[](https://github.com/MUSE-CODE-SPACE/vibe-coding-mcp/actions/workflows/ci.yml)
[](https://www.npmjs.com/package/vibe-coding-mcp)
[](https://opensource.org/licenses/MIT)

[English](#english) · [한국어](#한국어)

---

## Why vibe-coding?

You spent four hours pair-programming with Claude. You made three architectural decisions, wrote eight files, and reverted twice. Tomorrow you will not remember why you picked the second option in commit `a1b2c3d` over the first one you tried. Most people solve this with manual journaling that lasts two weeks, or by trawling `git log` after the fact.

vibe-coding-mcp solves it differently: it sits as an MCP server next to your editor, **collects code blocks and design decisions out of the conversation**, generates **README / DESIGN / API / ARCHITECTURE** documents from them, and **publishes to Notion / GitHub Wiki / Obsidian / Confluence / Slack / Discord** — all from inside the chat with Claude. Wire it as a Claude Code `PostToolUse` + `Stop` hook (one block of JSON, see [Quickstart](#5-minute-quickstart)) and every session auto-captures into `~/.vibe-coding-mcp/sessions/` without you typing anything. The bundled `daily-vibe-log` prompt then rolls today's captures into one document.

The Phase 3 refactor (v2.14.0, May 2026) collapsed the two-entry-point drift (`index.ts` had 7 tools, `stdio.ts` had 15) into a **single transport-agnostic registry**, so HTTP and stdio now expose the same 15 tools, 3 resources, and 3 prompts.

## What's new in v2.14.0

- **One registry, two entry points, zero drift.** `src/core/toolRegistry.ts` is the single source of truth — both `index.ts` (Streamable HTTP) and `stdio.ts` (bin) load the same 15 tools, 3 resources, and 3 prompts.
- **Migrated to high-level `McpServer` API** (SDK 1.25+). `McpServer.registerTool() / .resource() / .prompt()` instead of low-level `setRequestHandler(CallToolRequestSchema)`. Adding a tool is now a one-line `register()` call.
- **Streamable HTTP (MCP 2025-03-26), not SSE.** `POST /mcp` at `:3000`. The legacy `/sse` route returns HTTP 410 with a pointer.
- **3 new MCP Resources for `@-mention`.** `vibe-coding://sessions/list` (captured sessions), `vibe-coding://sessions/{id}` (one session in full), `vibe-coding://config` (current platform creds).
- **3 new MCP Prompts.** `daily-vibe-log` (roll today's sessions into one doc), `document-session` (one session → README/DESIGN/API/etc. → publish), `refactor-context` (session → PR description with decisions + AST analysis + git diff).
- **+34 tests** (149 → 183 passing) covering the registry, resources, prompts, and the McpServer factory.

## 5-minute Quickstart

```bash
# 1. Install via Claude Code
claude mcp add vibe-coding-mcp -- npx -y vibe-coding-mcp
```

2. Wire it as a Claude Code hook so every session auto-captures. Add this to `~/.claude/settings.json`:

```jsonc
{
  "mcpServers": {
    "vibe-coding-mcp": {
      "command": "npx",
      "args": ["-y", "vibe-coding-mcp"]
    }
  },
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write|NotebookEdit",
        "hooks": [{
          "type": "command",
          "command": "claude mcp call vibe-coding-mcp muse_session_history '{\"action\":\"save\",\"title\":\"auto-capture\",\"summary\":\"PostToolUse\",\"tags\":[\"auto-capture\"]}' >/dev/null 2>&1 || true"
        }]
      }
    ],
    "Stop": [
      {
        "hooks": [{
          "type": "command",
          "command": "claude mcp call vibe-coding-mcp muse_create_session_log '{\"title\":\"Claude Code session\",\"summary\":\"Stop hook\",\"options\":{\"logType\":\"session\"}}' >/dev/null 2>&1 || true"
        }]
      }
    ]
  }
}
```

3. Restart Claude Code. The next time you edit a file in a session, capture starts.
4. After a session, try this in Claude:

```
오늘 캡처된 세션들 합쳐서 daily vibe log 만들어줘. (use the /daily-vibe-log prompt)
```

5. Expected: Claude calls `muse_session_history(action='list', filterTags=['auto-capture'])` to gather today's sessions, then `muse_create_session_log` to compose, then offers to publish to Notion / Obsidian / GitHub Wiki. See [`docs/AUTO_CAPTURE.md`](./docs/AUTO_CAPTURE.md) for hook customization (e.g. piping `git diff --stat` into the capture payload).

## Real use cases

### 1. "I want today's coding session as a daily log without lifting a finger"
**Problem:** You'll never sit down at the end of the day and write a journal entry. Nobody does.
**With this MCP:** the `PostToolUse` + `Stop` hooks save sessions automatically into `~/.vibe-coding-mcp/sessions/`. Next morning, run the `/daily-vibe-log` prompt and Claude reads `vibe-coding://sessions/list` for today, compiles a Markdown log (problems, decisions, code blocks, blockers), and offers to publish to Notion.
**Why it's better than git log or Notion templates:** git log knows *what* you committed, not *why* you picked option B over option A. The session capture preserves the conversation context that the diff doesn't.

### 2. "I need a PR description for a refactor that touched 11 files"
**Problem:** Writing a good PR description for a refactor takes 15 minutes of re-reading the diff. Most refactor PRs end up with a one-liner and reviewers hate it.
**With this MCP:** invoke the `/refactor-context` prompt against the session you just finished. The prompt chains `muse_session_history(get)` → `muse_summarize_design_decisions` → `muse_analyze_code` (AST + Mermaid diagram) → `muse_git(diff)` and outputs a structured PR description with: *Why* (decisions), *What changed* (file-by-file from AST), *Trade-offs* (decisions section), and *How to review* (diagram of new architecture).
**Why it's better than asking Claude to "write a PR description":** the prompt explicitly pulls the **design-decision summary** out of the session, not just the diff — reviewers get the why, not a paraphrased diff.

### 3. "I want my Obsidian vault to fill itself with my design decisions"
**Problem:** You make architectural decisions during pair-programming and they evaporate. ADR templates require manual discipline you don't have.
**With this MCP:** call `muse_summarize_design_decisions` over your session, then `muse_publish_document({ platform: 'obsidian', vault: '~/MyVault/decisions' })`. The Obsidian platform writer adds YAML frontmatter (tags, date, session-id back-reference), so the new note shows up correctly in your vault graph view.
**Why it's better than a `Notes/ADR-template.md`:** the decision text is generated from the actual code+conversation, not from your tired post-session memory. And it works across **6 platforms** (Notion, GitHub Wiki, Obsidian, Confluence, Slack, Discord) with one tool call.

## Tools / Resources / Prompts

| Name | Type | What it does |
|------|------|--------------|
| `muse_collect_code_context` | tool | Pull code blocks + conversation summary out of a chat into a structured session |
| `muse_summarize_design_decisions` | tool | Extract architectural / design decisions (problem → options → choice → trade-off) |
| `muse_analyze_code` | tool | AST analysis (TypeScript / Python / Go) + Mermaid diagrams (Class / Flow / Sequence / ER / Architecture) |
| `muse_generate_dev_document` | tool | README / DESIGN / TUTORIAL / CHANGELOG / API / ARCHITECTURE generator |
| `muse_normalize_for_platform` | tool | Markdown normalization for Notion / GitHub Wiki / Obsidian / Confluence / Slack / Discord quirks |
| `muse_publish_document` | tool | Publish to any of the 6 supported platforms |
| `muse_create_session_log` | tool | Daily or per-session log composition |
| `muse_session_history` | tool | `save / get / update / delete / list / search / stats` over `~/.vibe-coding-mcp/sessions/` |
| `muse_export_session` | tool | Export one session to Markdown / JSON / HTML |
| `muse_project_profile` | tool | Per-project settings (default platform, default tags, language) |
| `muse_git` | tool | `status / log / diff / branch / snapshot` + design-decision extraction from commit messages |
| `muse_session_stats` | tool | Productivity dashboard: sessions/day, decisions/session, language breakdown |
| `muse_auto_tag` | tool | AI tag suggestions for a session (Claude API, optional) |
| `muse_template` | tool | Custom doc templates (per project / per output type) |
| `muse_batch` | tool | Compose multiple tool calls sequentially or in parallel in one round-trip |
| `vibe-coding://sessions/list` | resource | List of captured sessions (`@-mention`-able) |
| `vibe-coding://sessions/{id}` | resource | One session's full body, code blocks, decisions, tags |
| `vibe-coding://config` | resource | Current platform configuration (which integrations are wired) |
| `prompt://vibe-coding/daily-vibe-log` | prompt | Roll today's captured sessions into one daily log |
| `prompt://vibe-coding/document-session` | prompt | One session → dev document → publish |
| `prompt://vibe-coding/refactor-context` | prompt | Session → PR description with decisions + AST + git diff |

## How it works

```
                      Claude (or any MCP client)
                                │
       ┌────────────────────────┴────────────────────────┐
       ▼                                                  ▼
  src/index.ts (Streamable HTTP, POST /mcp at :3000)   src/stdio.ts (bin)
       │                                                  │
       └────────────────────────┬─────────────────────────┘
                                ▼
                  src/core/mcpServerFactory.ts
                                │
              ┌─────────────────┼─────────────────┐
              ▼                 ▼                 ▼
         toolRegistry.ts   resources.ts      prompts.ts
         (15 muse_* tools) (3 resources)     (3 prompts)
              │
              ▼
              src/tools/*.ts (15 tool implementations)
                            │
                            ▼
              src/core/sessionStorage.ts (~/.vibe-coding-mcp/sessions/)
              src/platforms/*.ts (notion / github-wiki / obsidian / ...)
```

Three design choices that matter:
1. **Single registry, two transports.** HTTP and stdio both call `createMcpServer()` from `mcpServerFactory.ts`. There's no "stdio has feature X that HTTP doesn't" — the v2.13.0 drift is closed.
2. **Sessions are local files.** `~/.vibe-coding-mcp/sessions/.json` — no remote DB, no telemetry, you own the data. Trivial to back up, grep, or sync via Dropbox.
3. **Publishing is per-platform, not one-size-fits-all.** Notion expects blocks, GitHub Wiki expects sidebar markdown, Obsidian expects frontmatter — `muse_normalize_for_platform` handles each one's quirks so `muse_publish_document` can stay a single tool.

## Configuration

| Env var | Required for | Default | Purpose |
|---------|--------------|---------|---------|
| `ANTHROPIC_API_KEY` | `muse_auto_tag`, AI summarization | — | Optional. Enables Claude-API-powered analysis |
| `NOTION_API_KEY` + `NOTION_DATABASE_ID` | Notion publishing | — | Notion integration |
| `GITHUB_TOKEN` + `GITHUB_REPO` | GitHub Wiki publishing | — | Wiki push uses git over HTTPS |
| `CONFLUENCE_BASE_URL` + `CONFLUENCE_USERNAME` + `CONFLUENCE_API_TOKEN` | Confluence | — | Atlassian Cloud |
| `SLACK_WEBHOOK_URL` | Slack | — | Webhook URL |
| `DISCORD_WEBHOOK_URL` | Discord | — | Webhook URL |
| `PORT` | HTTP mode only | `3000` | Streamable HTTP bind port |

All env vars are optional. The MCP boots with zero env vars set — tools that require an integration return a structured `INTEGRATION_NOT_CONFIGURED` error instead of crashing.

## Known limitations

- **Capture is hook-driven.** The MCP itself doesn't sniff your editor — it relies on Claude Code calling it (via the `PostToolUse` / `Stop` hooks shown in Quickstart). Without hooks, you have to call `muse_session_history` manually.
- **No shared session store yet.** Sessions are local. Two laptops = two session histories. Cross-device sync is on the roadmap.
- **AST analysis covers TS / Python / Go.** Rust, Swift, Kotlin, Ruby AST support is not in v2.x.
- **Publishing is one-way.** We can write to Notion / Wiki / Obsidian etc. but we don't pull updates back into the session store.

## When NOT to use this

- If you want **automatic git commit messages**, use [aicommits](https://github.com/Nutlope/aicommits) or similar — vibe-coding-mcp generates *documents*, not commit messages.
- If you want **team-wide knowledge base search across everyone's sessions**, this MCP is single-user/local. Build a Notion DB on top and search there, or wait for the shared-store roadmap item.
- If you want a **manual journaling tool with rich editing**, use Obsidian / Notion directly — this MCP is for the auto-capture-then-publish flow, not for hand-writing notes.

## Comparison

| | vibe-coding-mcp | Manual journaling | `git log` | Notion ADR template |
|---|---|---|---|---|
| Captures *why* (decisions), not just *what* | yes | yes (if you do it) | no | yes (if you do it) |
| Survives skipping a day | yes (hooks) | no | n/a | no |
| Code-block + AST analysis | yes | no | no | no |
| Auto-publishes to 6 platforms | yes | no | no | Notion only |
| Local-first session store | yes (`~/.vibe-coding-mcp/`) | varies | local | cloud |
| Per-platform Markdown quirks handled | yes | no | n/a | n/a |

## Roadmap

- **Shared session store.** Opt-in cross-device sync (S3 / Git / WebDAV) and team mode where multiple users can search each other's captured sessions.
- **Auto-summary by topic.** Group sessions by topic across weeks ("everything I did on the auth refactor in Q2") instead of by day.
- **Git commit-message integration.** Surface `muse_summarize_design_decisions` output as a prepare-commit-msg suggestion.
- **Wider AST language support.** Rust + Swift + Kotlin AST + Mermaid diagrams.
- **Resource for cross-session search.** `vibe-coding://search?q=...` so the LLM can `@-mention` "all sessions about caching" in one go.

## Contributing

PRs welcome. Adding a tool is now a single-file change in `src/tools/.ts` + a one-line `register()` in `src/core/toolRegistry.ts`. CI runs `typecheck + build + test` on Node 20 against every PR.

Quick contributor loop:

```bash
git clone https://github.com/MUSE-CODE-SPACE/vibe-coding-mcp
cd vibe-coding-mcp
npm install
npm run typecheck && npm test && npm run build
```

## Security

This package validates paths, sanitizes filenames, enforces HTTPS-only + allowlisted hosts for webhook URLs, and wraps outbound HTTP with a timeout + exponential-backoff retry — see [`src/core/security.ts`](./src/core/security.ts). The threat model, supported versions, and vulnerability reporting process are in [`SECURITY.md`](./SECURITY.md). CodeQL with the `security-and-quality` query pack runs on every push and weekly.

**Report vulnerabilities privately** via a GitHub Security Advisory: .

## License

MIT — SPDX identifier declared in [`package.json`](./package.json) (a top-level `LICENSE` file will be added in the next release).

## Maintainer

[@yoon-k](https://github.com/MUSE-CODE-SPACE) (MUSE-CODE-SPACE). Issues + support: .

---

## 한국어 요약

vibe-coding-mcp는 Claude(또는 다른 MCP 클라이언트)와 함께 **AI 페어 코딩 세션을 자동으로 문서화**해 주는 MCP 서버입니다. Claude Code의 `PostToolUse` + `Stop` 훅에 연결하면 매 세션이 `~/.vibe-coding-mcp/sessions/` 에 자동 저장되고, **15개 도구**가 거기서 **README / DESIGN / API / ARCHITECTURE / CHANGELOG / TUTORIAL** 6종 문서를 생성한 뒤 **Notion / GitHub Wiki / Obsidian / Confluence / Slack / Discord** 6개 플랫폼에 발행합니다.

v2.14.0(2026-05-20)에서 HTTP/stdio 두 진입점이 **단일 레지스트리** 를 공유하도록 통합되었고, `@-mention` 가능한 **MCP Resources 3개**(`sessions/list`, `sessions/{id}`, `config`)와 **Prompts 3개**(`daily-vibe-log`, `document-session`, `refactor-context`)가 추가되었습니다.

설치 + 자동 캡처 훅 설정은 [`docs/AUTO_CAPTURE.md`](./docs/AUTO_CAPTURE.md) 참고. 변경 이력은 [`CHANGELOG.md`](./CHANGELOG.md), 위협 모델은 [`SECURITY.md`](./SECURITY.md).

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [MUSE-CODE-SPACE](https://github.com/MUSE-CODE-SPACE)
- **Source:** [MUSE-CODE-SPACE/vibe-coding-mcp](https://github.com/MUSE-CODE-SPACE/vibe-coding-mcp)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Versions

- **2.12.1** — security scan: pending review — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-muse-code-space-vibe-coding-mcp
- Seller: https://agentstack.voostack.com/s/muse-code-space
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.