vibe-coding-mcp 2.12.0 → 2.14.0

package/CHANGELOG.md

@@ -0,0 +1,74 @@
+# Changelog
+
+All notable changes to `vibe-coding-mcp` are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versioning follows [SemVer](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+- Shared session store (opt-in S3 / Git / WebDAV sync; team mode).
+- Auto-summary by topic across weeks instead of by day.
+- Wider AST language support (Rust / Swift / Kotlin) + diagrams.
+- `vibe-coding://search?q=...` resource for cross-session search.
+- Git `prepare-commit-msg` integration surfacing decision summaries.
+
+## [2.14.0] - 2026-05-20
+
+### Highlights ⭐
+- **HTTP and stdio expose the same surface now.** v2.13.0's "stdio has 15 tools, HTTP has 7" drift is gone — both entry points go through `src/core/mcpServerFactory.ts` and `src/core/toolRegistry.ts`. **15 tools, 3 resources, 3 prompts** everywhere.
+- **One slash command publishes a full daily log.** `/daily-vibe-log` reads `vibe-coding://sessions/list`, composes a session log, offers to publish to Notion / Obsidian / GitHub Wiki — no manual tool chaining required.
+- **`/refactor-context` writes your PR description.** Pulls the design-decision summary out of the captured session and produces a structured "why / what / trade-offs / how to review" PR body, not a paraphrased diff.
+- **Streamable HTTP (MCP 2025-03-26).** `/sse` is retired (HTTP 410 with pointer); `POST /mcp` is the new endpoint.
+
+### Added
+- **MCP Resources (3):**
+  - `vibe-coding://sessions/list` — list of captured sessions.
+  - `vibe-coding://sessions/{id}` — full session detail (resource template).
+  - `vibe-coding://config` — current platform configuration.
+- **MCP Prompts (3):**
+  - `daily-vibe-log` — assemble today's captured sessions into a daily log.
+  - `document-session` — fetch a session, extract decisions, generate a dev document, optionally publish.
+  - `refactor-context` — produce a refactor-ready PR description from a session (decisions + AST + git diff).
+- **Auto-capture hook guide** — [`docs/AUTO_CAPTURE.md`](./docs/AUTO_CAPTURE.md) documents how to wire `PostToolUse` / `Stop` hooks in `~/.claude/settings.json` so Claude Code sessions auto-capture into `muse_session_history`.
+- **+34 tests** covering the tool registry, resources, prompts, and the McpServer factory (149 → 183 passing).
+
+### Changed
+- **Entry-point unification.** `src/index.ts` (HTTP) and `src/stdio.ts` (bin) now both consume a single shared registry (`src/core/toolRegistry.ts`) and the new `src/core/mcpServerFactory.ts`. Same 15 tools / 3 resources / 3 prompts on both transports.
+- **High-level `McpServer` API.** Both entry points moved from low-level `Server + setRequestHandler(CallToolRequestSchema, ...)` to `McpServer.registerTool() / .resource() / .prompt()` (SDK 1.25+).
+- **Transport: SSE → Streamable HTTP.** `src/index.ts` uses `StreamableHTTPServerTransport` at `POST /mcp`. The legacy `/sse` route returns HTTP 410 with a pointer to `/mcp`.
+
+## [2.13.0] - 2026-05-20
+
+### Highlights ⭐
+- **SDK pin tightened to ^1.25.0** (resolves to 1.29.0). Source-compatible — no breaking change.
+- **CI on every push, weekly CodeQL** with `security-and-quality` pack.
+- **`SECURITY.md` published** — this package is the canonical source of `src/core/security.ts` used by the other MCPs in the workspace, so the threat model lives here.
+
+### Added
+- GitHub Actions `ci.yml` running `npm ci`, `npm run typecheck`, `npm run build`, and `npm test` on Node 20 for every push and PR to `main`.
+- GitHub Actions `release.yml` that publishes to npm with provenance when a `v*.*.*` tag is pushed (gated on `NPM_TOKEN`).
+- GitHub Actions `codeql.yml` running the `security-and-quality` query pack weekly and on every push / PR.
+- `SECURITY.md` with threat model, supported versions, reporting process.
+- `npm run typecheck` script (`tsc --noEmit`) for CI use.
+
+### Changed
+- Bump `@modelcontextprotocol/sdk` constraint from `^1.0.0` to `^1.25.0` (resolves to 1.29.0). No source changes required.
+- Tighten the npm `files` whitelist so published tarballs only contain `dist/**/*.{js,d.ts,js.map}` plus `README.md`, `SECURITY.md`, `CHANGELOG.md`, `LICENSE`.
+
+### Known issues (resolved in 2.14.0)
+- The repo still ships **two entry points** with feature drift: `src/index.ts` (SSE transport, 7 tools) vs. `src/stdio.ts` (stdio transport, 15 tools). Full unification is deferred to Phase 3 (2.14.0) to keep this release purely additive.
+
+## [2.12.1] - prior
+
+- MCP Registry support.
+
+## [2.12.0] and earlier
+
+- Session stats, auto-tag, template, batch tools (v2.9-v2.12).
+- Session export and project profile tools (v2.7).
+- Session history management (v2.6).
+- AI-powered code analysis (v2.5).
+- AI-powered summarization with Claude API.
+- See git history for earlier releases.
+
+[Unreleased]: https://github.com/MUSE-CODE-SPACE/vibe-coding-mcp/compare/v2.14.0...HEAD
+[2.14.0]: https://github.com/MUSE-CODE-SPACE/vibe-coding-mcp/compare/v2.13.0...v2.14.0
+[2.13.0]: https://github.com/MUSE-CODE-SPACE/vibe-coding-mcp/compare/v2.12.1...v2.13.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 MUSE-CODE-SPACE / yoon-k
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,322 +1,236 @@
-# Vibe Coding Documentation MCP (MUSE)
-
-MCP server that automatically collects, summarizes, documents, and publishes code and design decisions created during vibe coding sessions.
-
-## Features
-
-This MCP server provides 15 tools for managing vibe coding documentation:
-
-| Tool | Description |
-|------|-------------|
-| `muse_collect_code_context` | Collects code blocks and conversation summaries into structured context |
-| `muse_summarize_design_decisions` | Extracts key architectural and design decisions from conversation logs |
-| `muse_generate_dev_document` | Generates README, DESIGN, TUTORIAL, CHANGELOG, API, or ARCHITECTURE documents |
-| `muse_normalize_for_platform` | Converts Markdown documents for Notion, GitHub Wiki, or Obsidian |
-| `muse_publish_document` | Publishes generated documents to external platforms |
-| `muse_create_session_log` | Creates daily or session-based vibe coding session logs |
-| `muse_analyze_code` | AST-based code analysis with Mermaid diagram generation |
-| `muse_session_history` | Manages session history - save, retrieve, search past sessions |
-| `muse_export_session` | Exports sessions to Markdown, JSON, or HTML formats |
-| `muse_project_profile` | Manages project-specific settings and configurations |
-| `muse_git` | Git integration - status, log, diff, branch, snapshot, design decision extraction |
-| `muse_session_stats` | Session analytics dashboard with productivity insights and trends |
-| `muse_auto_tag` | AI-powered auto-tagging for sessions based on content analysis |
-| `muse_template` | Custom template management for documents and reports |
-| `muse_batch` | Batch operations to execute multiple tools in sequence or parallel |
-
-### Additional Features (v2.0)
-- **AST Parsing**: TypeScript, Python, Go code analysis
-- **Mermaid Diagrams**: Class, Flowchart, Sequence, ER, Architecture diagrams
-- **Multi-language**: Korean/English support
-- **6 Document Types**: README, DESIGN, TUTORIAL, CHANGELOG, API, ARCHITECTURE
-- **6 Platforms**: Notion, GitHub Wiki, Obsidian, Confluence, Slack, Discord
-
-### Code Quality (v2.1)
-- **Input Validation**: Zod schema-based type-safe validation for all tools
-- **Error Handling**: Structured error classes (ToolError, ValidationError, PlatformError)
-- **Security**: Command injection prevention (exec → spawn), path sanitization
-- **Performance**: LRU cache, regex cache, memoization utilities
-
-### Security (v2.2)
-- **Path Traversal Prevention**: Validates file paths stay within allowed directories
-- **SSRF Protection**: Webhook URL validation for Slack/Discord
-- **Network Timeout**: AbortController-based request timeout (30s default)
-- **Retry Logic**: Exponential backoff with configurable retry attempts
-
-### Enhanced Quality (v2.3)
-- **Structured Logging**: JSON-based logging with child loggers per tool
-- **Configuration Validation**: Startup validation for all platform configurations
-- **Platform Expansion**: Full support for 6 platforms (Notion, GitHub Wiki, Obsidian, Confluence, Slack, Discord)
-- **AST Memoization**: Cached code analysis for improved performance
-- **Test Coverage**: 149 tests with 85%+ coverage on core modules
-
-### AI-Powered Analysis (v2.4)
-- **Claude AI Integration**: Use Claude AI for enhanced design decision analysis
-- **Smart Summarization**: AI-generated insights and recommendations
-- **Fallback Support**: Automatic fallback to pattern-based analysis when AI unavailable
-- **Optional Feature**: Enable with `useAI: true` parameter
-
-### AI Code Analysis (v2.5)
-- **AI-Powered Code Review**: Deep code analysis with quality, security, and performance insights
-- **Issue Detection**: Identify potential bugs, security vulnerabilities, and code smells
-- **Improvement Suggestions**: AI-generated recommendations for better code
-- **Works with AST**: Combines AI insights with AST-based analysis for comprehensive results
-
-### Session History (v2.6)
-- **Persistent Storage**: Save coding sessions to local JSON files
-- **CRUD Operations**: Create, read, update, delete sessions
-- **Search & Filter**: Find past sessions by keyword, tags, or date
-- **Statistics**: Track total sessions, code contexts, and design decisions
-
-### Session Export & Project Profiles (v2.7)
-- **Session Export**: Export sessions to Markdown, JSON, or HTML formats
-- **Multiple Templates**: Default, minimal, detailed, and report templates
-- **Project Profiles**: Manage project-specific settings and configurations
-- **Publishing Config**: Default platforms and settings per project
-- **Code Analysis Config**: Language preferences and diagram types
-- **Documentation Config**: Default document types, language, author info
-- **Team Management**: Store team member information per project
-
-### Git Integration (v2.8)
-- **Repository Status**: View staged, unstaged, and untracked files
-- **Commit History**: Browse commit log with filtering by author, date, grep
-- **Diff Analysis**: View changes with statistics (staged, unstaged, between refs)
-- **Branch Info**: List local and remote branches with tracking info
-- **Git Snapshot**: Capture complete repository state for session context
-- **Design Decision Extraction**: Auto-extract design decisions from commit messages
-- **Session Linking**: Attach Git context to coding sessions
-
-### Session Statistics Dashboard (v2.9)
-- **Overview Analytics**: Total sessions, code contexts, design decisions at a glance
-- **Language Distribution**: Breakdown of programming languages used across sessions
-- **Timeline View**: Session activity over time (daily, weekly, monthly)
-- **Tag Analytics**: Most used tags and tag co-occurrence analysis
-- **Productivity Insights**: Session duration, code output, and efficiency metrics
-- **Trend Analysis**: Compare current period with previous or average
-
-### AI Auto-tagging (v2.10)
-- **Smart Tag Suggestions**: Pattern-based and AI-powered tag recommendations
-- **Confidence Scoring**: Each tag suggestion includes confidence level
-- **Custom Tag Training**: Train the system with custom tag patterns
-- **Configurable Rules**: Define tag rules for file extensions, keywords, patterns
-- **Batch Tagging**: Apply tags to multiple sessions at once
-
-### Custom Templates (v2.11)
-- **Template Management**: Create, edit, delete custom document templates
-- **Variable Substitution**: Support for `{{variable}}`, `${variable}`, `{variable}` formats
-- **Built-in Templates**: README, Session Summary, Weekly Report templates included
-- **Template Preview**: Preview rendered output before applying
-- **Import/Export**: Share templates between projects
-
-### Batch Operations (v2.12)
-- **Sequential Execution**: Run multiple tools in order with dependency management
-- **Parallel Execution**: Execute independent operations concurrently
-- **Dependency Graph**: Topological sort for operation ordering
-- **Job Tracking**: Monitor batch job status, cancel running jobs
-- **Error Handling**: Stop on error or continue with remaining operations
-- **Result Chaining**: Pass output from one operation to next using `$ref` syntax
-
-## Installation
-
-### Claude Code (Recommended)
+# vibe-coding-mcp
 
-```bash
-claude mcp add vibe-coding-mcp npx vibe-coding-mcp
-```
-
-### npm
-
-```bash
-npm install -g vibe-coding-mcp
-```
-
-### Claude Desktop
-
-Add to `claude_desktop_config.json`:
-
-**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
-**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
-
-```json
-{
-  "mcpServers": {
-    "vibe-coding-mcp": {
-      "command": "npx",
-      "args": ["vibe-coding-mcp"]
-    }
-  }
-}
-```
-
-## Environment Variables
-
-```env
-# Anthropic API (optional, for AI-powered analysis)
-ANTHROPIC_API_KEY=your_anthropic_api_key_here
-
-# Notion API (optional)
-NOTION_API_KEY=your_notion_api_key_here
-NOTION_DATABASE_ID=your_database_id_here
-
-# GitHub (optional, for Wiki publishing)
-GITHUB_TOKEN=your_github_token_here
-GITHUB_REPO=owner/repo
-
-# Confluence (optional)
-CONFLUENCE_BASE_URL=https://your-domain.atlassian.net
-CONFLUENCE_USERNAME=your_email@example.com
-CONFLUENCE_API_TOKEN=your_api_token_here
-CONFLUENCE_SPACE_KEY=YOURSPACE
-
-# Slack (optional, webhook URL passed via tool parameter)
-SLACK_WEBHOOK_URL=https://hooks.slack.com/services/...
-
-# Discord (optional, webhook URL passed via tool parameter)
-DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/...
-```
-
-## Demo Scenarios
-
-### 1. Generate README and Publish to Notion
-
-```
-User: Collect the code we wrote today and create a README, then publish to Notion.
-
-Claude: [Uses collect_code_context → generate_dev_document → normalize_for_platform → publish_document]
-```
-
-### 2. Create Design Decision Docs for GitHub Wiki
-
-```
-User: Summarize our design decisions and publish to GitHub Wiki.
-
-Claude: [Uses summarize_design_decisions → generate_dev_document → normalize_for_platform → publish_document]
-```
-
-### 3. Daily Vibe Coding Log
+> 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.
 
-```
-User: Create a session log for today's work.
-
-Claude: [Uses collect_code_context → create_session_log]
-```
+[![CI](https://github.com/MUSE-CODE-SPACE/vibe-coding-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/MUSE-CODE-SPACE/vibe-coding-mcp/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/vibe-coding-mcp.svg)](https://www.npmjs.com/package/vibe-coding-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+![Maintained](https://img.shields.io/badge/maintained-yes-brightgreen.svg)
 
-### 4. Git-Aware Session Documentation
-
-```
-User: Capture my current Git state and create a session with design decisions from commits.
-
-Claude: [Uses muse_git(action='snapshot') → muse_git(action='extractDecisions') → muse_session_history(action='save')]
-```
+[English](#english) · [한국어](#한국어)
 
-### 5. Complete Session Export with Git Context
+---
 
-```
-User: Export all my sessions from this week with Git information.
+<a name="english"></a>
+## Why vibe-coding?
 
-Claude: [Uses muse_git(action='linkToSession') → muse_export_session(format='markdown')]
-```
+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.
 
-### 6. Session Analytics Dashboard
+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.
 
-```
-User: Show me my coding productivity statistics for this month.
+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.
 
-Claude: [Uses muse_session_stats(action='overview') → muse_session_stats(action='productivity') → muse_session_stats(action='trends')]
-```
+## What's new in v2.14.0
 
-### 7. Auto-tag and Organize Sessions
+- **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.
 
-```
-User: Analyze my sessions and suggest relevant tags.
+## 5-minute Quickstart
 
-Claude: [Uses muse_auto_tag(action='suggest') → muse_auto_tag(action='apply')]
+```bash
+# 1. Install via Claude Code
+claude mcp add vibe-coding-mcp -- npx -y vibe-coding-mcp
 ```
 
-### 8. Generate Custom Report with Template
-
-```
-User: Create a weekly report using the team report template.
+2. Wire it as a Claude Code hook so every session auto-captures. Add this to `~/.claude/settings.json`:
 
-Claude: [Uses muse_template(action='apply', templateId='weekly-report') → muse_publish_document]
+```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"
+        }]
+      }
+    ]
+  }
+}
 ```
 
-### 9. Batch Documentation Workflow
-
-```
-User: Analyze this code, generate docs, and publish to Notion in one go.
+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/<id>.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/<name>.ts` + a one-line `register()` in `src/core/toolRegistry.ts`. CI runs `typecheck + build + test` on Node 20 against every PR.
+
+Quick contributor loop:
 
-Claude: [Uses muse_batch(action='execute', operations=[
-  {tool: 'muse_analyze_code', params: {...}},
-  {tool: 'muse_generate_dev_document', params: {...}, dependsOn: ['op_0']},
-  {tool: 'muse_publish_document', params: {...}, dependsOn: ['op_1']}
-])]
+```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
 ```
 
-## Supported Platforms
+## Security
 
-- **Notion**: Full API integration with page creation
-- **GitHub Wiki**: Git-based wiki updates
-- **Obsidian**: Local vault file storage with frontmatter support
-- **Confluence**: Atlassian Confluence page publishing
-- **Slack**: Webhook-based message publishing
-- **Discord**: Webhook-based message publishing
+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.
 
-## Project Structure
+**Report vulnerabilities privately** via a GitHub Security Advisory: <https://github.com/MUSE-CODE-SPACE/vibe-coding-mcp/security/advisories/new>.
 
-```
-src/
-├── stdio.ts              # MCP server entry point (stdio transport)
-├── index.ts              # HTTP/SSE server entry point
-├── core/
-│   ├── schemas.ts        # Zod validation schemas
-│   ├── errors.ts         # Structured error classes
-│   ├── cache.ts          # LRU cache & memoization
-│   ├── security.ts       # Path traversal, SSRF, timeout utilities
-│   ├── logger.ts         # Structured JSON logging
-│   └── config.ts         # Platform configuration validation
-├── tools/                # 15 MCP tools
-├── platforms/            # Notion, GitHub Wiki, Obsidian, Confluence, Slack, Discord
-├── types/                # TypeScript interfaces
-└── utils/
-    ├── markdown.ts       # Markdown processing
-    ├── astParser.ts      # AST parsing for TypeScript, Python, Go
-    ├── diagramGenerator.ts # Mermaid diagram generation
-    ├── gitExecutor.ts    # Safe Git command execution
-    └── gitParsers.ts     # Git output parsing utilities
-```
-
-## Development
-
-```bash
-# Watch mode
-npm run dev
-
-# Build
-npm run build
+## License
 
-# Start (HTTP/SSE mode)
-npm start
+MIT — SPDX identifier declared in [`package.json`](./package.json) (a top-level `LICENSE` file will be added in the next release).
 
-# Start (stdio mode for Claude Desktop)
-npm run stdio
+## Maintainer
 
-# Run tests
-npm test
+[@yoon-k](https://github.com/MUSE-CODE-SPACE) (MUSE-CODE-SPACE). Issues + support: <https://github.com/MUSE-CODE-SPACE/vibe-coding-mcp/issues>.
 
-# Run tests with coverage
-npm run test:coverage
-```
+---
 
-## Dependencies
+<a name="한국어"></a>
+## 한국어 요약
 
-| Package | Purpose |
-|---------|---------|
-| `@modelcontextprotocol/sdk` | MCP server SDK |
-| `@notionhq/client` | Notion API integration |
-| `zod` | Input validation |
-| `typescript` | TypeScript compiler |
+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개 플랫폼에 발행합니다.
 
-## License
+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`)가 추가되었습니다.
 
-MIT
+설치 + 자동 캡처 훅 설정은 [`docs/AUTO_CAPTURE.md`](./docs/AUTO_CAPTURE.md) 참고. 변경 이력은 [`CHANGELOG.md`](./CHANGELOG.md), 위협 모델은 [`SECURITY.md`](./SECURITY.md).