pcp-mcp 0.1.0__py3-none-any.whl

pcp_mcp/utils/builders.py

@@ -0,0 +1,290 @@
+"""Metric transformation and builder functions.
+
+Consolidated metric builders extracted from tools/system.py to follow DRY principles.
+"""
+
+from __future__ import annotations
+
+from pcp_mcp.models import (
+    CPUMetrics,
+    DiskMetrics,
+    LoadMetrics,
+    MemoryMetrics,
+    NetworkMetrics,
+    ProcessInfo,
+)
+from pcp_mcp.utils.extractors import get_first_value, sum_instances
+
+
+def build_cpu_metrics(data: dict) -> CPUMetrics:
+    """Build CPU metrics from fetched data."""
+    user = get_first_value(data, "kernel.all.cpu.user")
+    sys = get_first_value(data, "kernel.all.cpu.sys")
+    idle = get_first_value(data, "kernel.all.cpu.idle")
+    iowait = get_first_value(data, "kernel.all.cpu.wait.total")
+    ncpu = int(get_first_value(data, "hinv.ncpu", 1))
+
+    total = user + sys + idle + iowait
+    if total > 0:
+        user_pct = (user / total) * 100
+        sys_pct = (sys / total) * 100
+        idle_pct = (idle / total) * 100
+        iowait_pct = (iowait / total) * 100
+    else:
+        user_pct = sys_pct = idle_pct = iowait_pct = 0.0
+
+    if iowait_pct > 20:
+        assessment = "High I/O wait - system is disk bound"
+    elif idle_pct < 10:
+        assessment = "CPU is saturated"
+    elif user_pct > 70:
+        assessment = "CPU bound on user processes"
+    elif sys_pct > 30:
+        assessment = "High system/kernel CPU usage"
+    else:
+        assessment = "CPU utilization is normal"
+
+    return CPUMetrics(
+        user_percent=round(user_pct, 1),
+        system_percent=round(sys_pct, 1),
+        idle_percent=round(idle_pct, 1),
+        iowait_percent=round(iowait_pct, 1),
+        ncpu=ncpu,
+        assessment=assessment,
+    )
+
+
+def build_memory_metrics(data: dict) -> MemoryMetrics:
+    """Build memory metrics from fetched data."""
+    total = int(get_first_value(data, "mem.physmem")) * 1024
+    available = int(get_first_value(data, "mem.util.available")) * 1024
+    free = int(get_first_value(data, "mem.util.free")) * 1024
+    cached = int(get_first_value(data, "mem.util.cached")) * 1024
+    buffers = int(get_first_value(data, "mem.util.bufmem")) * 1024
+    swap_total = int(get_first_value(data, "mem.util.swapTotal")) * 1024
+    swap_free = int(get_first_value(data, "mem.util.swapFree")) * 1024
+    swap_used = swap_total - swap_free
+
+    used = total - available
+    used_pct = (used / total * 100) if total > 0 else 0.0
+
+    if swap_used > swap_total * 0.5:
+        assessment = "Heavy swap usage - memory pressure"
+    elif used_pct > 90:
+        assessment = "Memory usage is critical"
+    elif used_pct > 75:
+        assessment = "Memory usage is elevated"
+    else:
+        assessment = "Memory utilization is normal"
+
+    return MemoryMetrics(
+        total_bytes=total,
+        used_bytes=used,
+        free_bytes=free,
+        available_bytes=available,
+        cached_bytes=cached,
+        buffers_bytes=buffers,
+        swap_used_bytes=swap_used,
+        swap_total_bytes=swap_total,
+        used_percent=round(used_pct, 1),
+        assessment=assessment,
+    )
+
+
+def build_load_metrics(data: dict) -> LoadMetrics:
+    """Build load metrics from fetched data."""
+    load_data = data.get("kernel.all.load", {}).get("instances", {})
+
+    load_1m = float(load_data.get(1, 0.0))
+    load_5m = float(load_data.get(5, 0.0))
+    load_15m = float(load_data.get(15, 0.0))
+
+    runnable = int(get_first_value(data, "kernel.all.runnable"))
+    nprocs = int(get_first_value(data, "kernel.all.nprocs"))
+    ncpu = int(get_first_value(data, "hinv.ncpu", 1))
+
+    if load_1m > ncpu * 2:
+        assessment = f"Load is very high ({load_1m:.1f} vs {ncpu} CPUs)"
+    elif load_1m > ncpu:
+        assessment = f"Load is elevated ({load_1m:.1f} > {ncpu} CPUs)"
+    else:
+        assessment = "Load is normal"
+
+    return LoadMetrics(
+        load_1m=round(load_1m, 2),
+        load_5m=round(load_5m, 2),
+        load_15m=round(load_15m, 2),
+        runnable=runnable,
+        nprocs=nprocs,
+        assessment=assessment,
+    )
+
+
+def build_disk_metrics(data: dict) -> DiskMetrics:
+    """Build disk I/O metrics from fetched data."""
+    read_bytes = get_first_value(data, "disk.all.read_bytes")
+    write_bytes = get_first_value(data, "disk.all.write_bytes")
+    reads = get_first_value(data, "disk.all.read")
+    writes = get_first_value(data, "disk.all.write")
+
+    if read_bytes > 100_000_000 or write_bytes > 100_000_000:
+        assessment = (
+            f"Heavy disk I/O ({read_bytes / 1e6:.0f} MB/s read, {write_bytes / 1e6:.0f} MB/s write)"
+        )
+    elif read_bytes > 10_000_000 or write_bytes > 10_000_000:
+        assessment = "Moderate disk activity"
+    else:
+        assessment = "Disk I/O is low"
+
+    return DiskMetrics(
+        read_bytes_per_sec=round(read_bytes, 1),
+        write_bytes_per_sec=round(write_bytes, 1),
+        reads_per_sec=round(reads, 1),
+        writes_per_sec=round(writes, 1),
+        assessment=assessment,
+    )
+
+
+def build_network_metrics(data: dict) -> NetworkMetrics:
+    """Build network I/O metrics from fetched data."""
+    in_bytes = sum_instances(data, "network.interface.in.bytes")
+    out_bytes = sum_instances(data, "network.interface.out.bytes")
+    in_packets = sum_instances(data, "network.interface.in.packets")
+    out_packets = sum_instances(data, "network.interface.out.packets")
+
+    total_throughput = in_bytes + out_bytes
+    if total_throughput > 100_000_000:
+        assessment = f"High network throughput ({total_throughput / 1e6:.0f} MB/s)"
+    elif total_throughput > 10_000_000:
+        assessment = "Moderate network activity"
+    else:
+        assessment = "Network I/O is low"
+
+    return NetworkMetrics(
+        in_bytes_per_sec=round(in_bytes, 1),
+        out_bytes_per_sec=round(out_bytes, 1),
+        in_packets_per_sec=round(in_packets, 1),
+        out_packets_per_sec=round(out_packets, 1),
+        assessment=assessment,
+    )
+
+
+def _extract_process_data_sources(data: dict) -> dict[str, dict]:
+    """Extract all process data sources from raw PCP data."""
+    return {
+        "pid": data.get("proc.psinfo.pid", {}).get("instances", {}),
+        "cmd": data.get("proc.psinfo.cmd", {}).get("instances", {}),
+        "args": data.get("proc.psinfo.psargs", {}).get("instances", {}),
+        "rss": data.get("proc.memory.rss", {}).get("instances", {}),
+        "utime": data.get("proc.psinfo.utime", {}).get("instances", {}),
+        "stime": data.get("proc.psinfo.stime", {}).get("instances", {}),
+        "io_read": data.get("proc.io.read_bytes", {}).get("instances", {}),
+        "io_write": data.get("proc.io.write_bytes", {}).get("instances", {}),
+    }
+
+
+def _calculate_cpu_percent(
+    inst_id: str, utime_data: dict, stime_data: dict, include_cpu: bool
+) -> float | None:
+    """Calculate CPU percentage for a process instance."""
+    if not include_cpu and not utime_data:
+        return None
+    utime = float(utime_data.get(inst_id, 0))
+    stime = float(stime_data.get(inst_id, 0))
+    return (utime + stime) / 10.0
+
+
+def _calculate_io_metrics(
+    inst_id: str, io_read_data: dict, io_write_data: dict, include_io: bool
+) -> tuple[float | None, float | None]:
+    """Calculate I/O read/write metrics for a process instance."""
+    if not include_io and not io_read_data:
+        return None, None
+    io_read = float(io_read_data.get(inst_id, 0))
+    io_write = float(io_write_data.get(inst_id, 0))
+    return io_read, io_write
+
+
+def _build_process_info(
+    inst_id: str, sources: dict[str, dict], sort_by: str, total_mem: float
+) -> ProcessInfo | None:
+    """Build a single ProcessInfo from instance data."""
+    pid = int(sources["pid"].get(inst_id, 0))
+    if pid <= 0:
+        return None
+
+    cmd = str(sources["cmd"].get(inst_id, "unknown"))
+    cmdline = str(sources["args"].get(inst_id, cmd))[:200]
+    rss = int(sources["rss"].get(inst_id, 0)) * 1024
+    rss_pct = (rss / total_mem * 100) if total_mem > 0 else 0.0
+
+    cpu_pct = _calculate_cpu_percent(inst_id, sources["utime"], sources["stime"], sort_by == "cpu")
+
+    io_read, io_write = _calculate_io_metrics(
+        inst_id, sources["io_read"], sources["io_write"], sort_by == "io"
+    )
+
+    return ProcessInfo(
+        pid=pid,
+        command=cmd,
+        cmdline=cmdline,
+        cpu_percent=round(cpu_pct, 1) if cpu_pct is not None else None,
+        rss_bytes=rss,
+        rss_percent=round(rss_pct, 1),
+        io_read_bytes_per_sec=round(io_read, 1) if io_read is not None else None,
+        io_write_bytes_per_sec=round(io_write, 1) if io_write is not None else None,
+    )
+
+
+def build_process_list(data: dict, sort_by: str, total_mem: float, ncpu: int) -> list[ProcessInfo]:
+    """Build list of ProcessInfo from fetched data."""
+    sources = _extract_process_data_sources(data)
+    processes: list[ProcessInfo] = []
+
+    for inst_id in sources["pid"]:
+        process = _build_process_info(inst_id, sources, sort_by, total_mem)
+        if process is not None:
+            processes.append(process)
+
+    return processes
+
+
+def get_sort_key(proc: ProcessInfo, sort_by: str) -> float:
+    """Get sort key value for a process."""
+    if sort_by == "cpu":
+        return proc.cpu_percent or 0.0
+    elif sort_by == "memory":
+        return float(proc.rss_bytes)
+    elif sort_by == "io":
+        return (proc.io_read_bytes_per_sec or 0.0) + (proc.io_write_bytes_per_sec or 0.0)
+    return 0.0
+
+
+def assess_processes(processes: list[ProcessInfo], sort_by: str, ncpu: int) -> str:
+    """Generate assessment string for top processes."""
+    if not processes:
+        return "No processes found"
+
+    top = processes[0]
+    if sort_by == "cpu":
+        if top.cpu_percent and top.cpu_percent > ncpu * 100 * 0.5:
+            return f"{top.command} is CPU-bound ({top.cpu_percent:.0f}%)"
+        return f"Top CPU: {top.command} ({top.cpu_percent:.0f}%)"
+    elif sort_by == "memory":
+        return f"Top memory: {top.command} ({top.rss_percent:.1f}%)"
+    elif sort_by == "io":
+        total_io = (top.io_read_bytes_per_sec or 0) + (top.io_write_bytes_per_sec or 0)
+        return f"Top I/O: {top.command} ({total_io / 1e6:.1f} MB/s)"
+    return f"Top process: {top.command}"
+
+
+__all__ = [
+    "build_cpu_metrics",
+    "build_memory_metrics",
+    "build_load_metrics",
+    "build_disk_metrics",
+    "build_network_metrics",
+    "build_process_list",
+    "get_sort_key",
+    "assess_processes",
+]

pcp_mcp/utils/decorators.py

@@ -0,0 +1,38 @@
+"""Error handling decorators for MCP tools."""
+
+from __future__ import annotations
+
+from functools import wraps
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from typing import Any
+
+
+def handle_pcp_errors(operation: str) -> Callable:
+    """Decorator to convert PCP exceptions to ToolError.
+
+    Args:
+        operation: Description of the operation (e.g., "fetching metrics").
+
+    Returns:
+        Decorated async function that handles PCP errors.
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def wrapper(*args: Any, **kwargs: Any) -> Any:
+            from pcp_mcp.errors import handle_pcp_error
+
+            try:
+                return await func(*args, **kwargs)
+            except Exception as e:
+                raise handle_pcp_error(e, operation) from e
+
+        return wrapper
+
+    return decorator
+
+
+__all__ = ["handle_pcp_errors"]

pcp_mcp/utils/extractors.py

@@ -0,0 +1,60 @@
+"""Metric data extraction utilities.
+
+Consolidated helpers for extracting values from PCP metric responses.
+"""
+
+from __future__ import annotations
+
+
+def get_first_value(data: dict, metric: str, default: float = 0.0) -> float:
+    """Get first instance value from fetched data."""
+    metric_data = data.get(metric, {})
+    instances = metric_data.get("instances", {})
+    if instances:
+        return float(next(iter(instances.values()), default))
+    return default
+
+
+def get_scalar_value(response: dict, metric: str, default: int = 0) -> int:
+    """Get scalar value from raw fetch response."""
+    for v in response.get("values", []):
+        if v.get("name") == metric:
+            instances = v.get("instances", [])
+            if instances:
+                return int(instances[0].get("value", default))
+    return default
+
+
+def sum_instances(data: dict, metric: str) -> float:
+    """Sum all instance values for a metric."""
+    metric_data = data.get(metric, {})
+    instances = metric_data.get("instances", {})
+    return sum(float(v) for v in instances.values())
+
+
+def extract_help_text(metric_dict: dict, default: str = "") -> str:
+    """Extract help text from metric info dictionary.
+
+    Tries text-help first, then falls back to text-oneline.
+    """
+    return metric_dict.get("text-help") or metric_dict.get("text-oneline") or default
+
+
+def extract_timestamp(response: dict) -> float:
+    """Extract timestamp from pmproxy response.
+
+    Handles both float timestamps and dict format {s: ..., us: ...}.
+    """
+    ts = response.get("timestamp", 0.0)
+    if isinstance(ts, dict):
+        return ts.get("s", 0) + ts.get("us", 0) / 1e6
+    return float(ts)
+
+
+__all__ = [
+    "get_first_value",
+    "get_scalar_value",
+    "sum_instances",
+    "extract_help_text",
+    "extract_timestamp",
+]

pcp_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: pcp-mcp
+Version: 0.1.0
+Summary: MCP server for Performance Co-Pilot
+Keywords: mcp,pcp,performance-co-pilot,monitoring,model-context-protocol
+Author: Major Hayden
+Author-email: Major Hayden <major@mhtx.net>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: System :: Monitoring
+Classifier: Typing :: Typed
+Requires-Dist: fastmcp>=2.0.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: typing-extensions>=4.0 ; python_full_version < '3.11'
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/major/pcp-mcp
+Project-URL: Repository, https://github.com/major/pcp-mcp
+Description-Content-Type: text/markdown
+
+# pcp-mcp
+
+MCP server for [Performance Co-Pilot (PCP)](https://pcp.io/) metrics.
+
+Query system performance metrics via the Model Context Protocol - CPU, memory, disk I/O, network, processes, and more.
+
+## 🚀 Installation
+
+```bash
+pip install pcp-mcp
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add pcp-mcp
+```
+
+## 📋 Requirements
+
+- **Python**: 3.10+
+- **PCP**: Performance Co-Pilot with `pmproxy` running
+  ```bash
+  # Fedora/RHEL/CentOS
+  sudo dnf install pcp
+  sudo systemctl enable --now pmproxy
+  
+  # Ubuntu/Debian
+  sudo apt install pcp
+  sudo systemctl enable --now pmproxy
+  ```
+
+## ⚙️ Configuration
+
+Configure via environment variables:
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `PCP_HOST` | pmproxy host | `localhost` |
+| `PCP_PORT` | pmproxy port | `44322` |
+| `PCP_TARGET_HOST` | Target pmcd host to monitor | `localhost` |
+| `PCP_USE_TLS` | Use HTTPS for pmproxy | `false` |
+| `PCP_TIMEOUT` | Request timeout (seconds) | `30` |
+| `PCP_USERNAME` | HTTP basic auth user | (optional) |
+| `PCP_PASSWORD` | HTTP basic auth password | (optional) |
+
+## 🎯 Usage
+
+### Monitor localhost (default)
+
+```bash
+pcp-mcp
+```
+
+### Monitor a remote host
+
+```bash
+PCP_TARGET_HOST=webserver1.example.com pcp-mcp
+```
+
+Or use the CLI flag:
+
+```bash
+pcp-mcp --target-host webserver1.example.com
+```
+
+### Connect to remote pmproxy
+
+```bash
+PCP_HOST=metrics.example.com pcp-mcp
+```
+
+### Use SSE transport
+
+```bash
+pcp-mcp --transport sse
+```
+
+## 🔌 MCP Client Configuration
+
+### Claude Desktop
+
+Add to `~/.config/claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "pcp": {
+      "command": "pcp-mcp"
+    }
+  }
+}
+```
+
+For remote monitoring:
+
+```json
+{
+  "mcpServers": {
+    "pcp": {
+      "command": "pcp-mcp",
+      "args": ["--target-host", "webserver1.example.com"]
+    }
+  }
+}
+```
+
+## 🛠️ Available Tools
+
+### System Monitoring
+
+- **`get_system_snapshot`** - Point-in-time system overview (CPU, memory, disk, network, load)
+- **`get_process_top`** - Top processes by CPU, memory, or I/O usage
+- **`query_metrics`** - Fetch current values for specific PCP metrics
+- **`search_metrics`** - Discover available metrics by name pattern
+- **`describe_metric`** - Get detailed metadata about a metric
+
+### Example Queries
+
+```
+"What's the current CPU usage?"
+→ Uses get_system_snapshot
+
+"Show me the top 10 processes by memory usage"
+→ Uses get_process_top(sort_by="memory", limit=10)
+
+"What metrics are available for network traffic?"
+→ Uses search_metrics(pattern="network")
+
+"Get detailed info about kernel.all.load"
+→ Uses describe_metric(name="kernel.all.load")
+```
+
+## 📚 Resources
+
+Browse metrics via MCP resources:
+
+- `pcp://metrics` - List all available metrics (grouped by prefix)
+- `pcp://system/snapshot` - Latest system snapshot
+- `pcp://processes/top` - Top processes
+
+## 💡 Use Cases
+
+### Performance Troubleshooting
+
+Ask Claude to:
+- "Analyze current system performance and identify bottlenecks"
+- "Why is my disk I/O so high?"
+- "Which processes are consuming the most CPU?"
+
+### System Monitoring
+
+- "Give me a health check of the production server"
+- "Compare CPU usage over the last minute"
+- "Monitor network traffic on eth0"
+
+### Capacity Planning
+
+- "What's the memory utilization trend?"
+- "Show me disk usage across all filesystems"
+- "Analyze process resource consumption patterns"
+
+## 🏗️ Architecture
+
+```
+┌─────────┐         ┌─────────┐         ┌─────────┐         ┌─────────┐
+│   LLM   │ ◄─MCP─► │ pcp-mcp │ ◄─HTTP─► │ pmproxy │ ◄─────► │  pmcd   │
+└─────────┘         └─────────┘         └─────────┘         └─────────┘
+                                         (REST API)          (metrics)
+```
+
+- **pcp-mcp**: FastMCP server exposing PCP metrics via MCP tools
+- **pmproxy**: PCP's REST API server (runs on port 44322 by default)
+- **pmcd**: PCP metrics collector daemon
+- **Remote monitoring**: Set `PCP_TARGET_HOST` to query a different pmcd instance via pmproxy
+
+## 🔧 Development
+
+```bash
+# Install dependencies
+uv sync --dev
+
+# Run all checks
+make check
+
+# Individual commands
+make lint       # ruff check
+make format     # ruff format
+make typecheck  # ty check
+make test       # pytest with coverage
+```
+
+## 📖 Documentation
+
+Full documentation at [https://major.github.io/pcp-mcp](https://major.github.io/pcp-mcp)
+
+## 📄 License
+
+MIT

pcp_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+pcp_mcp/__init__.py,sha256=u-jLAyQZEv6jKWvAfBOAkuNkh7AVQIMgrq3hX9KqvpM,1658
+pcp_mcp/client.py,sha256=CaEP8uVkMsfqLG-HDDhf4qnl3g4CgJBt0xpDcScgzzg,8151
+pcp_mcp/config.py,sha256=EvcHnVHMM9tHSklYmksA2zMmtUJnOLAc-LSCWz4HW68,1771
+pcp_mcp/context.py,sha256=Q7R8nB3UHxNxHVm2bKRnM7J2jXLIUv3eC3a1KfQWiQ4,1298
+pcp_mcp/errors.py,sha256=sIes9OSNdYQeOmwjFknhfXXjBjOOzXmc94bbB-4b_tg,1598
+pcp_mcp/models.py,sha256=GUILMSh9XGBt0Ayjt0-N8_ELl9K2jq78MD9ltdL-FBA,6390
+pcp_mcp/prompts/__init__.py,sha256=0XnHZQVYFjCOEPFI54CuJsRdfl4g_PhocHDepe6_OV4,12208
+pcp_mcp/resources/__init__.py,sha256=55Mm2ZCuyyQWWql9N8cLk6ld1pNj3Ezc416jgFX35dU,541
+pcp_mcp/resources/catalog.py,sha256=1TIZgZ-o5dec47ftSpSRSl1xMtnKJZZOCKjrs9xIpaE,10374
+pcp_mcp/resources/health.py,sha256=ekirrQdEnSI0VjFtXepeFlBjhshG0sDRrJpI2Ngh2Qs,2194
+pcp_mcp/server.py,sha256=1VIei1UdeXgIaiO00nPFfuXRJti48_bLKwkS8aCW-LM,4209
+pcp_mcp/tools/__init__.py,sha256=sXhOqqnUwzSf16QU6eS79LMvXJcv7jqSXQlrpQG4UV0,505
+pcp_mcp/tools/metrics.py,sha256=suu9X6JAYENdZjlQXqaGtFAqxkIGSoG5NNHCuZdlae0,4479
+pcp_mcp/tools/system.py,sha256=hrOu-xoCmQbmsGhGU2w7vmG1f-Sv7BMqLEnKSwFxD78,6942
+pcp_mcp/utils/__init__.py,sha256=HfZ2KM23RlO85sOLcrJG0Oii2YhOqq4SkeVKS0TLBmA,1031
+pcp_mcp/utils/builders.py,sha256=n13Ou6cb1-YToG-M31J8_jWajq8ioJx6tJTKnqaQiio,10293
+pcp_mcp/utils/decorators.py,sha256=FutKJgYjP6hgg9N388mycyzUTp-hTqwU_jYt_i39O5o,939
+pcp_mcp/utils/extractors.py,sha256=F977szuqUNBkhNa9Tx1nQio9YiiwKAkbWD9aROZ7sgo,1807
+pcp_mcp-0.1.0.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
+pcp_mcp-0.1.0.dist-info/entry_points.txt,sha256=PhVo92EGoS05yEpHVRyKEsxKya_bWlPLodp-g4tr2Rg,42
+pcp_mcp-0.1.0.dist-info/METADATA,sha256=gCYEaj2adv_Qw7gIgIX8_pbDJMA04MW0aUTg6A4QfNU,5708
+pcp_mcp-0.1.0.dist-info/RECORD,,

pcp_mcp-0.1.0.dist-info/WHEEL

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

pcp_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pcp-mcp = pcp_mcp:main
+