Dependencies for phuryn/pm-skills: Complete Standard Library Breakdown

The phuryn/pm-skills repository operates with zero external dependencies, utilizing only Python 3.6+ standard library modules to validate and manage Claude plugins.

The phuryn/pm-skills repository is a collection of Markdown-based Claude plugins that provide product management skills and commands. Unlike typical Python projects that rely on requirements.txt or pyproject.toml files, this repository ships with no third-party dependencies whatsoever. Every script, including the validation tooling in validate_plugins.py, runs exclusively on built-in Python modules.

Standard Library Modules in phuryn/pm-skills

Since the repository contains no requirements.txt, Pipfile, package.json, or similar dependency definition files, all functionality derives from Python's built-in capabilities:

• json: Loads plugin.json manifest files located in each .claude-plugin directory
• os and pathlib: Handles file-system navigation to locate plugin directories and read/write files
• re: Performs simple regular-expression parsing for front-matter and cross-references in Markdown files
• sys: Manages process arguments and controls exit codes in validate_plugins.py
• typing.Optional: Provides type hints for helper functions throughout the codebase
• io: Ensures UTF-8 output on Windows terminals (platform-specific usage)

Core Implementation: validate_plugins.py

The sole executable Python script, validate_plugins.py, demonstrates how the repository achieves full functionality without external packages.

Validating Plugin Manifests

The script uses json and os to parse plugin configurations:

import json, os

def validate_manifest(plugin_dir):
    pj_path = os.path.join(plugin_dir, ".claude-plugin", "plugin.json")
    with open(pj_path, "r") as f:
        data = json.load(f)          # ← standard-library JSON parser

    # …perform checks on `data`…

Directory Discovery

File system traversal relies entirely on os:

import os, sys

base_path = os.path.dirname(os.path.abspath(__file__))
plugin_dirs = [
    os.path.join(base_path, d)
    for d in os.listdir(base_path)
    if os.path.isdir(os.path.join(base_path, d, ".claude-plugin"))
]
print(f"Found {len(plugin_dirs)} plugins")

Front-Matter Parsing Without External YAML Libraries

Rather than importing PyYAML or similar packages, the repository uses the re module for simple front-matter extraction:

import re

def parse_yaml_frontmatter(content: str):
    if not content.startswith("---"):
        return None
    end = content.find("---", 3)
    fm_text = content[3:end].strip()
    result = {}
    for line in fm_text.split("\n"):
        match = re.match(r'^(\S+):\s*(.+)$', line)
        if match:
            result[match.group(1)] = match.group(2).strip('"\'')
    return result

Repository Structure and Key Files

Understanding the dependencies requires examining how the repository organizes its code:

• validate_plugins.py: The only executable Python script that validates the plugin collection using standard library modules
• .claude-plugin/plugin.json: Manifest files required by Claude for each plugin, parsed using the built-in json module
• README.md: Top-level documentation containing installation instructions (which simply require Python 3.x)
• pm-toolkit/README.md: Documentation for the toolkit's available skills and commands
• Domain-specific collections: pm-product-strategy/README.md, pm-go-to-market/README.md, and similar Markdown files that constitute the actual plugin content

Runtime Requirements

Because phuryn/pm-skills has no external dependencies, deployment is straightforward:

1. Python 3.6+: Any version that includes the standard modules listed above
2. No package managers: No need for pip, npm, yarn, or poetry
3. Claude platform: The plugins run inside the Claude environment as Markdown-based skills

This zero-dependency architecture makes the repository lightweight and environment-agnostic, requiring only a basic Python interpreter to execute validation scripts.

Summary

• phuryn/pm-skills has zero external dependencies and requires no requirements.txt or package.json
• The repository relies exclusively on Python 3.6+ standard library modules including json, os, pathlib, re, sys, typing, and io
• The validate_plugins.py script performs all validation using only built-in functionality
• Plugin manifests (.claude-plugin/plugin.json) are parsed with the standard json module
• No third-party YAML parsers are needed; front-matter is handled via the re module
• The only runtime requirement is a Python 3.x interpreter

Frequently Asked Questions

Does phuryn/pm-skills require pip install?

No. The repository contains no requirements.txt, Pipfile, or pyproject.toml files. Since all code in validate_plugins.py uses only Python standard library modules like json, os, and re, you never need to run pip install to use or validate the plugins.

What Python version is required for phuryn/pm-skills?

Any Python 3.6 or higher installation will work. The repository uses standard library features available since Python 3.6, including pathlib and typing.Optional. No specific minor version features beyond 3.6 are required.

Are there any Node.js dependencies in pm-skills?

No. Despite being a collection of Claude plugins (which can sometimes involve JavaScript), phuryn/pm-skills is implemented entirely in Markdown and Python. There is no package.json file, and the validation logic in validate_plugins.py is pure Python.

How does validate_plugins.py work without external libraries?

The script implements lightweight alternatives to heavy dependencies. Instead of using PyYAML for front-matter, it uses the re module for simple pattern matching. Instead of external CLI frameworks, it uses sys for basic argument handling and exit codes. JSON validation uses the built-in json module rather than ujson or similar accelerators.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}