node804-claude-code-mcp 1.0.0__py3-none-any.whl

node804_claude_code_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""Claude Code MCP Server — reads local Claude Code session history."""
+
+__version__ = "1.0.0"

node804_claude_code_mcp/config.py

@@ -0,0 +1,19 @@
+"""Configuration for the Claude Code MCP server."""
+
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+def get_claude_dir() -> Path:
+    override = os.getenv("CLAUDE_DIR")
+    if override:
+        return Path(override)
+    return Path.home() / ".claude"
+
+
+def get_projects_dir() -> Path:
+    return get_claude_dir() / "projects"

node804_claude_code_mcp/server.py

@@ -0,0 +1,133 @@
+"""Claude Code MCP server entry point."""
+
+import logging
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from . import __version__
+from .config import get_projects_dir
+from .sessions import (
+    get_session,
+    get_session_stats,
+    list_projects,
+    list_sessions,
+    search_sessions,
+)
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+mcp = FastMCP("node804_claude_code_mcp")
+
+
+@mcp.tool()
+async def server_status() -> dict[str, Any]:
+    """Show the current server configuration.
+
+    Returns the version, the resolved Claude Code data directory, and the
+    number of projects found.
+    """
+    projects = list_projects()
+    return {
+        "version": __version__,
+        "claude_dir": str(get_projects_dir().parent),
+        "projects_dir": str(get_projects_dir()),
+        "project_count": len(projects),
+    }
+
+
+@mcp.tool()
+async def list_claude_projects() -> dict[str, Any]:
+    """List all Claude Code projects in the local session store.
+
+    Reads from ``~/.claude/projects/`` (or ``CLAUDE_DIR`` if set).
+    Returns each project's slug, session count, and last activity timestamp,
+    sorted most-recent first.
+    """
+    return {
+        "projects_dir": str(get_projects_dir()),
+        "projects": list_projects(),
+    }
+
+
+@mcp.tool()
+async def list_claude_sessions(
+    project_slug: str = "",
+    limit: int = 20,
+) -> dict[str, Any]:
+    """List Claude Code sessions, optionally filtered to a single project.
+
+    Args:
+        project_slug: The project slug (as returned by list_claude_projects).
+                      Leave empty to list sessions across all projects.
+        limit: Maximum number of sessions to return. Defaults to 20.
+    """
+    return list_sessions(project_slug or None, limit=limit)
+
+
+@mcp.tool()
+async def get_claude_session(
+    session_id: str,
+    project_slug: str,
+    include_thinking: bool = False,
+) -> dict[str, Any]:
+    """Get the full conversation transcript from a Claude Code session.
+
+    Returns user and assistant messages in order, with timestamps and tool
+    call names. Internal thinking blocks are excluded unless include_thinking
+    is set.
+
+    Args:
+        session_id: The session UUID (as returned by list_claude_sessions).
+        project_slug: The project the session belongs to.
+        include_thinking: Include assistant thinking blocks. Defaults to False.
+    """
+    return get_session(session_id, project_slug, include_thinking=include_thinking)
+
+
+@mcp.tool()
+async def get_claude_session_stats(
+    session_id: str,
+    project_slug: str,
+) -> dict[str, Any]:
+    """Get token usage, timing, and message counts for a Claude Code session.
+
+    Returns input/output token totals, cache read tokens, duration in
+    minutes, models used, and the working directory the session was run from.
+
+    Args:
+        session_id: The session UUID.
+        project_slug: The project the session belongs to.
+    """
+    return get_session_stats(session_id, project_slug)
+
+
+@mcp.tool()
+async def search_claude_sessions(
+    query: str,
+    project_slug: str = "",
+    limit: int = 20,
+) -> dict[str, Any]:
+    """Search for text across Claude Code session messages.
+
+    Case-insensitive full-text search over all user and assistant messages.
+    Returns matching snippets with surrounding context, session IDs, and
+    timestamps.
+
+    Args:
+        query: Text to search for.
+        project_slug: Limit search to a single project. Leave empty to
+                      search all projects.
+        limit: Maximum number of hits to return. Defaults to 20.
+    """
+    return search_sessions(query, project_slug or None, limit=limit)
+
+
+def main() -> None:
+    logger.info(f"node804-claude-code-mcp v{__version__} starting")
+    mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

node804_claude_code_mcp/sessions.py

@@ -0,0 +1,344 @@
+"""Session and project reading for Claude Code's local JSONL store."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from .config import get_projects_dir
+
+_MAX_LIMIT = 200
+
+
+# ---- Path safety -----------------------------------------------------------
+
+def _safe_child(base: Path, *parts: str) -> Path | None:
+    """Resolve a path under base, returning None if it escapes the base directory."""
+    try:
+        candidate = base.joinpath(*parts).resolve()
+        base.resolve()  # ensure base itself is resolvable
+        candidate.relative_to(base.resolve())  # raises ValueError if outside
+        return candidate
+    except (ValueError, OSError):
+        return None
+
+
+# ---- Project listing -------------------------------------------------------
+
+def list_projects() -> list[dict[str, Any]]:
+    """List all projects in ~/.claude/projects/, sorted by most recent activity."""
+    projects_dir = get_projects_dir()
+    if not projects_dir.is_dir():
+        return []
+
+    results = []
+    for entry in projects_dir.iterdir():
+        if not entry.is_dir():
+            continue
+        sessions = _list_session_files(entry)
+        timestamps = sorted(
+            (s["last_activity"] for s in sessions if s["last_activity"]),
+            reverse=True,
+        )
+        results.append(
+            {
+                "slug": entry.name,
+                "session_count": len(sessions),
+                "last_activity": timestamps[0] if timestamps else None,
+            }
+        )
+
+    results.sort(key=lambda p: p["last_activity"] or "", reverse=True)
+    return results
+
+
+# ---- Session file listing --------------------------------------------------
+
+def _list_session_files(project_dir: Path) -> list[dict[str, Any]]:
+    sessions = []
+    for f in project_dir.glob("*.jsonl"):
+        stat = f.stat()
+        sessions.append(
+            {
+                "session_id": f.stem,
+                "project_slug": project_dir.name,
+                "last_activity": _mtime_iso(stat),
+                "size_bytes": stat.st_size,
+            }
+        )
+    sessions.sort(key=lambda s: s["last_activity"] or "", reverse=True)
+    return sessions
+
+
+def list_sessions(project_slug: str | None = None, limit: int = 20) -> dict[str, Any]:
+    limit = min(limit, _MAX_LIMIT)
+    projects_dir = get_projects_dir()
+    sessions: list[dict[str, Any]] = []
+
+    if project_slug:
+        project_dir = _safe_child(projects_dir, project_slug)
+        if not project_dir or not project_dir.is_dir():
+            return {"error": f"Project not found: {project_slug}"}
+        sessions = _list_session_files(project_dir)
+    else:
+        if not projects_dir.is_dir():
+            return {"total": 0, "shown": 0, "sessions": []}
+        for entry in projects_dir.iterdir():
+            if entry.is_dir():
+                sessions.extend(_list_session_files(entry))
+        sessions.sort(key=lambda s: s["last_activity"] or "", reverse=True)
+
+    return {
+        "total": len(sessions),
+        "shown": min(len(sessions), limit),
+        "sessions": sessions[:limit],
+    }
+
+
+# ---- JSONL reading ---------------------------------------------------------
+
+def _read_jsonl(path: Path) -> list[dict[str, Any]]:
+    records = []
+    try:
+        for line in path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                records.append(json.loads(line))
+            except json.JSONDecodeError:
+                pass
+    except OSError:
+        pass
+    return records
+
+
+def _extract_text(content: str | list[dict] | None) -> str:
+    if not content:
+        return ""
+    if isinstance(content, str):
+        return content
+    return "\n".join(
+        b.get("text", "") for b in content if b.get("type") == "text"
+    ).strip()
+
+
+def _extract_tool_calls(content: list[dict]) -> list[str]:
+    return [b["name"] for b in content if b.get("type") == "tool_use" and b.get("name")]
+
+
+# ---- Public session API ----------------------------------------------------
+
+def get_session(
+    session_id: str,
+    project_slug: str,
+    include_thinking: bool = False,
+) -> dict[str, Any]:
+    projects_dir = get_projects_dir()
+    path = _safe_child(projects_dir, project_slug, f"{session_id}.jsonl")
+    if not path or not path.is_file():
+        return {"error": f"Session not found: {session_id}"}
+
+    messages = []
+    for rec in _read_jsonl(path):
+        rtype = rec.get("type")
+
+        if rtype == "user":
+            text = _extract_text(rec.get("message", {}).get("content"))
+            if not text:
+                continue
+            messages.append(
+                {
+                    "uuid": rec.get("uuid"),
+                    "role": "user",
+                    "timestamp": rec.get("timestamp"),
+                    "text": text,
+                }
+            )
+
+        elif rtype == "assistant":
+            msg = rec.get("message", {})
+            content = msg.get("content") or []
+
+            text_parts = [b.get("text", "") for b in content if b.get("type") == "text"]
+            text = "\n".join(text_parts).strip()
+
+            if include_thinking:
+                thinking_parts = [
+                    f"<thinking>\n{b['thinking']}\n</thinking>"
+                    for b in content
+                    if b.get("type") == "thinking" and b.get("thinking")
+                ]
+                if thinking_parts:
+                    text = "\n".join(thinking_parts) + ("\n\n" + text if text else "")
+
+            tool_calls = _extract_tool_calls(content)
+            if not text and not tool_calls:
+                continue
+
+            messages.append(
+                {
+                    "uuid": rec.get("uuid"),
+                    "role": "assistant",
+                    "timestamp": rec.get("timestamp"),
+                    "text": text,
+                    "model": msg.get("model"),
+                    "tool_calls": tool_calls or None,
+                }
+            )
+
+    return {
+        "session_id": session_id,
+        "project_slug": project_slug,
+        "message_count": len(messages),
+        "messages": messages,
+    }
+
+
+def get_session_stats(session_id: str, project_slug: str) -> dict[str, Any]:
+    projects_dir = get_projects_dir()
+    path = _safe_child(projects_dir, project_slug, f"{session_id}.jsonl")
+    if not path or not path.is_file():
+        return {"error": f"Session not found: {session_id}"}
+
+    user_count = 0
+    assistant_count = 0
+    total_input = 0
+    total_output = 0
+    cache_read = 0
+    first_ts = None
+    last_ts = None
+    models: set[str] = set()
+    cwd = None
+
+    for rec in _read_jsonl(path):
+        rtype = rec.get("type")
+        if rtype not in ("user", "assistant"):
+            continue
+
+        ts = rec.get("timestamp")
+        if ts:
+            if not first_ts or ts < first_ts:
+                first_ts = ts
+            if not last_ts or ts > last_ts:
+                last_ts = ts
+
+        if rtype == "user":
+            user_count += 1
+            if not cwd:
+                cwd = rec.get("cwd")
+        elif rtype == "assistant":
+            assistant_count += 1
+            msg = rec.get("message", {})
+            if msg.get("model"):
+                models.add(msg["model"])
+            usage = msg.get("usage") or {}
+            total_input += usage.get("input_tokens", 0)
+            total_output += usage.get("output_tokens", 0)
+            cache_read += usage.get("cache_read_input_tokens", 0)
+
+    duration_minutes = None
+    if first_ts and last_ts and first_ts != last_ts:
+        fmt = "%Y-%m-%dT%H:%M:%S.%fZ"
+        try:
+            t0 = datetime.strptime(first_ts[:26] + "Z", fmt).replace(tzinfo=timezone.utc)
+            t1 = datetime.strptime(last_ts[:26] + "Z", fmt).replace(tzinfo=timezone.utc)
+            duration_minutes = round((t1 - t0).total_seconds() / 60)
+        except ValueError:
+            pass
+
+    return {
+        "session_id": session_id,
+        "project_slug": project_slug,
+        "message_count": user_count + assistant_count,
+        "user_messages": user_count,
+        "assistant_messages": assistant_count,
+        "total_input_tokens": total_input,
+        "total_output_tokens": total_output,
+        "cache_read_tokens": cache_read,
+        "first_message": first_ts,
+        "last_message": last_ts,
+        "duration_minutes": duration_minutes,
+        "models_used": sorted(models),
+        "cwd": cwd,
+    }
+
+
+def search_sessions(
+    query: str,
+    project_slug: str | None = None,
+    limit: int = 20,
+) -> dict[str, Any]:
+    limit = min(limit, _MAX_LIMIT)
+    projects_dir = get_projects_dir()
+    lower = query.lower()
+    hits: list[dict[str, Any]] = []
+
+    if project_slug:
+        project_dir = _safe_child(projects_dir, project_slug)
+        if not project_dir or not project_dir.is_dir():
+            return {"error": f"Project not found: {project_slug}"}
+        slugs = [project_slug]
+    else:
+        if not projects_dir.is_dir():
+            return {"query": query, "total": 0, "shown": 0, "hits": []}
+        slugs = [e.name for e in projects_dir.iterdir() if e.is_dir()]
+
+    for slug in slugs:
+        if len(hits) >= limit:
+            break
+        slug_dir = _safe_child(projects_dir, slug)
+        if not slug_dir:
+            continue
+        for session in _list_session_files(slug_dir):
+            if len(hits) >= limit:
+                break
+            path = slug_dir / f"{session['session_id']}.jsonl"
+            for rec in _read_jsonl(path):
+                rtype = rec.get("type")
+                if rtype not in ("user", "assistant"):
+                    continue
+
+                full_text = _extract_text(rec.get("message", {}).get("content") or [])
+                uuid = rec.get("uuid", "")
+
+                idx = full_text.lower().find(lower)
+                if idx == -1:
+                    continue
+
+                ctx = 200
+                start = max(0, idx - ctx)
+                end = min(len(full_text), idx + len(query) + ctx)
+                snippet = full_text[start:end].strip()
+                if start > 0:
+                    snippet = "…" + snippet
+                if end < len(full_text):
+                    snippet = snippet + "…"
+
+                hits.append(
+                    {
+                        "session_id": session["session_id"],
+                        "project_slug": slug,
+                        "message_uuid": uuid,
+                        "role": rtype,
+                        "timestamp": rec.get("timestamp"),
+                        "snippet": snippet,
+                    }
+                )
+
+    return {
+        "query": query,
+        "total": len(hits),
+        "shown": min(len(hits), limit),
+        "hits": hits[:limit],
+    }
+
+
+# ---- Helpers ---------------------------------------------------------------
+
+def _mtime_iso(stat: Any) -> str:
+    return datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc).strftime(
+        "%Y-%m-%dT%H:%M:%SZ"
+    )

node804_claude_code_mcp-1.0.0.dist-info/METADATA

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: node804-claude-code-mcp
+Version: 1.0.0
+Summary: MCP server for reading Claude Code session history from the local filesystem
+Project-URL: Homepage, https://github.com/Node804/node804-claude-code-mcp
+Project-URL: Repository, https://github.com/Node804/node804-claude-code-mcp
+Project-URL: Issues, https://github.com/Node804/node804-claude-code-mcp/issues
+Author-email: Michael Pope <me@michaelpope.cv>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: claude,claude-code,knowledge-management,mcp,model-context-protocol,pkm,session-history
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Requires-Dist: mcp[cli]>=1.3.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# node804-claude-code-mcp
+
+[![PyPI version](https://img.shields.io/pypi/v/node804-claude-code-mcp)](https://pypi.org/project/node804-claude-code-mcp/)
+[![Python versions](https://img.shields.io/pypi/pyversions/node804-claude-code-mcp)](https://pypi.org/project/node804-claude-code-mcp/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![CI](https://github.com/Node804/node804-claude-code-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/Node804/node804-claude-code-mcp/actions/workflows/ci.yml)
+
+MCP server for reading Claude Code session history from the local filesystem.
+Exposes project and session data to any MCP-compatible client — Claude Cowork, Claude Chat, scheduled agents, or your own tooling.
+
+Reads directly from `~/.claude/projects/` — no external dependencies, no network calls, no API keys.
+
+---
+
+## Why this exists
+
+Claude Code stores every session as a local JSONL file containing the full conversation: user messages, assistant responses, tool calls, token counts, and timing. That history is rich and detailed, but it's locked inside the CLI with no way to query it from other tools.
+
+This server opens it up.
+
+### Use cases
+
+**Personal Knowledge Management and daily logging**
+Claude Code sessions are a detailed record of decisions made, problems solved, and code written. This server lets a Cowork or Chat session pull that raw material into a daily note, work log, or PKM entry automatically — capturing not just *what* changed but the reasoning behind it, without any manual copy-paste.
+
+**Cross-session continuity**
+Starting a new Claude Code session on a project that was last touched weeks ago means re-explaining context from scratch. With this server, a fresh session can search prior conversations for relevant background — design decisions, dead ends already explored, environment quirks — before writing a single line of code.
+
+**Standup and progress reporting**
+`search_claude_sessions` and `get_claude_session_stats` give enough signal to reconstruct what was worked on across a day or week. A scheduled agent can draft standup notes or weekly summaries without you keeping a separate activity log.
+
+**Token and time auditing**
+`get_claude_session_stats` returns per-session input/output token counts, cache hit rates, and duration. Useful for understanding which projects are consuming the most AI time, or for back-of-envelope cost tracking across a team.
+
+**Recovering decisions and rationale**
+The assistant messages in a session contain reasoning that never makes it into git history or documentation. When a colleague asks "why did we pick X over Y?", a search across sessions is often faster than reading commits — and captures the full deliberation, not just the outcome.
+
+**Handoff and onboarding**
+A new team member or a handoff to another AI session can be primed with the actual conversation history from a project rather than a manually written summary that may already be stale.
+
+**Research and spike synthesis**
+Exploratory sessions — spiking on a library, investigating an incident, prototyping an approach — produce valuable findings that are easy to lose. Searching across those sessions lets later work build on earlier exploration rather than repeat it.
+
+---
+
+## Installation
+
+```bash
+pip install node804-claude-code-mcp
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/Node804/node804-claude-code-mcp
+cd node804-claude-code-mcp
+pip install -e .
+```
+
+---
+
+## Setup
+
+### Claude Desktop / Claude Chat
+
+Add to `claude_desktop_config.json`:
+
+**Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
+**macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "claude-code-logs": {
+      "command": "python",
+      "args": ["-m", "node804_claude_code_mcp.server"]
+    }
+  }
+}
+```
+
+Restart Claude Desktop after saving.
+
+### Claude Code (settings.json)
+
+Add to `.claude/settings.json` in your project, or to the global `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "claude-code-logs": {
+      "command": "python",
+      "args": ["-m", "node804_claude_code_mcp.server"]
+    }
+  }
+}
+```
+
+---
+
+## Environment variables
+
+| Variable     | Default      | Description                                |
+|-------------|-------------|--------------------------------------------|
+| `CLAUDE_DIR` | `~/.claude` | Override the Claude Code data directory    |
+
+---
+
+## Tools
+
+### `server_status`
+Show the current server version and resolved data directory.
+
+---
+
+### `list_claude_projects`
+List all Claude Code projects in the local session store, sorted by most recent activity.
+
+**Returns:** project slug, session count, last activity timestamp.
+
+---
+
+### `list_claude_sessions`
+List sessions for a specific project or all projects.
+
+| Argument       | Type   | Default | Description                         |
+|---------------|--------|---------|-------------------------------------|
+| `project_slug` | string | —       | Filter to one project (optional)    |
+| `limit`        | int    | 20      | Max sessions to return              |
+
+---
+
+### `get_claude_session`
+Get the full conversation transcript from a session. Returns user and assistant messages in order, with timestamps and tool call names.
+
+| Argument           | Type    | Default | Description                            |
+|-------------------|---------|---------|----------------------------------------|
+| `session_id`      | string  | —       | Session UUID                           |
+| `project_slug`    | string  | —       | Project the session belongs to         |
+| `include_thinking` | bool   | false   | Include assistant thinking blocks      |
+
+---
+
+### `get_claude_session_stats`
+Token usage, timing, and message counts for a session.
+
+| Argument       | Type   | Description        |
+|---------------|--------|--------------------|
+| `session_id`  | string | Session UUID       |
+| `project_slug`| string | Project slug       |
+
+**Returns:** input/output tokens, cache read tokens, duration in minutes, models used, working directory.
+
+---
+
+### `search_claude_sessions`
+Case-insensitive full-text search across all session messages. Returns matching snippets with surrounding context.
+
+| Argument       | Type   | Default | Description                          |
+|---------------|--------|---------|--------------------------------------|
+| `query`       | string | —       | Text to search for                   |
+| `project_slug`| string | —       | Limit to one project (optional)      |
+| `limit`       | int    | 20      | Max hits to return                   |
+
+---
+
+## Known limitations
+
+Session files are read linearly from top to bottom. Claude Code's JSONL format is actually a tree — every record links to its parent via `parentUuid`, which means a session can contain forks (abandoned tool call branches, retries, compaction summaries). Linear reading is correct for the vast majority of normal interactive sessions, but a forked session could include abandoned branches in the output. Fork-aware traversal that follows the primary thread and discards dead branches is a potential future improvement.
+
+---
+
+## Data locations
+
+Claude Code stores session data at:
+
+- **Windows:** `%USERPROFILE%\.claude\projects\`
+- **macOS / Linux:** `~/.claude/projects/`
+
+Each project directory contains one `.jsonl` file per session. Records include `user` messages, `assistant` messages (with tool calls and token usage), and internal control messages.
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

node804_claude_code_mcp-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+node804_claude_code_mcp/__init__.py,sha256=S2Co1iNFfn48iS225htCcFgqT0HdmrUeTY4qvNUzAkg,97
+node804_claude_code_mcp/config.py,sha256=Cxb1K-PsrwSJ94-0qSXe_7kuQRYa9ivku6AWLMSdOQA,363
+node804_claude_code_mcp/server.py,sha256=rv_CHLgCZ3cQ_JDCJEnsU-nYpvxqOgycfea-kXw-FgA,3816
+node804_claude_code_mcp/sessions.py,sha256=OCmZ0ULOwo9XfWuABONFkHqz9EMb8_RqkGp0HXaFlBI,11084
+node804_claude_code_mcp-1.0.0.dist-info/METADATA,sha256=RFr7dgYTucyKbzQaN5PSn9Lw89xURAF9U4ymPESd9jc,8833
+node804_claude_code_mcp-1.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+node804_claude_code_mcp-1.0.0.dist-info/entry_points.txt,sha256=SIea3MITRkCAgO_qYHd-dvwDJc4O7ZblFvrjLp8gJMI,80
+node804_claude_code_mcp-1.0.0.dist-info/licenses/LICENSE,sha256=MWZG7mvTKQAmF-bl5ZJ9VkzcpQy-ZPgzRoMe_rKekTc,1069
+node804_claude_code_mcp-1.0.0.dist-info/RECORD,,

node804_claude_code_mcp-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

node804_claude_code_mcp-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+node804-claude-code-mcp = node804_claude_code_mcp.server:main

node804_claude_code_mcp-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michael Pope
+
+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.