kitctl 0.0.1__py3-none-any.whl

kitctl/__init__.py

@@ -0,0 +1,3 @@
+"""Kit: inventory and manage agent tooling through deterministic loadouts."""
+
+__version__ = "0.0.1"

kitctl/__main__.py

@@ -0,0 +1,3 @@
+from kitctl.cli import main
+
+raise SystemExit(main())

kitctl/cli.py

@@ -0,0 +1,44 @@
+"""CLI for Kit's initial read-only release."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from kitctl import __version__
+from kitctl.inventory import inventory
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="kitctl", description="Kit — inventory and manage agent tooling."
+    )
+    parser.add_argument("--version", action="version", version=f"kitctl {__version__}")
+    commands = parser.add_subparsers(dest="command", required=True)
+    scan = commands.add_parser("inventory", help="Read-only discovery in explicit roots.")
+    scan.add_argument(
+        "--root",
+        action="append",
+        type=Path,
+        dest="roots",
+        metavar="PATH",
+        help="Repository or home directory to inspect; repeatable. Defaults to current directory.",
+    )
+    scan.add_argument("--json", action="store_true", help="Print metadata and hashes as JSON.")
+    args = parser.parse_args(argv)
+    try:
+        report = inventory(args.roots or [Path.cwd()])
+    except (OSError, ValueError) as error:
+        print(f"kitctl: {error}", file=sys.stderr)
+        return 2
+    if args.json:
+        print(json.dumps(report, indent=2))
+    else:
+        for entry in report["entries"]:
+            print(f"{entry['kind']:6}  {entry['name']}  {entry['path']}")
+        print(f"{len(report['entries'])} items; no files changed.")
+        for warning in report["warnings"]:
+            print(f"warning: {warning}", file=sys.stderr)
+    return 1 if report["warnings"] else 0

kitctl/inventory.py

@@ -0,0 +1,129 @@
+"""Read-only, explicitly scoped discovery. Never serialize configuration values."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import TypedDict
+
+CONFIG_PATHS = (
+    ".claude/settings.json",
+    ".claude/settings.local.json",
+    ".claude.json",
+    ".mcp.json",
+    ".codex/config.toml",
+    ".codex/hooks.json",
+    "CLAUDE.md",
+    "AGENTS.md",
+    "kit.yaml",
+    "kit.lock",
+)
+SKILL_PATHS = (".claude/skills", ".agents/skills", ".codex/skills")
+
+
+@dataclass(frozen=True)
+class Entry:
+    kind: str
+    name: str
+    root: str
+    path: str
+    content_hash: str
+
+
+class Report(TypedDict):
+    schema_version: int
+    entries: list[dict[str, str]]
+    warnings: list[str]
+
+
+def _safe_file(path: Path, root: Path) -> bool:
+    """Skip links, including a link in a parent directory, and special files."""
+    relative = path.relative_to(root)
+    current = root
+    for part in relative.parts:
+        current /= part
+        if current.is_symlink():
+            return False
+    return path.is_file()
+
+
+def _file_hash(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(65536), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _skill_hash(directory: Path, root: Path) -> str:
+    """Hash relative names and bytes of all regular skill assets deterministically."""
+    digest = hashlib.sha256()
+
+    def fail(error: OSError) -> None:
+        raise error
+
+    for current, dirs, files in os.walk(directory, followlinks=False, onerror=fail):
+        dirs[:] = sorted(
+            name for name in dirs if name != ".git" and not (Path(current) / name).is_symlink()
+        )
+        for name in sorted(files):
+            path = Path(current) / name
+            if _safe_file(path, root):
+                digest.update(path.relative_to(directory).as_posix().encode("utf-8"))
+                digest.update(b"\0")
+                digest.update(_file_hash(path).encode("ascii"))
+                digest.update(b"\0")
+    return digest.hexdigest()
+
+
+def inventory(roots: list[Path]) -> Report:
+    entries: list[Entry] = []
+    warnings: list[str] = []
+    for root in sorted({path.expanduser().resolve() for path in roots}):
+        if not root.is_dir():
+            raise ValueError(f"Inventory root is not a directory: {root}")
+        for relative in CONFIG_PATHS:
+            path = root / relative
+            try:
+                if _safe_file(path, root):
+                    entries.append(
+                        Entry("config", relative, str(root), str(path), _file_hash(path))
+                    )
+                elif path.exists() or path.is_symlink():
+                    warnings.append(f"Skipped link or non-regular file: {path}")
+            except OSError:
+                warnings.append(f"Cannot read: {path}")
+        for relative in SKILL_PATHS:
+            directory = root / relative
+            try:
+                if directory.is_symlink() or any(
+                    parent.is_symlink() for parent in directory.parents if parent != root
+                ):
+                    warnings.append(f"Skipped linked skill directory: {directory}")
+                    continue
+                if not directory.is_dir():
+                    continue
+                for skill in sorted(directory.iterdir()):
+                    manifest = skill / "SKILL.md"
+                    if skill.is_symlink():
+                        warnings.append(f"Skipped linked skill: {skill}")
+                    elif manifest.is_symlink():
+                        warnings.append(f"Skipped linked skill manifest: {manifest}")
+                    elif _safe_file(manifest, root):
+                        try:
+                            entries.append(
+                                Entry(
+                                    "skill",
+                                    skill.name,
+                                    str(root),
+                                    str(skill),
+                                    _skill_hash(skill, root),
+                                )
+                            )
+                        except OSError:
+                            warnings.append(f"Cannot read complete skill: {skill}")
+            except OSError:
+                warnings.append(f"Cannot read: {directory}")
+    return {"schema_version": 1, "entries": [asdict(e) for e in entries], "warnings": warnings}

kitctl-0.0.1.dist-info/METADATA

@@ -0,0 +1,96 @@
+Metadata-Version: 2.5
+Name: kitctl
+Version: 0.0.1
+Summary: Inventory and manage agent skills, MCP connectors, hooks, and loadouts.
+Project-URL: Repository, https://github.com/ConnorBritain/kitctl
+Project-URL: Issues, https://github.com/ConnorBritain/kitctl/issues
+Author: Connor England
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,claude,codex,mcp,skills
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Kit (`kitctl`)
+
+Kit inventories the skills, MCP configuration, hooks, and plugins used by coding
+agents. The planned compiler manages named **loadouts** from a separate private
+warehouse and writes each harness's native configuration with an ownership ledger.
+The planned default warehouse location is `~/kits`; setup will ask which parent
+directories contain your repositories.
+
+**0.0.1 is an early, read-only release.** It discovers skill folders and known
+configuration files in explicitly selected roots, computes SHA-256 hashes, and
+prints text or JSON. It does not yet parse connectors, count usage, compile
+loadouts, reconcile changes, or modify agent configuration.
+
+## Run
+
+Python 3.11+:
+
+```sh
+# From a checkout (works before the PyPI release):
+uv run kitctl --version
+uv run kitctl inventory --root /path/to/repo --json
+
+# After publication to PyPI:
+uvx kitctl --version
+uv tool install kitctl
+```
+
+Node 20+ with [uv installed](https://docs.astral.sh/uv/getting-started/installation/):
+
+```sh
+# After publication to npm:
+npx kitctl --version
+npx kitctl inventory --root /path/to/repo --json
+```
+
+The npm package is a thin launcher around the bundled Python wheel from the same
+release. It uses `uvx` with that local wheel; it does not require a PyPI release,
+run install scripts, or ship a `kit` binary. uv manages Python if needed.
+
+`inventory` defaults to the current directory. Repeat `--root` to inspect several
+repositories, or explicitly pass your home directory to include user config.
+There is no recursive search through unrelated repositories. Symlinked skills and
+configuration are skipped with warnings. JSON includes file paths and hashes,
+never configuration contents. Exit codes: 0 complete, 1 partial due to skipped
+items, 2 invalid arguments or roots. Reports may reveal private paths; keep them
+out of public source control.
+
+## Develop
+
+```sh
+uv sync --locked
+uv run ruff check .
+uv run ruff format --check .
+uv run mypy
+uv run pytest
+uv build
+uv run python scripts/prepare_npm.py
+npm --prefix npm test
+cd npm
+npm pack --dry-run
+```
+
+Tests use throwaway HOME, CODEX_HOME, CLAUDE_CONFIG_DIR, and repository fixtures.
+CI runs on Linux and Windows with Python 3.11 and 3.14. A local pre-commit
+configuration and CI check reject common token formats and private keys. Install
+the hook with `uvx pre-commit install` if desired; this basic check is not a
+comprehensive secret scanner.
+
+See [PLAN.md](PLAN.md), [design](docs/design.md),
+[harness reference](docs/harness-reference.md), and [publishing](docs/publishing.md).
+
+## Naming
+
+Kit ships only the `kitctl` command. AWS's Kubernetes Iteration Toolkit and
+Gravwell also use a `kitctl` binary; installing those tools alongside Kit can
+cause PATH collisions. This project is independent of those projects and KitOps.
+
+MIT License. The code repository and private warehouse are deliberately separate.

kitctl-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+kitctl/__init__.py,sha256=rSm9eIUxoPces7GkCow9GLqAJwoHrEdpF3o8zUE5wuA,101
+kitctl/__main__.py,sha256=YyfWKomGWqYwcoPkocKXKYrrtWoDEImggBnVUHFUYuk,54
+kitctl/cli.py,sha256=EzF9-Z1nShrmsAv-Nfbdd7I4xlUeTWiibCqeoxiLpRI,1581
+kitctl/inventory.py,sha256=AIbAXOm81z8ODsALhfRVaP87YjlG82gPN_l3KxYk1Ps,4516
+kitctl-0.0.1.dist-info/METADATA,sha256=8sPUv3CD6BvhOigGSg1juyjheP1iPNsoQ9SkiAu5kL4,3547
+kitctl-0.0.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+kitctl-0.0.1.dist-info/entry_points.txt,sha256=ebID8O6jX7VSeb-McMCyAKvmRomQGLLWqPnC1AACB_w,43
+kitctl-0.0.1.dist-info/licenses/LICENSE,sha256=DNjvGPlBeV_eLjSZIVk9TltdnjU6k0nfD0v-iBY_YOM,1071
+kitctl-0.0.1.dist-info/RECORD,,

kitctl-0.0.1.dist-info/WHEEL

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

kitctl-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kitctl = kitctl.cli:main

kitctl-0.0.1.dist-info/licenses/LICENSE

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