claude-code-capabilities 0.1.2__py3-none-any.whl

capdisc/scope/types.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+from enum import StrEnum
+from pathlib import Path
+from typing import Annotated
+
+from pydantic import Field
+
+ARTIFACT_CONTENT_MAX_CHARS = 200_000  # length cap of ArtifactContents; _safe_read enforces it
+
+
+class ScopeKind(StrEnum):
+    """Who sees a definition. Not every artifact supports every scope — session is subagents
+    via --agents, component is a hook living in a skill/agent's frontmatter."""
+
+    managed = "managed"
+    session = "session"
+    project = "project"
+    user = "user"
+    plugin = "plugin"
+    component = "component"
+
+
+class Shareability(StrEnum):
+    """How a definition is (or is not) shared — the mechanism behind the docs' Shareable column."""
+
+    committed = "committed"  # in-repo, e.g. .claude/settings.json, .claude/agents/
+    gitignored = "gitignored"  # .claude/settings.local.json
+    machine_local = "machine_local"  # ~/.claude/*, this machine only
+    admin = "admin"  # managed policy, admin-controlled
+    bundled = "bundled"  # shipped inside a plugin
+    in_component = "in_component"  # embedded in a host component's frontmatter
+    ephemeral = "ephemeral"  # in-memory only, e.g. --agents JSON
+
+
+class ArtifactKind(StrEnum):
+    """A kind of scoped artifact Claude Code loads. Storage differs by kind: agents/skills/
+    commands are standalone files, hooks are settings entries or frontmatter."""
+
+    agent = "agent"
+    skill = "skill"
+    command = "command"
+    hook = "hook"
+
+
+class ResolutionMode(StrEnum):
+    """How same-named definitions across scopes combine. Collision: the highest-precedence one
+    wins (agents, skills, commands). Additive: every matching one fires (hooks)."""
+
+    collision = "collision"
+    additive = "additive"
+
+
+ScopeRoot = Annotated[
+    str,
+    Field(
+        min_length=1,
+        max_length=120,
+        title="Scope root",
+        description="Filesystem root a scope's artifacts live under.",
+        examples=[".claude", "~/.claude"],
+    ),
+]
+ArtifactSubdir = Annotated[
+    str,
+    Field(
+        pattern=r"^[a-z]+$",
+        title="Artifact subdir",
+        description="Subdirectory under a scope root that holds one artifact kind.",
+        examples=["agents", "skills"],
+    ),
+]
+GlobPattern = Annotated[
+    str,
+    Field(
+        min_length=1,
+        max_length=64,
+        title="Glob pattern",
+        description="Glob, relative to an artifact's subdir, that matches its entry files.",
+        examples=["**/*.md", "**/SKILL.md"],
+    ),
+]
+SettingsFile = Annotated[
+    str,
+    Field(
+        min_length=1,
+        max_length=64,
+        title="Settings file",
+        description="Name of the JSON file a settings-entry artifact lives inside.",
+        examples=["settings.json", "settings.local.json", "hooks/hooks.json"],
+    ),
+]
+JsonKey = Annotated[
+    str,
+    Field(
+        pattern=r"^[a-zA-Z][a-zA-Z0-9_]*$",
+        title="JSON key",
+        description="Top-level key, inside a settings file or frontmatter, holding the entries.",
+        examples=["hooks", "mcpServers"],
+    ),
+]
+CliFlag = Annotated[
+    str,
+    Field(
+        pattern=r"^--[a-z][a-z-]*$",
+        title="CLI flag",
+        description="Launch flag that supplies an in-memory definition.",
+        examples=["--agents"],
+    ),
+]
+ArtifactName = Annotated[
+    str,
+    Field(
+        min_length=1,
+        max_length=128,
+        title="Artifact name",
+        description="Path-derived label for a captured artifact; its true identity is the "
+        "name frontmatter inside contents.",
+        examples=["code-reviewer"],
+    ),
+]
+ArtifactPath = Annotated[
+    Path,
+    Field(
+        title="Artifact path",
+        description="Exact filesystem path of a captured artifact (None when supplied in-memory).",
+        examples=["~/.claude/agents/code-reviewer.md"],
+    ),
+]
+ArtifactContents = Annotated[
+    str,
+    Field(
+        max_length=ARTIFACT_CONTENT_MAX_CHARS,
+        title="Artifact contents",
+        description="Raw text of a captured artifact file.",
+    ),
+]
+ResolutionRank = Annotated[
+    int,
+    Field(
+        ge=0,
+        title="Resolution rank",
+        description="Precedence position when names collide — 0 is highest, larger loses. "
+        "Encodes both cross-scope order and nearest-first depth within project scope.",
+    ),
+]
+ScanBasePath = Annotated[
+    Path,
+    Field(
+        title="Scan base path",
+        description="Concrete filesystem directory scanned for a scope's artifacts.",
+        examples=["~/.claude", "/repo/.claude"],
+    ),
+]

capdisc/settings.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+from functools import cache
+from pathlib import Path
+from typing import Annotated
+
+from pydantic import Field
+from pydantic_settings import (
+    BaseSettings,
+    JsonConfigSettingsSource,
+    PydanticBaseSettingsSource,
+    SettingsConfigDict,
+    YamlConfigSettingsSource,
+)
+
+from .base import InputModel
+from .hooks import EnvVarName
+
+ExtraSourceDir = Annotated[
+    Path,
+    Field(
+        title="Extra source directory",
+        description=(
+            "A filesystem directory contributed to discovery as a cataloged source. "
+            "These dirs are cataloged as discovery data only — never honored as active "
+            "hooks or MCP servers; that boundary is enforced upstream."
+        ),
+        examples=["/home/user/my-org-skills", "/opt/shared-agents"],
+    ),
+]
+ExactHostname = Annotated[
+    str,
+    Field(
+        title="Exact hostname",
+        description="Hostname a server's url must resolve to before a credential is attached.",
+        examples=["api.githubcopilot.com"],
+    ),
+]
+OAuthClientId = Annotated[
+    str,
+    Field(
+        title="OAuth client id",
+        description="Pre-registered OAuth client id for an authorization server without dynamic "
+        "client registration.",
+        examples=["abc123"],
+    ),
+]
+OAuthScope = Annotated[
+    str,
+    Field(
+        title="OAuth scope",
+        description="One OAuth scope requested for a pre-registered client.",
+        examples=["read:user"],
+    ),
+]
+CallbackPort = Annotated[
+    int,
+    Field(
+        title="OAuth callback port",
+        description="Fixed localhost callback port for an OAuth app registered with an exact "
+        "redirect URL.",
+        ge=1,
+        le=65535,
+        examples=[8765],
+    ),
+]
+PluginsRootPath = Annotated[
+    Path,
+    Field(title="Plugins root", description="Root holding installed_plugins.json."),
+]
+ClaudeJsonPath = Annotated[
+    Path,
+    Field(
+        title="Claude JSON path",
+        description="User/project MCP server config (~/.claude.json).",
+    ),
+]
+UserSettingsPath = Annotated[
+    Path,
+    Field(
+        title="User settings path",
+        description="User settings.json, read for plugin user_config options.",
+    ),
+]
+McpCachePath = Annotated[
+    Path,
+    Field(title="MCP cache path", description="Tool-enriched MCP server cache."),
+]
+ReportDirPath = Annotated[
+    Path,
+    Field(
+        title="Report directory",
+        description="Directory the discovery report (json + html) is written to.",
+    ),
+]
+OAuthTokenDirPath = Annotated[
+    Path,
+    Field(
+        title="OAuth token directory",
+        description="OAuth token cache for `--oauth` harvests. Plaintext files, dir mode 0700.",
+    ),
+]
+
+DEFAULT_CONFIG_PATH: Path = Path.home() / ".claude" / "capdisc" / "config.json"
+DEFAULT_YAML_CONFIG_PATH: Path = Path.home() / ".claude" / "capdisc" / "config.yaml"
+
+
+class McpBearerAuth(InputModel):
+    """A bearer credential for one HTTP MCP server, bound to the exact host it may be sent to.
+
+    Keyed by bare server name (matched case-insensitively), but the name alone never grants the
+    credential — a plugin cannot receive it by simply declaring a same-named server, since the
+    server's own `url` must resolve to `host` before the token is attached."""
+
+    env: EnvVarName
+    host: ExactHostname
+
+
+class McpOAuthClient(InputModel):
+    """A pre-registered OAuth client for one HTTP MCP server, used by the opt-in `--oauth`
+    harvest. Required for authorization servers without dynamic client registration (GitHub).
+    The secret itself is never stored here — only the name of the env var that holds it.
+
+    Bound to `host` for the same reason as `McpBearerAuth`: the bare-name key alone must never
+    be enough for a same-named server to receive the client credentials."""
+
+    client_id: OAuthClientId
+    host: ExactHostname
+    scopes: list[OAuthScope] = Field(default_factory=list)
+    secret_env: EnvVarName | None = Field(
+        default=None,
+        description="Name of the env var holding the client secret; omit for PKCE-only clients.",
+    )
+    callback_port: CallbackPort | None = Field(
+        default=None,
+        description="Omit to use a random free port.",
+    )
+
+
+class DiscoverySettings(BaseSettings):
+    """Paths and source dirs the discovery layer reads from and writes to.
+
+    Precedence (highest to lowest): init args > env vars > .env file > JSON config file >
+    YAML config file > defaults. Env vars use the ``CAPDISC_`` prefix; the
+    .env, JSON, and YAML files are all read from ``~/.claude/capdisc/`` (any
+    or all may be absent = empty, never an error) — never from the process's current working
+    directory, so running this tool from inside an untrusted checkout can't override
+    ``claude_json``/``plugins_root`` via a repo-committed ``.env`` and defeat the harvest's own
+    exclusion of untrusted project config (see ``scope_server_configs``). For a scalar or list
+    field set in both JSON and YAML, the JSON value wins outright. For a dict-typed field
+    (``mcp_bearer_env``, ``mcp_oauth_clients``), the two files are deep-merged instead — keys
+    present in both compose recursively, and only an actual leaf conflict picks JSON's value.
+    Subclasses may override ``model_config`` to change the prefix or config file paths.
+
+    ``extra_scan_dirs`` and ``extra_plugin_dirs`` are cataloged as discovery data only —
+    never honored as active hooks or MCP servers; that boundary is enforced upstream.
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="CAPDISC_",
+        env_file=DEFAULT_CONFIG_PATH.parent / ".env",
+        extra="ignore",
+        json_file=DEFAULT_CONFIG_PATH,
+        yaml_file=DEFAULT_YAML_CONFIG_PATH,
+    )
+
+    extra_scan_dirs: list[ExtraSourceDir] = Field(default_factory=list[ExtraSourceDir])
+    extra_plugin_dirs: list[ExtraSourceDir] = Field(default_factory=list[ExtraSourceDir])
+
+    # Locations discovery reads from / writes to; each independently overridable.
+    plugins_root: PluginsRootPath = Field(
+        default_factory=lambda: Path.home() / ".claude" / "plugins"
+    )
+    claude_json: ClaudeJsonPath = Field(default_factory=lambda: Path.home() / ".claude.json")
+    user_settings: UserSettingsPath = Field(
+        default_factory=lambda: Path.home() / ".claude" / "settings.json"
+    )
+    mcp_cache: McpCachePath = Field(
+        default_factory=lambda: (
+            Path.home() / ".claude" / "capdisc" / "mcp-tools.json"
+        )
+    )
+    report_dir: ReportDirPath = Field(
+        default_factory=lambda: Path.home() / ".claude" / "capdisc"
+    )
+
+    # Auth for HTTP MCP servers the anonymous probe can't reach. Keyed by bare server name
+    # (the last segment of the ref, e.g. "github" for plugin:github:github). The name is only
+    # a lookup key, not a trust boundary — `host` is what actually gates the credential.
+    mcp_bearer_env: dict[str, McpBearerAuth] = Field(
+        default_factory=dict,
+        description="Server name → {env, host} for a bearer token, e.g. "
+        '{"github": {"env": "GH_TOKEN", "host": "api.githubcopilot.com"}}. Non-interactive; '
+        "used whenever the var is set and the server's url matches host.",
+    )
+    mcp_oauth_clients: dict[str, McpOAuthClient] = Field(
+        default_factory=dict,
+        description="Server name → pre-registered OAuth client, used only under `--oauth` "
+        "(interactive browser flow; never in background paths).",
+    )
+    oauth_token_dir: OAuthTokenDirPath = Field(
+        default_factory=lambda: Path.home() / ".claude" / "capdisc" / "oauth-tokens"
+    )
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,  # noqa: ARG003
+    ) -> tuple[PydanticBaseSettingsSource, ...]:
+        return (
+            init_settings,
+            env_settings,
+            dotenv_settings,
+            JsonConfigSettingsSource(settings_cls),
+            YamlConfigSettingsSource(settings_cls),
+        )
+
+
+@cache
+def get_settings() -> DiscoverySettings:
+    """The process-wide settings, resolved lazily on first use from env/.env/JSON/YAML config.
+
+    Lazy so importing the package never reads config files or raises on a malformed
+    environment, and so configuration applied before first use is honored. The default
+    source for discovery/report/mcp path defaults."""
+    return DiscoverySettings()

capdisc/tokens.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+from pydantic import Field
+from pydantic.functional_validators import AfterValidator
+
+# Defined here, not imported from catalog/types.py: catalog/types.py itself imports
+# token_bounds from this module, so importing back from it would be circular.
+TokenCount = Annotated[
+    int,
+    Field(ge=0, title="Token count", description="Estimated token count of a text."),
+]
+
+
+def estimate_tokens(text: str) -> TokenCount:
+    """Estimate a string's token count, cheaply and deterministically.
+
+    ~4 chars/token with a word-count floor. A guard rail, not a billing figure — swap in
+    tiktoken for a tighter number.
+
+    Args:
+        text: The text to estimate.
+
+    Returns:
+        The estimated token count.
+    """
+    return max(len(text) // 4, len(text.split()))
+
+
+def token_bounds(max_tokens: TokenCount) -> AfterValidator:
+    """Build an `AfterValidator` that rejects strings over a token estimate.
+
+    Args:
+        max_tokens: The inclusive upper bound on `estimate_tokens(value)`.
+
+    Returns:
+        A validator that returns the value unchanged, or raises `ValueError` when the estimate
+        exceeds `max_tokens`.
+    """
+
+    def _check(value: str) -> str:
+        used = estimate_tokens(value)
+        if used > max_tokens:
+            raise ValueError(f"~{used} tokens exceeds {max_tokens}-token maximum")
+        return value
+
+    return AfterValidator(_check)

claude_code_capabilities-0.1.2.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: claude-code-capabilities
+Version: 0.1.2
+Summary: Discovers Claude Code capabilities — skills, agents, plugins, MCP servers, hooks — into typed catalogs and an environment report.
+Project-URL: Homepage, https://github.com/Magic-Man-us/capability-discovery
+Project-URL: Repository, https://github.com/Magic-Man-us/capability-discovery
+Author: Magic-Man-us
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: fastmcp>=3.4.4
+Requires-Dist: py-key-value-aio[filetree]>=0.4.5
+Requires-Dist: pydantic-settings>=2.14.2
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: pyyaml>=6.0.3
+Description-Content-Type: text/markdown
+
+# capdisc
+
+[![PyPI](https://img.shields.io/pypi/v/claude-code-capabilities.svg)](https://pypi.org/project/claude-code-capabilities/)
+[![Python versions](https://img.shields.io/pypi/pyversions/claude-code-capabilities.svg)](https://pypi.org/project/claude-code-capabilities/)
+[![CI](https://github.com/Magic-Man-us/capability-discovery/actions/workflows/ci.yml/badge.svg)](https://github.com/Magic-Man-us/capability-discovery/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/Magic-Man-us/capability-discovery/blob/main/LICENSE)
+
+Discovers Claude Code capabilities — skills, agents, plugins, MCP servers, hooks — into typed
+Pydantic catalogs and an environment report.
+
+## Install
+
+```bash
+uv add claude-code-capabilities
+# or
+pip install claude-code-capabilities
+```
+
+## CLI
+
+```bash
+capdisc            # scan this machine, write discovery-report.json + .html
+capdisc --oauth     # also allow the interactive OAuth flow for HTTP MCP servers
+                    # with a pre-registered client (forces a fresh MCP harvest)
+```
+
+Both files are written to `~/.claude/capdisc/` by default. Configure paths and MCP auth via env
+vars (`CAPDISC_` prefix), a `.env` file, or `~/.claude/capdisc/config.json`/`config.yaml` — see
+`DiscoverySettings` in `settings.py` for every field.
+
+## Library
+
+Scan the machine into a typed catalog:
+
+```python
+from pathlib import Path
+from capdisc.discovery import scan_environment
+from capdisc.scope import ScopeRoots
+
+roots = ScopeRoots.discover(start=Path.cwd(), home_dir=Path.home())
+catalog = scan_environment(roots)
+for entry in catalog.entries:
+    ...  # CatalogSkill | CatalogTool | CatalogMcpServer | CatalogPlugin
+```
+
+Build and persist the full environment report (what the CLI does):
+
+```python
+from capdisc.report import build_report, write_report
+
+report = build_report(oauth=False)
+write_report(report)  # -> ~/.claude/capdisc/discovery-report.{json,html}
+```
+
+Inspect the on-disk scope inventory directly — every skill/agent/command/hook found, its
+precedence, and which ones actually win a collision:
+
+```python
+from capdisc.scope import ScopeInventory, ScopeRoots
+
+inventory = ScopeInventory.scan(ScopeRoots.discover(start=Path.cwd(), home_dir=Path.home()))
+print(len(inventory.artifacts), "captured,", len(inventory.effective), "in effect")
+for hooks in inventory.hook_configs:
+    ...  # HookConfig, unified from settings.json and component frontmatter
+```
+
+### MCP servers
+
+Read the last harvested tool inventory (fast, no network — served from a 12h cache):
+
+```python
+from capdisc.mcp_harvest import read_mcp_cache, cache_is_stale
+
+servers = read_mcp_cache()  # [] if there's no cache yet
+if cache_is_stale():
+    ...  # trigger a refresh (below) before trusting this
+```
+
+Force a fresh harvest — connects to every configured server concurrently (bounded) and lists
+their real tool schemas:
+
+```python
+from capdisc.mcp_harvest import refresh_mcp_cache
+
+servers = refresh_mcp_cache(oauth=False)  # also (re)writes the cache
+for server in servers:
+    print(server.ref, [t.name for t in server.tools])
+```
+
+Bearer/OAuth auth for HTTP servers is opt-in via settings, bound to an exact hostname so a
+same-named server elsewhere can never receive a credential meant for another:
+
+```bash
+export CAPDISC_MCP_BEARER_ENV='{"github": {"env": "GH_TOKEN", "host": "api.githubcopilot.com"}}'
+```
+
+`report.EnvironmentReport` captures the full discovery harvest (scan roots, on-disk inventory, skills,
+builtin tools, plugins with per-component token cost, MCP servers). `mcp_harvest` and `mcp_catalog`
+enumerate connected MCP servers; `plugin_catalog` reads installed plugins; `scope` resolves which
+roots to scan.
+
+The package ships `py.typed`.
+
+## Tests
+
+```bash
+uv run pytest
+uv run mypy src
+uv run ruff check .
+```

claude_code_capabilities-0.1.2.dist-info/RECORD

@@ -0,0 +1,47 @@
+capdisc/__init__.py,sha256=xRifNB3tWg3Ax67e9TkMjb7SflAFnXY_ZkUkEKKpYnU,1804
+capdisc/base.py,sha256=7124V1bHbVMkeCtnDQUOFFZ-u1Y7Un8EVUOOQYB6-mc,2193
+capdisc/discovery.py,sha256=XbKelU4VjYgo4TFTXJZzglcRltVWdJiW2ObfIrg0HUw,10235
+capdisc/frontmatter.py,sha256=XAwmLgqyHacO5iKYHHjIXilvJIJ5bB4PEc-J533hIiQ,1745
+capdisc/html.py,sha256=qWRpXTcDS06dRJTtR71GAJ12Ms_ofr47neWW1HMMv3A,2990
+capdisc/mcp_catalog.py,sha256=Rwv2ReEJfa6dncBLH29VlLdlR6CmY923s4AshySY9YU,3009
+capdisc/plugin_catalog.py,sha256=k-0pmQyHMWSTY0fw53OCuJeLliovGvnbQoHJYZxWBQw,10306
+capdisc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+capdisc/settings.py,sha256=La5Wb8_PaqnbN0MKDRWz6laivmlvGKuA3owPsd9Qg8U,8622
+capdisc/tokens.py,sha256=3u_ib8hAItJc3WzzHy1EiK6EYtGEitjmC32v5wEkisE,1450
+capdisc/catalog/__init__.py,sha256=rDTI88ikm1r3DYNTwruLFdKpf7HLuJOZWmv-8Rq1n-8,1365
+capdisc/catalog/entries.py,sha256=apmhUEmCnrjt5QbvS2FgRG1N88sxcapoVNdkN2BYCS4,2966
+capdisc/catalog/types.py,sha256=YKMOCtxB1aZYQg818Em2MgI1XtCBr-UVFDGiXsTm_Rc,7090
+capdisc/hooks/__init__.py,sha256=BMlHREAhXS5mIVSBuQ5I9zdWHttuYNfMNf2VqzS-9As,1047
+capdisc/hooks/schema.py,sha256=ZVi58WclKJCM99IR47Gc1YILa07B7FV8hhiVqOcOm2E,7161
+capdisc/hooks/types.py,sha256=MnMhCNoseSq1eGix0IiyFlyuBqi145LG72anSxViOMs,4339
+capdisc/mcp_harvest/__init__.py,sha256=XEkZoT2IhZvs5kMzteAEq332LSgE29RMB41vqDDkU38,306
+capdisc/mcp_harvest/auth.py,sha256=IOke9rMfgN_zJSwcUMnq1lym6o5DA57fMK2eiW73aLc,4608
+capdisc/mcp_harvest/cache.py,sha256=HHFY69iDXcVmnl0BM3olVstHWG4nULfxNpyR3jLLcdM,5590
+capdisc/mcp_harvest/config.py,sha256=BeGmoakOXm4Ws25NaFZCOMYK7WM_1LnKRPD6xFbFXug,11892
+capdisc/mcp_harvest/connect.py,sha256=Bjs0oh6D-nVsEFL1cHsoLeVItBTCFfh9gCO2qLtQj7M,7115
+capdisc/mcp_harvest/types.py,sha256=QMklnjXH-b-9r0AgAX878bWEHAq3vin4zvdUNMlAw7A,884
+capdisc/report/__init__.py,sha256=axlk_daMqLeKi3VdMj6wsoDTz8kcnmWXDK-3pMsIkXA,1415
+capdisc/report/__main__.py,sha256=u80yf2rO_w6_MuyOfo2SES79u_F6tQUiwFwMexKpGFQ,97
+capdisc/report/assets.py,sha256=P1-yIv3RbkizRSkiDxsSgaCwsaRTzMPwSHom-MQrG9Q,7531
+capdisc/report/cards.py,sha256=NuGS-Fp-K4XvC4pbE31GcdxKNeKKlMF2Vog7OoVydnA,3944
+capdisc/report/cli.py,sha256=uU19sFd_zQ6S_r8RSBOR_fJr0I7haY_lT3272S0mhV8,1167
+capdisc/report/components.py,sha256=EUgAhfwUJhjFRYy9AXSTxfXHe5apt3tvaRRRq7zaPe0,5772
+capdisc/report/harvest.py,sha256=HHuFnQvl18_IX12tXobsje1ko7oUUFRtOrE0Yz271lI,5990
+capdisc/report/html.py,sha256=v3oJnRlm0aWMT0RdI7IOOYcL0VaPPQpe8Y0Ts8r8aDI,2077
+capdisc/report/models.py,sha256=KW078sZH0KFDDmONj5b4TBnNKUVk4Q7AZVz7QYAvUDM,2562
+capdisc/report/page.py,sha256=zy2RZ3aGpqBgwKCWPdg9SsmDNh9E-8ccExTXT5d6z30,4410
+capdisc/report/sections.py,sha256=rFEe03NTSgn9FDg-p4Ke11NcvFcXvUPP5aSfdr-npZY,5632
+capdisc/report/types.py,sha256=h8XWPhz3HQGPjARc4vI8MZidY-bwvXmOdmBG6RYCRm4,961
+capdisc/scope/__init__.py,sha256=CCddcTSUmooThC9sax6GFFQE3YG5ZfwUigDjAHzWXOQ,1480
+capdisc/scope/locations.py,sha256=UMqfadVjRkZQfh2Ib2S_EF993bf8RY4CilpyzfARd8I,11922
+capdisc/scope/types.py,sha256=XdA6UwqgnsYUX1_VvR5o9GVmOAgqlF4RzmAnjyu6kPY,4523
+capdisc/scope/inventory/__init__.py,sha256=CQ3j0N0pqh6a3ttlf_BGWf9YKHY3MHjUQmkcK9SSy88,609
+capdisc/scope/inventory/assets.py,sha256=A9odfbo4UK7kJA9B-UgMeHkiBl5y_DS-GHvMAhTZ0eg,2781
+capdisc/scope/inventory/capture.py,sha256=WVoYEmiWQO01LdKfH1cQ0mWHRmjuOb704wsf-YxLKQg,8654
+capdisc/scope/inventory/render.py,sha256=bbDvt7LXkk3EJSP6MSauoVHW1kNIdNb5WrnavCXDE_Q,6304
+capdisc/scope/inventory/roots.py,sha256=GYZhMeFqw7I5U1bRAWTUvyJyXlMdqwhu83q2r2DnNV4,7219
+claude_code_capabilities-0.1.2.dist-info/METADATA,sha256=icXWOGkscpD8SeUyfSH4WYPo1fMdt7bBR1hwVTGB5kk,4912
+claude_code_capabilities-0.1.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+claude_code_capabilities-0.1.2.dist-info/entry_points.txt,sha256=_Bpcif5HawFaBeHswPeJ_7Ep_F37KsTOaOV-VDcUdm0,48
+claude_code_capabilities-0.1.2.dist-info/licenses/LICENSE,sha256=U8Kmm9RvqogXmfGNlmVcAHpi72693fiOfsJsnnA4J1s,1069
+claude_code_capabilities-0.1.2.dist-info/RECORD,,

claude_code_capabilities-0.1.2.dist-info/WHEEL

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

claude_code_capabilities-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+capdisc = capdisc.report:main

claude_code_capabilities-0.1.2.dist-info/licenses/LICENSE

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