goliath-utils-docs 0.1.1__tar.gz

goliath_utils_docs-0.1.1/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: goliath-utils-docs
+Version: 0.1.1
+Summary: MCP server exposing goliath-utils API documentation to Claude Code
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.0
+Requires-Dist: goliath-utils>=0.1.3
+
+# goliath-utils-docs
+
+MCP server that exposes [goliath-utils](https://pypi.org/project/goliath-utils/) API documentation to Claude Code.
+
+When configured, Claude Code gains access to three tools:
+
+- **list_available_utils** — overview of all modules, classes, and functions
+- **get_module_docs** — full API reference for a specific module
+- **search_utils** — search across all utility APIs by keyword
+
+## Install
+
+```bash
+pip install goliath-utils-docs
+goliath-utils-docs install
+```
+
+This registers the MCP server in your Claude Code settings. Restart Claude Code to activate.
+
+## Uninstall
+
+```bash
+goliath-utils-docs uninstall
+```
+
+## Manual configuration
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "goliath-utils-docs": {
+      "command": "uvx",
+      "args": ["goliath-utils-docs", "serve"]
+    }
+  }
+}
+```

goliath_utils_docs-0.1.1/README.md

@@ -0,0 +1,39 @@
+# goliath-utils-docs
+
+MCP server that exposes [goliath-utils](https://pypi.org/project/goliath-utils/) API documentation to Claude Code.
+
+When configured, Claude Code gains access to three tools:
+
+- **list_available_utils** — overview of all modules, classes, and functions
+- **get_module_docs** — full API reference for a specific module
+- **search_utils** — search across all utility APIs by keyword
+
+## Install
+
+```bash
+pip install goliath-utils-docs
+goliath-utils-docs install
+```
+
+This registers the MCP server in your Claude Code settings. Restart Claude Code to activate.
+
+## Uninstall
+
+```bash
+goliath-utils-docs uninstall
+```
+
+## Manual configuration
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "goliath-utils-docs": {
+      "command": "uvx",
+      "args": ["goliath-utils-docs", "serve"]
+    }
+  }
+}
+```

goliath_utils_docs-0.1.1/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "goliath-utils-docs"
+version = "0.1.1"
+description = "MCP server exposing goliath-utils API documentation to Claude Code"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+  "mcp>=1.0",
+  "goliath-utils>=0.1.3",
+]
+
+[project.scripts]
+goliath-utils-docs = "goliath_utils_docs.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.package-data]
+goliath_utils_docs = ["supplements.json"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[dependency-groups]
+dev = [
+    "build>=1.4.2",
+    "twine>=6.2.0",
+]

goliath_utils_docs-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

goliath_utils_docs-0.1.1/src/goliath_utils_docs/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

goliath_utils_docs-0.1.1/src/goliath_utils_docs/__main__.py

@@ -0,0 +1,5 @@
+import asyncio
+
+from .server import main
+
+asyncio.run(main())

goliath_utils_docs-0.1.1/src/goliath_utils_docs/cli.py

@@ -0,0 +1,99 @@
+"""CLI for installing/uninstalling the MCP server and running it directly."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+SERVER_NAME = "goliath-utils-docs"
+MCP_CONFIG = {
+    "command": "uvx",
+    "args": ["goliath-utils-docs", "serve"],
+}
+
+
+def _global_settings_path() -> Path:
+    return Path.home() / ".claude" / "settings.json"
+
+
+def _project_settings_path() -> Path:
+    # Walk up to find a git root
+    cwd = Path.cwd()
+    for parent in [cwd, *cwd.parents]:
+        if (parent / ".git").exists():
+            return parent / ".claude" / "settings.json"
+    return cwd / ".claude" / "settings.json"
+
+
+def _read_settings(path: Path) -> dict:
+    if path.exists():
+        return json.loads(path.read_text(encoding="utf-8"))
+    return {}
+
+
+def _write_settings(path: Path, settings: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(settings, indent=2) + "\n", encoding="utf-8")
+
+
+def install(project: bool = False) -> None:
+    """Register the MCP server in Claude Code settings."""
+    path = _project_settings_path() if project else _global_settings_path()
+    settings = _read_settings(path)
+    settings.setdefault("mcpServers", {})
+    settings["mcpServers"][SERVER_NAME] = MCP_CONFIG
+    _write_settings(path, settings)
+    scope = "project" if project else "global"
+    print(f"Installed {SERVER_NAME} in {scope} settings: {path}")
+    print("Restart Claude Code to activate.")
+
+
+def uninstall(project: bool = False) -> None:
+    """Remove the MCP server from Claude Code settings."""
+    path = _project_settings_path() if project else _global_settings_path()
+    settings = _read_settings(path)
+    servers = settings.get("mcpServers", {})
+    if SERVER_NAME in servers:
+        del servers[SERVER_NAME]
+        _write_settings(path, settings)
+        scope = "project" if project else "global"
+        print(f"Removed {SERVER_NAME} from {scope} settings: {path}")
+    else:
+        print(f"{SERVER_NAME} not found in settings.")
+
+
+def serve() -> None:
+    """Run the MCP server (stdio transport)."""
+    from .server import main as server_main
+    asyncio.run(server_main())
+
+
+def main() -> None:
+    args = sys.argv[1:]
+
+    if not args or args[0] in ("-h", "--help"):
+        print("Usage: goliath-utils-docs <command>")
+        print()
+        print("Commands:")
+        print("  install    Register MCP server in Claude Code settings")
+        print("  uninstall  Remove MCP server from Claude Code settings")
+        print("  serve      Run the MCP server directly")
+        print()
+        print("Options:")
+        print("  --project  Use project-level settings instead of global")
+        return
+
+    command = args[0]
+    project = "--project" in args
+
+    if command == "install":
+        install(project=project)
+    elif command == "uninstall":
+        uninstall(project=project)
+    elif command == "serve":
+        serve()
+    else:
+        print(f"Unknown command: {command}")
+        sys.exit(1)

goliath_utils_docs-0.1.1/src/goliath_utils_docs/introspect.py

@@ -0,0 +1,435 @@
+"""Runtime introspection engine for goliath_utils.
+
+Imports goliath_utils submodules and extracts structured documentation
+from type annotations, docstrings, and supplemental descriptions.
+"""
+
+from __future__ import annotations
+
+import importlib
+import importlib.resources
+import inspect
+import json
+from dataclasses import dataclass, field
+from typing import Any
+
+MODULES = {
+    "atrax": "goliath_utils.atrax",
+    "s3": "goliath_utils.s3",
+    "sns": "goliath_utils.sns",
+    "secrets": "goliath_utils.secrets",
+    "helpers": "goliath_utils.helpers",
+}
+
+MODULE_DESCRIPTIONS = {
+    "atrax": "Pure-Python pandas alternative (Series, DataSet) with zero external dependencies",
+    "s3": "Lightweight S3 client using httpx and AWS SigV4 signing (no boto3)",
+    "sns": "Client for the Goliath notification/SNS API",
+    "secrets": "Client for the Goliath secrets management API",
+    "helpers": "S3 I/O helpers (CSV, JSON, Parquet), event parsing, and database insertion",
+}
+
+
+@dataclass
+class ParamDoc:
+    name: str
+    annotation: str
+    default: str | None
+    kind: str
+
+
+@dataclass
+class MethodDoc:
+    name: str
+    signature: str
+    docstring: str | None
+    params: list[ParamDoc]
+    return_annotation: str
+    is_property: bool = False
+
+
+@dataclass
+class ClassDoc:
+    name: str
+    docstring: str | None
+    methods: list[MethodDoc]
+    bases: list[str]
+
+
+@dataclass
+class FunctionDoc:
+    name: str
+    signature: str
+    docstring: str | None
+    params: list[ParamDoc]
+    return_annotation: str
+
+
+@dataclass
+class ModuleDoc:
+    name: str
+    full_path: str
+    description: str | None
+    docstring: str | None
+    classes: list[ClassDoc]
+    functions: list[FunctionDoc]
+
+
+def _load_supplements() -> dict[str, str]:
+    """Load supplemental one-liner docs from supplements.json."""
+    ref = importlib.resources.files("goliath_utils_docs").joinpath("supplements.json")
+    text = ref.read_text(encoding="utf-8")
+    return json.loads(text)
+
+
+def _format_annotation(ann: Any) -> str:
+    """Convert a type annotation to a readable string."""
+    if ann is inspect.Parameter.empty or ann is inspect.Signature.empty:
+        return ""
+    if isinstance(ann, str):
+        return ann
+    if hasattr(ann, "__name__"):
+        return ann.__name__
+    return str(ann).replace("typing.", "")
+
+
+def _extract_params(sig: inspect.Signature) -> list[ParamDoc]:
+    """Extract parameter documentation from a signature."""
+    params = []
+    for name, param in sig.parameters.items():
+        if name == "self":
+            continue
+        kind_map = {
+            inspect.Parameter.POSITIONAL_ONLY: "positional",
+            inspect.Parameter.POSITIONAL_OR_KEYWORD: "keyword",
+            inspect.Parameter.KEYWORD_ONLY: "keyword_only",
+            inspect.Parameter.VAR_POSITIONAL: "var_positional",
+            inspect.Parameter.VAR_KEYWORD: "var_keyword",
+        }
+        default = None
+        if param.default is not inspect.Parameter.empty:
+            default = repr(param.default)
+        params.append(ParamDoc(
+            name=name,
+            annotation=_format_annotation(param.annotation),
+            default=default,
+            kind=kind_map.get(param.kind, "unknown"),
+        ))
+    return params
+
+
+def _format_signature(obj: Any) -> str:
+    """Get a clean signature string for a callable."""
+    try:
+        sig = inspect.signature(obj)
+        parts = []
+        for name, param in sig.parameters.items():
+            if name == "self":
+                continue
+            ann = _format_annotation(param.annotation)
+            default = ""
+            if param.default is not inspect.Parameter.empty:
+                default = f" = {param.default!r}"
+            if param.kind == inspect.Parameter.VAR_POSITIONAL:
+                part = f"*{name}"
+            elif param.kind == inspect.Parameter.VAR_KEYWORD:
+                part = f"**{name}"
+            elif param.kind == inspect.Parameter.KEYWORD_ONLY:
+                part = name
+            else:
+                part = name
+            if ann:
+                part = f"{part}: {ann}"
+            part += default
+            parts.append(part)
+
+        ret = _format_annotation(sig.return_annotation)
+        ret_str = f" -> {ret}" if ret else ""
+        return f"({', '.join(parts)}){ret_str}"
+    except (ValueError, TypeError):
+        return "(...)"
+
+
+def _is_public_method(name: str) -> bool:
+    """Check if a name is a public method we should document."""
+    if name.startswith("__") and name.endswith("__"):
+        return name == "__init__"
+    return not name.startswith("_")
+
+
+def _extract_class(cls: type, supplements: dict[str, str]) -> ClassDoc:
+    """Extract documentation for a class."""
+    class_name = cls.__name__
+    methods = []
+
+    for name in sorted(cls.__dict__):
+        if not _is_public_method(name):
+            continue
+
+        attr = cls.__dict__[name]
+        is_prop = isinstance(attr, property)
+
+        if is_prop:
+            docstring = inspect.getdoc(attr.fget) if attr.fget else None
+            try:
+                sig = inspect.signature(attr.fget) if attr.fget else None
+                ret = _format_annotation(sig.return_annotation) if sig else ""
+            except (ValueError, TypeError):
+                ret = ""
+            methods.append(MethodDoc(
+                name=name,
+                signature=f"-> {ret}" if ret else "(property)",
+                docstring=supplements.get(f"{class_name}.{name}") or docstring,
+                params=[],
+                return_annotation=ret,
+                is_property=True,
+            ))
+        elif callable(attr) or isinstance(attr, (staticmethod, classmethod)):
+            actual = attr
+            if isinstance(attr, staticmethod):
+                actual = attr.__func__
+            elif isinstance(attr, classmethod):
+                actual = attr.__func__
+
+            # Use getattr on __doc__ directly to avoid inheriting generic docstrings
+            raw_doc = getattr(actual, "__doc__", None)
+            docstring = inspect.cleandoc(raw_doc) if raw_doc else None
+            sig_str = _format_signature(actual)
+            try:
+                sig = inspect.signature(actual)
+                params = _extract_params(sig)
+                ret = _format_annotation(sig.return_annotation)
+            except (ValueError, TypeError):
+                params = []
+                ret = ""
+
+            supplement = supplements.get(f"{class_name}.{name}")
+            methods.append(MethodDoc(
+                name=name,
+                signature=sig_str,
+                docstring=supplement or docstring,
+                params=params,
+                return_annotation=ret,
+                is_property=False,
+            ))
+
+    bases = [b.__name__ for b in cls.__bases__ if b is not object]
+
+    return ClassDoc(
+        name=class_name,
+        docstring=inspect.getdoc(cls),
+        methods=methods,
+        bases=bases,
+    )
+
+
+def _extract_function(name: str, func: Any, supplements: dict[str, str]) -> FunctionDoc:
+    """Extract documentation for a module-level function."""
+    docstring = inspect.getdoc(func)
+    sig_str = _format_signature(func)
+    try:
+        sig = inspect.signature(func)
+        params = _extract_params(sig)
+        ret = _format_annotation(sig.return_annotation)
+    except (ValueError, TypeError):
+        params = []
+        ret = ""
+
+    return FunctionDoc(
+        name=name,
+        signature=sig_str,
+        docstring=docstring or supplements.get(name),
+        params=params,
+        return_annotation=ret,
+    )
+
+
+def extract_module(short_name: str) -> ModuleDoc:
+    """Extract documentation for a single goliath_utils submodule."""
+    full_path = MODULES[short_name]
+    mod = importlib.import_module(full_path)
+    supplements = _load_supplements()
+
+    exported = getattr(mod, "__all__", None)
+    if exported is None:
+        exported = [n for n in dir(mod) if not n.startswith("_")]
+
+    classes = []
+    functions = []
+
+    for name in exported:
+        obj = getattr(mod, name)
+        if inspect.isclass(obj):
+            # Skip pure exception classes (just document their names)
+            if issubclass(obj, Exception) and obj is not Exception:
+                classes.append(ClassDoc(
+                    name=name,
+                    docstring=inspect.getdoc(obj),
+                    methods=[],
+                    bases=[b.__name__ for b in obj.__bases__ if b is not object],
+                ))
+            else:
+                classes.append(_extract_class(obj, supplements))
+        elif inspect.isfunction(obj):
+            functions.append(_extract_function(name, obj, supplements))
+
+    return ModuleDoc(
+        name=short_name,
+        full_path=full_path,
+        description=MODULE_DESCRIPTIONS.get(short_name),
+        docstring=inspect.getdoc(mod),
+        classes=classes,
+        functions=functions,
+    )
+
+
+def extract_all() -> dict[str, ModuleDoc]:
+    """Extract documentation for all goliath_utils submodules."""
+    result = {}
+    for short_name in MODULES:
+        try:
+            result[short_name] = extract_module(short_name)
+        except ImportError:
+            continue
+    return result
+
+
+def format_module_docs(doc: ModuleDoc) -> str:
+    """Format a ModuleDoc into readable markdown."""
+    lines = [f"# {doc.name}", ""]
+    if doc.description:
+        lines.append(doc.description)
+        lines.append("")
+    if doc.docstring:
+        lines.append(doc.docstring)
+        lines.append("")
+    lines.append(f"**Import**: `from goliath_utils.{doc.name} import ...`")
+    lines.append("")
+
+    for cls in doc.classes:
+        lines.append(f"## {cls.name}")
+        if cls.bases:
+            lines.append(f"Inherits from: {', '.join(cls.bases)}")
+        if cls.docstring:
+            lines.append("")
+            lines.append(cls.docstring)
+        lines.append("")
+
+        if not cls.methods:
+            lines.append("*(Exception class — raise/catch only)*")
+            lines.append("")
+            continue
+
+        for method in cls.methods:
+            if method.is_property:
+                lines.append(f"### `{cls.name}.{method.name}` (property)")
+                if method.return_annotation:
+                    lines.append(f"  Type: `{method.return_annotation}`")
+            else:
+                lines.append(f"### `{cls.name}.{method.name}{method.signature}`")
+
+            if method.docstring:
+                lines.append(f"  {method.docstring}")
+            lines.append("")
+
+    for func in doc.functions:
+        lines.append(f"## `{func.name}{func.signature}`")
+        if func.docstring:
+            lines.append("")
+            lines.append(func.docstring)
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def format_overview(docs: dict[str, ModuleDoc]) -> str:
+    """Format all modules into a high-level overview."""
+    lines = ["# goliath-utils API Overview", ""]
+    lines.append("A collection of pure-Python utilities for the Goliath platform.")
+    lines.append("")
+    lines.append("**Install**: `pip install goliath-utils`")
+    lines.append("")
+
+    for name, doc in docs.items():
+        lines.append(f"## {name}")
+        if doc.description:
+            lines.append(doc.description)
+        lines.append("")
+
+        for cls in doc.classes:
+            method_count = len([m for m in cls.methods if not m.is_property])
+            prop_count = len([m for m in cls.methods if m.is_property])
+            if cls.methods:
+                parts = []
+                if method_count:
+                    parts.append(f"{method_count} methods")
+                if prop_count:
+                    parts.append(f"{prop_count} properties")
+                lines.append(f"- **{cls.name}** ({', '.join(parts)})")
+            else:
+                lines.append(f"- **{cls.name}** (exception)")
+            if cls.docstring:
+                first_line = cls.docstring.split("\n")[0]
+                lines.append(f"  {first_line}")
+
+        for func in doc.functions:
+            lines.append(f"- **{func.name}()**")
+            if func.docstring:
+                first_line = func.docstring.split("\n")[0]
+                lines.append(f"  {first_line}")
+
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def search_docs(docs: dict[str, ModuleDoc], query: str, max_results: int = 10) -> str:
+    """Search across all documentation for matching methods/functions."""
+    terms = query.lower().split()
+    results: list[tuple[float, str]] = []
+
+    for mod_name, doc in docs.items():
+        for cls in doc.classes:
+            for method in cls.methods:
+                score = _score_match(terms, method.name, method.docstring, method.signature)
+                if score > 0:
+                    desc = method.docstring or "(no description)"
+                    if method.is_property:
+                        entry = f"**{cls.name}.{method.name}** (property)\n  {desc}"
+                    else:
+                        entry = f"**{cls.name}.{method.name}**`{method.signature}`\n  {desc}"
+                    entry = f"[{mod_name}] {entry}"
+                    results.append((score, entry))
+
+        for func in doc.functions:
+            score = _score_match(terms, func.name, func.docstring, func.signature)
+            if score > 0:
+                desc = func.docstring or "(no description)"
+                entry = f"[{mod_name}] **{func.name}**`{func.signature}`\n  {desc}"
+                results.append((score, entry))
+
+    results.sort(key=lambda x: -x[0])
+    top = results[:max_results]
+
+    if not top:
+        return f"No results found for: {query}"
+
+    lines = [f"# Search results for: {query}", ""]
+    for _, entry in top:
+        lines.append(f"- {entry}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+def _score_match(terms: list[str], name: str, docstring: str | None, signature: str) -> float:
+    """Score how well a method matches search terms."""
+    text = f"{name} {docstring or ''} {signature}".lower()
+    score = 0.0
+    for term in terms:
+        if term in name.lower():
+            score += 3.0  # name match is strongest
+        elif docstring and term in docstring.lower():
+            score += 1.5
+        elif term in signature.lower():
+            score += 1.0
+    return score

goliath_utils_docs-0.1.1/src/goliath_utils_docs/server.py

@@ -0,0 +1,117 @@
+"""MCP server exposing goliath-utils documentation to Claude Code."""
+
+from __future__ import annotations
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import TextContent, Tool
+
+from .introspect import (
+    ModuleDoc,
+    extract_all,
+    extract_module,
+    format_module_docs,
+    format_overview,
+    search_docs,
+    MODULES,
+)
+
+app = Server("goliath-utils-docs")
+
+_docs: dict[str, ModuleDoc] | None = None
+
+
+def _get_docs() -> dict[str, ModuleDoc]:
+    global _docs
+    if _docs is None:
+        _docs = extract_all()
+    return _docs
+
+
+@app.list_tools()
+async def list_tools() -> list[Tool]:
+    return [
+        Tool(
+            name="list_available_utils",
+            description=(
+                "List all available goliath-utils modules, classes, and functions "
+                "with a high-level overview. Call this first to understand what "
+                "utilities are available."
+            ),
+            inputSchema={"type": "object", "properties": {}},
+        ),
+        Tool(
+            name="get_module_docs",
+            description=(
+                "Get full API documentation for a specific goliath-utils module. "
+                "Returns all classes, methods with signatures and descriptions. "
+                "Modules: atrax, s3, sns, secrets, helpers."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "module": {
+                        "type": "string",
+                        "description": "Module name: atrax, s3, sns, secrets, or helpers",
+                        "enum": list(MODULES.keys()),
+                    },
+                },
+                "required": ["module"],
+            },
+        ),
+        Tool(
+            name="search_utils",
+            description=(
+                "Search across all goliath-utils APIs by keyword. "
+                "Returns matching methods and functions with their signatures "
+                "and descriptions. Useful when you know what you want to do "
+                "but not which module or method to use."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search terms (e.g., 'groupby aggregate', 'upload file s3', 'merge join')",
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+    ]
+
+
+@app.call_tool()
+async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+    docs = _get_docs()
+
+    if name == "list_available_utils":
+        text = format_overview(docs)
+        return [TextContent(type="text", text=text)]
+
+    elif name == "get_module_docs":
+        module = arguments.get("module", "")
+        if module not in MODULES:
+            return [TextContent(
+                type="text",
+                text=f"Unknown module: {module}. Available: {', '.join(MODULES.keys())}",
+            )]
+        doc = docs.get(module)
+        if doc is None:
+            return [TextContent(type="text", text=f"Module {module} could not be loaded.")]
+        text = format_module_docs(doc)
+        return [TextContent(type="text", text=text)]
+
+    elif name == "search_utils":
+        query = arguments.get("query", "")
+        if not query.strip():
+            return [TextContent(type="text", text="Please provide a search query.")]
+        text = search_docs(docs, query)
+        return [TextContent(type="text", text=text)]
+
+    return [TextContent(type="text", text=f"Unknown tool: {name}")]
+
+
+async def main():
+    async with stdio_server() as (read, write):
+        await app.run(read, write, app.create_initialization_options())

goliath_utils_docs-0.1.1/src/goliath_utils_docs/supplements.json

@@ -0,0 +1,118 @@
+{
+  "Series.head": "Return the first n elements (default 5).",
+  "Series.tail": "Return the last n elements (default 5).",
+  "Series.values": "Return the underlying data as a plain list.",
+  "Series.index": "Return the index labels as a list.",
+  "Series.shape": "Return a tuple with the number of elements.",
+  "Series.size": "Return the number of elements.",
+  "Series.empty": "True if the Series has no elements.",
+  "Series.loc": "Label-based indexer. Supports scalar, list, slice, and boolean Series keys.",
+  "Series.iloc": "Position-based indexer. Supports int, list of ints, and slice keys.",
+  "Series.str": "Accessor for vectorized string operations (lower, upper, contains, replace, etc.).",
+  "Series.__init__": "Construct from a list, dict, scalar (with index), or another Series. Optionally specify dtype and name.",
+  "Series.sum": "Return the sum of non-NA values. Returns 0 for empty Series.",
+  "Series.mean": "Return the mean of non-NA values. Returns NA for empty Series.",
+  "Series.median": "Return the median of non-NA values. Returns NA for empty Series.",
+  "Series.min": "Return the minimum non-NA value. Returns NA for empty Series.",
+  "Series.max": "Return the maximum non-NA value. Returns NA for empty Series.",
+  "Series.std": "Return the standard deviation. ddof=1 (sample) by default.",
+  "Series.var": "Return the variance. ddof=1 (sample) by default.",
+  "Series.quantile": "Return value at the given quantile (0-1). Pass a list for multiple quantiles, returns a Series.",
+  "Series.count": "Return the number of non-NA values.",
+  "Series.nunique": "Return the number of unique non-NA values.",
+  "Series.value_counts": "Return a Series of unique value counts, sorted descending.",
+  "Series.any": "Return True if any non-NA value is truthy.",
+  "Series.all": "Return True if all non-NA values are truthy (or Series is empty).",
+  "Series.apply": "Apply a function element-wise. NA values propagate.",
+  "Series.map": "Map values using a dict or function. Unmapped dict keys become NA.",
+  "Series.sort_values": "Sort by values. ascending=True by default. NA values go to the end.",
+  "Series.sort_index": "Sort by index labels. ascending=True by default.",
+  "Series.rank": "Rank values. method='average' by default. Options: average, min, max, first, dense.",
+  "Series.drop_duplicates": "Remove duplicate values. keep='first' (default), 'last', or False (drop all duplicates).",
+  "Series.fillna": "Replace NA values with the given value.",
+  "Series.dropna": "Remove NA values, returning a shorter Series.",
+  "Series.astype": "Cast values to the specified type (e.g., int, float, str).",
+  "Series.rename": "Return a copy with a new name.",
+  "Series.reset_index": "Reset to integer index. drop=False returns (old_index_series, value_series). drop=True returns just the value Series.",
+  "Series.copy": "Return a deep copy of the Series.",
+  "Series.items": "Iterate over (index_label, value) pairs.",
+
+  "DataSet.__init__": "Construct from a dict of lists/Series, a list of dicts, or another DataSet. Optionally specify index and columns.",
+  "DataSet.columns": "Return the column names as a list.",
+  "DataSet.index": "Return the index labels as a list.",
+  "DataSet.shape": "Return (n_rows, n_cols) tuple.",
+  "DataSet.size": "Return total number of elements (rows * cols).",
+  "DataSet.empty": "True if the DataSet has no rows.",
+  "DataSet.dtypes": "Return a Series of column dtypes.",
+  "DataSet.values": "Return data as a list of lists (one inner list per row).",
+  "DataSet.loc": "Label-based indexer. Supports ds.loc[row] and ds.loc[row, col].",
+  "DataSet.iloc": "Position-based indexer. Supports ds.iloc[row] and ds.iloc[row, col].",
+  "DataSet.T": "Transpose the DataSet (swap rows and columns).",
+  "DataSet.sum": "Sum per column (axis=0) or per row (axis=1). Returns a Series.",
+  "DataSet.mean": "Mean per column (axis=0) or per row (axis=1). Returns a Series.",
+  "DataSet.median": "Median per column (axis=0) or per row (axis=1). Returns a Series.",
+  "DataSet.min": "Min per column (axis=0) or per row (axis=1). Returns a Series.",
+  "DataSet.max": "Max per column (axis=0) or per row (axis=1). Returns a Series.",
+  "DataSet.std": "Standard deviation per column/row. ddof=1 by default.",
+  "DataSet.var": "Variance per column/row. ddof=1 by default.",
+  "DataSet.count": "Count non-NA values per column (axis=0) or per row (axis=1).",
+  "DataSet.nunique": "Count unique non-NA values per column or row.",
+  "DataSet.any": "True per column/row if any value is truthy.",
+  "DataSet.all": "True per column/row if all values are truthy.",
+  "DataSet.describe": "Generate summary statistics (count, mean, std, min, 25%, 50%, 75%, max) for numeric columns.",
+  "DataSet.sort_values": "Sort rows by one or more columns. by accepts str or list[str]. ascending=True by default.",
+  "DataSet.sort_index": "Sort rows by index labels. ascending=True by default.",
+  "DataSet.fillna": "Replace NA values with the given value across all columns.",
+  "DataSet.dropna": "Remove rows (axis=0) or columns (axis=1) with NA values. how='any' drops if any NA, how='all' drops if all NA.",
+  "DataSet.apply": "Apply a function per column (axis=0) returning a Series, or per row (axis=1) returning a DataSet.",
+  "DataSet.astype": "Cast columns. Pass a single type for all columns, or a dict mapping column names to types.",
+  "DataSet.rename": "Rename columns using a dict mapping old names to new names.",
+  "DataSet.reset_index": "Reset to integer index. drop=True discards old index, drop=False (default) adds it as an 'index' column.",
+  "DataSet.drop": "Drop columns by name. Accepts a single column name or a list.",
+  "DataSet.select_dtypes": "Select columns by dtype. include accepts a type or list of types.",
+  "DataSet.copy": "Return a deep copy of the DataSet.",
+  "DataSet.head": "Return the first n rows (default 5).",
+  "DataSet.tail": "Return the last n rows (default 5).",
+  "DataSet.to_dict": "Convert to dict. orient='dict' (default) returns {col: {idx: val}}, orient='records' returns list of row dicts.",
+  "DataSet.to_series": "Convert a single-column DataSet to a Series. Raises if more than one column.",
+  "DataSet.equals": "Return True if two DataSets have identical data, index, and columns.",
+  "DataSet.merge": "Join two DataSets. on= for shared key, or left_on=/right_on= for different keys. how='inner' (default), 'left', 'right', 'outer'. suffixes=('_x','_y') for conflicting column names.",
+  "DataSet.groupby": "Group by one or more columns. Returns a _GroupBy object with sum/mean/median/min/max/std/var/count/agg methods.",
+  "DataSet.melt": "Unpivot from wide to long format. id_vars= columns to keep, value_vars= columns to melt, var_name/value_name for output column names.",
+  "DataSet.pivot": "Pivot from long to wide format. index= row labels, columns= new column headers, values= cell values.",
+  "DataSet.items": "Iterate over (column_name, Series) pairs.",
+  "DataSet.iterrows": "Iterate over (index_label, row_Series) pairs.",
+  "DataSet.itertuples": "Iterate over rows as tuples. First element is the index label.",
+
+  "_GroupBy.sum": "Sum each group's non-key columns.",
+  "_GroupBy.mean": "Mean of each group's non-key columns.",
+  "_GroupBy.median": "Median of each group's non-key columns.",
+  "_GroupBy.min": "Min of each group's non-key columns.",
+  "_GroupBy.max": "Max of each group's non-key columns.",
+  "_GroupBy.std": "Standard deviation of each group. ddof=1 by default.",
+  "_GroupBy.var": "Variance of each group. ddof=1 by default.",
+  "_GroupBy.count": "Count non-NA values in each group.",
+  "_GroupBy.agg": "Aggregate with a string method name, callable, or dict mapping columns to methods/callables.",
+
+  "StringAccessor.lower": "Convert strings to lowercase.",
+  "StringAccessor.upper": "Convert strings to uppercase.",
+  "StringAccessor.strip": "Strip leading and trailing whitespace.",
+  "StringAccessor.contains": "Test if pattern is contained in each string. Returns a boolean Series.",
+  "StringAccessor.replace": "Replace occurrences of pat with repl in each string.",
+  "StringAccessor.len": "Return the length of each string as an integer Series.",
+  "StringAccessor.startswith": "Test if each string starts with prefix. Returns a boolean Series.",
+  "StringAccessor.endswith": "Test if each string ends with suffix. Returns a boolean Series.",
+  "StringAccessor.split": "Split each string by separator. Returns a Series of lists.",
+
+  "S3Client.__init__": "Create an S3 client. Reads credentials from args or env vars: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION.",
+  "S3Client.create_bucket": "Create a new S3 bucket.",
+  "S3Client.delete_bucket": "Delete an empty S3 bucket.",
+  "S3Client.delete_object": "Delete an object from S3.",
+  "S3Client.copy_object": "Copy an object from src_bucket/src_key to dest_bucket/dest_key.",
+  "S3Client.move_object": "Move an object (copy + delete source).",
+  "S3Client.upload_file": "Upload a local file to S3.",
+  "S3Client.download_file": "Download an S3 object to a local file path.",
+  "S3Client.list_objects": "List object keys in a bucket, optionally filtered by prefix. Handles pagination automatically.",
+
+  "is_na": "Test if a value is NA (the Atrax missing-value sentinel). Returns True for NA, False otherwise."
+}

goliath_utils_docs-0.1.1/src/goliath_utils_docs.egg-info/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: goliath-utils-docs
+Version: 0.1.1
+Summary: MCP server exposing goliath-utils API documentation to Claude Code
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.0
+Requires-Dist: goliath-utils>=0.1.3
+
+# goliath-utils-docs
+
+MCP server that exposes [goliath-utils](https://pypi.org/project/goliath-utils/) API documentation to Claude Code.
+
+When configured, Claude Code gains access to three tools:
+
+- **list_available_utils** — overview of all modules, classes, and functions
+- **get_module_docs** — full API reference for a specific module
+- **search_utils** — search across all utility APIs by keyword
+
+## Install
+
+```bash
+pip install goliath-utils-docs
+goliath-utils-docs install
+```
+
+This registers the MCP server in your Claude Code settings. Restart Claude Code to activate.
+
+## Uninstall
+
+```bash
+goliath-utils-docs uninstall
+```
+
+## Manual configuration
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "goliath-utils-docs": {
+      "command": "uvx",
+      "args": ["goliath-utils-docs", "serve"]
+    }
+  }
+}
+```

goliath_utils_docs-0.1.1/src/goliath_utils_docs.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+src/goliath_utils_docs/__init__.py
+src/goliath_utils_docs/__main__.py
+src/goliath_utils_docs/cli.py
+src/goliath_utils_docs/introspect.py
+src/goliath_utils_docs/server.py
+src/goliath_utils_docs/supplements.json
+src/goliath_utils_docs.egg-info/PKG-INFO
+src/goliath_utils_docs.egg-info/SOURCES.txt
+src/goliath_utils_docs.egg-info/dependency_links.txt
+src/goliath_utils_docs.egg-info/entry_points.txt
+src/goliath_utils_docs.egg-info/requires.txt
+src/goliath_utils_docs.egg-info/top_level.txt

goliath_utils_docs-0.1.1/src/goliath_utils_docs.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

goliath_utils_docs-0.1.1/src/goliath_utils_docs.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+goliath-utils-docs = goliath_utils_docs.cli:main

goliath_utils_docs-0.1.1/src/goliath_utils_docs.egg-info/requires.txt

@@ -0,0 +1,2 @@
+mcp>=1.0
+goliath-utils>=0.1.3

goliath_utils_docs-0.1.1/src/goliath_utils_docs.egg-info/top_level.txt

@@ -0,0 +1 @@
+goliath_utils_docs