agentkit-cli 0.1.0__py3-none-any.whl

agentkit_cli/__init__.py

@@ -0,0 +1,3 @@
+"""agentkit-cli: Unified CLI for the Agent Quality Toolkit."""
+
+__version__ = "0.1.0"

agentkit_cli/commands/__init__.py

@@ -0,0 +1 @@
+# commands package

agentkit_cli/commands/init_cmd.py

@@ -0,0 +1,63 @@
+"""agentkit init command."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich import print as rprint
+
+from agentkit_cli.tools import QUARTET_TOOLS, is_installed, INSTALL_HINTS
+from agentkit_cli.config import find_project_root, config_path, config_exists, write_default_config
+
+console = Console()
+
+
+def init_command(
+    path: Optional[Path] = typer.Option(None, "--path", "-p", help="Project root (default: git root or cwd)"),
+) -> None:
+    """Initialize agentkit in a project directory."""
+    root = path or find_project_root()
+    console.print(f"\n[bold]Initializing agentkit in:[/bold] {root}\n")
+
+    # Check quartet tools
+    table = Table(title="Agent Quality Toolkit — Tool Status", show_header=True)
+    table.add_column("Tool", style="bold")
+    table.add_column("Status")
+    table.add_column("Install Command")
+
+    missing = []
+    for tool in QUARTET_TOOLS:
+        if is_installed(tool):
+            table.add_row(tool, "[green]✓ installed[/green]", "")
+        else:
+            table.add_row(tool, "[red]✗ missing[/red]", INSTALL_HINTS.get(tool, f"pip install {tool}"))
+            missing.append(tool)
+
+    console.print(table)
+
+    # Write config
+    cfg_path = config_path(root)
+    if config_exists(root):
+        console.print(f"\n[yellow]Config already exists:[/yellow] {cfg_path}")
+    else:
+        written = write_default_config(root)
+        console.print(f"\n[green]Created config:[/green] {written}")
+
+    # Print install instructions for missing tools
+    if missing:
+        console.print("\n[yellow]Install missing tools:[/yellow]")
+        for tool in missing:
+            console.print(f"  pip install {tool}")
+
+    # Next steps
+    next_steps = "\n".join([
+        "1. Install any missing tools (see above)",
+        "2. Run [bold]agentkit run[/bold] to execute the full quality pipeline",
+        "3. Run [bold]agentkit status[/bold] to check your setup at any time",
+    ])
+    console.print(Panel(next_steps, title="Next Steps", border_style="blue"))
+    console.print()

agentkit_cli/commands/run_cmd.py

@@ -0,0 +1,173 @@
+"""agentkit run command — sequential pipeline runner."""
+from __future__ import annotations
+
+import json
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import List, Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from agentkit_cli.tools import is_installed, run_tool, INSTALL_HINTS
+from agentkit_cli.config import find_project_root, save_last_run
+
+console = Console()
+
+STEP_TOOL_MAP = {
+    "generate": "agentmd",
+    "lint": "agentlint",
+    "benchmark": "coderace",
+    "reflect": "agentreflect",
+}
+
+
+def _run_step(name: str, tool: str, args: list[str], cwd: str) -> dict:
+    """Execute one pipeline step; return result dict."""
+    start = time.monotonic()
+    if not is_installed(tool):
+        return {
+            "step": name,
+            "tool": tool,
+            "status": "skipped",
+            "reason": f"not installed — {INSTALL_HINTS.get(tool, f'pip install {tool}')}",
+            "duration": 0.0,
+            "output": "",
+        }
+    try:
+        result = run_tool(tool, args, cwd=cwd)
+        duration = time.monotonic() - start
+        success = result.returncode == 0
+        return {
+            "step": name,
+            "tool": tool,
+            "status": "pass" if success else "fail",
+            "returncode": result.returncode,
+            "duration": round(duration, 2),
+            "output": (result.stdout + result.stderr).strip(),
+        }
+    except Exception as e:
+        return {
+            "step": name,
+            "tool": tool,
+            "status": "error",
+            "reason": str(e),
+            "duration": round(time.monotonic() - start, 2),
+            "output": "",
+        }
+
+
+def run_command(
+    path: Optional[Path] = typer.Option(None, "--path", "-p", help="Project directory to run against"),
+    skip: Optional[List[str]] = typer.Option(None, "--skip", help="Steps to skip: generate, lint, benchmark, reflect"),
+    benchmark: bool = typer.Option(False, "--benchmark", help="Include benchmark step (skipped by default)"),
+    json_output: bool = typer.Option(False, "--json", help="Output summary JSON"),
+    notes: Optional[str] = typer.Option(None, "--notes", help="Notes passed to agentreflect"),
+) -> None:
+    """Run the full Agent Quality pipeline."""
+    root = path or find_project_root()
+    cwd_str = str(root)
+    skip_set = set(s.lower() for s in (skip or []))
+
+    # Benchmark is opt-in
+    if not benchmark:
+        skip_set.add("benchmark")
+
+    console.print(f"\n[bold]agentkit run[/bold] — project: {root}\n")
+
+    context_file = root / "CLAUDE.md"
+    results = []
+
+    # Step 1: generate
+    if "generate" not in skip_set:
+        console.print("[dim]→ agentmd generate ...[/dim]")
+        r = _run_step("generate", "agentmd", ["generate", cwd_str], cwd_str)
+        results.append(r)
+    else:
+        results.append({"step": "generate", "tool": "agentmd", "status": "skipped", "reason": "user skipped", "duration": 0.0})
+
+    # Step 2: lint context file
+    if "lint" not in skip_set:
+        lint_args = ["check-context", str(context_file)] if context_file.exists() else ["check-context", cwd_str]
+        console.print("[dim]→ agentlint check-context ...[/dim]")
+        r = _run_step("lint-context", "agentlint", lint_args, cwd_str)
+        results.append(r)
+
+        # Step 3: lint diffs
+        console.print("[dim]→ agentlint (diff) ...[/dim]")
+        r2 = _run_step("lint-diff", "agentlint", [cwd_str], cwd_str)
+        results.append(r2)
+    else:
+        results.append({"step": "lint-context", "tool": "agentlint", "status": "skipped", "reason": "user skipped", "duration": 0.0})
+        results.append({"step": "lint-diff", "tool": "agentlint", "status": "skipped", "reason": "user skipped", "duration": 0.0})
+
+    # Step 4: benchmark (opt-in)
+    if "benchmark" not in skip_set:
+        console.print("[dim]→ coderace benchmark ...[/dim]")
+        r = _run_step("benchmark", "coderace", ["benchmark", cwd_str], cwd_str)
+        results.append(r)
+    else:
+        results.append({"step": "benchmark", "tool": "coderace", "status": "skipped", "reason": "opt-in only (use --benchmark)", "duration": 0.0})
+
+    # Step 5: reflect
+    if "reflect" not in skip_set:
+        reflect_args = ["generate", "--notes", notes or "agentkit run completed", cwd_str]
+        console.print("[dim]→ agentreflect generate ...[/dim]")
+        r = _run_step("reflect", "agentreflect", reflect_args, cwd_str)
+        results.append(r)
+    else:
+        results.append({"step": "reflect", "tool": "agentreflect", "status": "skipped", "reason": "user skipped", "duration": 0.0})
+
+    # Display table
+    table = Table(title="Pipeline Results", show_header=True)
+    table.add_column("Step", style="bold")
+    table.add_column("Tool")
+    table.add_column("Status")
+    table.add_column("Duration")
+    table.add_column("Notes", max_width=50)
+
+    status_colors = {"pass": "green", "fail": "red", "skipped": "yellow", "error": "red"}
+
+    for r in results:
+        status = r.get("status", "unknown")
+        color = status_colors.get(status, "white")
+        duration = f"{r.get('duration', 0):.2f}s" if r.get("duration") else ""
+        note = r.get("reason", "") or (r.get("output", "")[:60] if r.get("output") else "")
+        table.add_row(
+            r["step"],
+            r.get("tool", ""),
+            f"[{color}]{status}[/{color}]",
+            duration,
+            note,
+        )
+
+    console.print()
+    console.print(table)
+
+    # Save last run
+    summary = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "project": cwd_str,
+        "steps": results,
+        "total": len(results),
+        "passed": sum(1 for r in results if r.get("status") == "pass"),
+        "failed": sum(1 for r in results if r.get("status") == "fail"),
+        "skipped": sum(1 for r in results if r.get("status") == "skipped"),
+    }
+    try:
+        save_last_run(summary, root)
+    except Exception:
+        pass
+
+    if json_output:
+        console.print("\n[bold]JSON Output:[/bold]")
+        print(json.dumps(summary, indent=2))
+
+    # Final status
+    if summary["failed"] > 0:
+        console.print(f"\n[red]Pipeline completed with {summary['failed']} failure(s).[/red]")
+        raise typer.Exit(code=1)
+    else:
+        console.print(f"\n[green]Pipeline complete.[/green] {summary['passed']} passed, {summary['skipped']} skipped.\n")

agentkit_cli/commands/status_cmd.py

@@ -0,0 +1,97 @@
+"""agentkit status command."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from agentkit_cli.tools import tool_status
+from agentkit_cli.config import find_project_root, config_exists, load_last_run
+
+console = Console()
+
+
+def status_command(
+    path: Optional[Path] = typer.Option(None, "--path", "-p", help="Project directory to check"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+) -> None:
+    """Show health status of the Agent Quality Toolkit."""
+    root = path or find_project_root()
+    console.print(f"\n[bold]agentkit status[/bold] — project: {root}\n")
+
+    # Tool table
+    tool_table = Table(title="Quartet Tools", show_header=True)
+    tool_table.add_column("Tool", style="bold")
+    tool_table.add_column("Status")
+    tool_table.add_column("Version")
+    tool_table.add_column("Path")
+
+    ts = tool_status()
+    for tool, info in ts.items():
+        if info["installed"]:
+            status_str = "[green]✓ installed[/green]"
+            version_str = info.get("version") or "—"
+            path_str = info.get("path") or "—"
+        else:
+            status_str = "[red]✗ missing[/red]"
+            version_str = "—"
+            path_str = "—"
+        tool_table.add_row(tool, status_str, version_str, path_str)
+
+    console.print(tool_table)
+
+    # Project files table
+    files_table = Table(title="Project Files", show_header=True)
+    files_table.add_column("File", style="bold")
+    files_table.add_column("Status")
+
+    config_ok = config_exists(root)
+    claude_ok = (root / "CLAUDE.md").exists()
+    last_run_ok = (root / ".agentkit-last-run.json").exists()
+
+    files_table.add_row(
+        ".agentkit.yaml",
+        "[green]✓ exists[/green]" if config_ok else "[yellow]✗ missing — run agentkit init[/yellow]",
+    )
+    files_table.add_row(
+        "CLAUDE.md",
+        "[green]✓ exists[/green]" if claude_ok else "[yellow]✗ missing[/yellow]",
+    )
+    files_table.add_row(
+        ".agentkit-last-run.json",
+        "[green]✓ exists[/green]" if last_run_ok else "[dim]not found[/dim]",
+    )
+
+    console.print(files_table)
+
+    # Last run summary
+    last_run = load_last_run(root)
+    if last_run:
+        lr_table = Table(title="Last Run Summary", show_header=True)
+        lr_table.add_column("Key", style="bold")
+        lr_table.add_column("Value")
+        lr_table.add_row("Timestamp", last_run.get("timestamp", "—"))
+        lr_table.add_row("Passed", str(last_run.get("passed", "—")))
+        lr_table.add_row("Failed", str(last_run.get("failed", "—")))
+        lr_table.add_row("Skipped", str(last_run.get("skipped", "—")))
+        console.print(lr_table)
+
+    if json_output:
+        output = {
+            "project": str(root),
+            "tools": ts,
+            "files": {
+                ".agentkit.yaml": config_ok,
+                "CLAUDE.md": claude_ok,
+                ".agentkit-last-run.json": last_run_ok,
+            },
+            "last_run": last_run,
+        }
+        console.print("\n[bold]JSON Output:[/bold]")
+        print(json.dumps(output, indent=2))
+
+    console.print()

agentkit_cli/config.py

@@ -0,0 +1,91 @@
+"""Config file management for .agentkit.yaml."""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Optional
+
+try:
+    import yaml  # type: ignore
+    HAS_YAML = True
+except ImportError:
+    HAS_YAML = False
+
+
+CONFIG_FILENAME = ".agentkit.yaml"
+LAST_RUN_FILENAME = ".agentkit-last-run.json"
+
+DEFAULT_CONFIG = {
+    "tools": {
+        "coderace": True,
+        "agentmd": True,
+        "agentlint": True,
+        "agentreflect": True,
+    },
+    "defaults": {
+        "min_score": 80,
+        "context_file": "CLAUDE.md",
+    },
+}
+
+DEFAULT_CONFIG_YAML = """\
+tools:
+  coderace: true
+  agentmd: true
+  agentlint: true
+  agentreflect: true
+defaults:
+  min_score: 80
+  context_file: CLAUDE.md
+"""
+
+
+def find_project_root(start: Optional[Path] = None) -> Path:
+    """Walk up to find git root; fall back to cwd."""
+    cwd = start or Path.cwd()
+    current = cwd
+    while True:
+        if (current / ".git").exists():
+            return current
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+    return cwd
+
+
+def config_path(root: Optional[Path] = None) -> Path:
+    root = root or find_project_root()
+    return root / CONFIG_FILENAME
+
+
+def last_run_path(root: Optional[Path] = None) -> Path:
+    root = root or find_project_root()
+    return root / LAST_RUN_FILENAME
+
+
+def config_exists(root: Optional[Path] = None) -> bool:
+    return config_path(root).exists()
+
+
+def write_default_config(root: Optional[Path] = None) -> Path:
+    path = config_path(root)
+    path.write_text(DEFAULT_CONFIG_YAML)
+    return path
+
+
+def load_last_run(root: Optional[Path] = None) -> Optional[dict]:
+    import json
+    p = last_run_path(root)
+    if not p.exists():
+        return None
+    try:
+        return json.loads(p.read_text())
+    except Exception:
+        return None
+
+
+def save_last_run(data: dict, root: Optional[Path] = None) -> None:
+    import json
+    p = last_run_path(root)
+    p.write_text(json.dumps(data, indent=2))

agentkit_cli/main.py

@@ -0,0 +1,62 @@
+"""agentkit CLI entry point."""
+from __future__ import annotations
+
+import typer
+from typing import Optional
+from pathlib import Path
+
+from agentkit_cli.commands.init_cmd import init_command
+from agentkit_cli.commands.run_cmd import run_command
+from agentkit_cli.commands.status_cmd import status_command
+
+app = typer.Typer(
+    name="agentkit",
+    help="Unified CLI for the Agent Quality Toolkit (agentmd, coderace, agentlint, agentreflect).",
+    add_completion=False,
+)
+
+
+@app.command("init")
+def init(
+    path: Optional[Path] = typer.Option(None, "--path", "-p", help="Project root"),
+) -> None:
+    """Initialize agentkit in a project. Creates .agentkit.yaml and checks for quartet tools."""
+    init_command(path=path)
+
+
+@app.command("run")
+def run(
+    path: Optional[Path] = typer.Option(None, "--path", "-p", help="Project directory"),
+    skip: Optional[list[str]] = typer.Option(None, "--skip", help="Steps to skip: generate, lint, benchmark, reflect"),
+    benchmark: bool = typer.Option(False, "--benchmark", help="Include benchmark step (off by default)"),
+    json_output: bool = typer.Option(False, "--json", help="Emit summary as JSON"),
+    notes: Optional[str] = typer.Option(None, "--notes", help="Notes for agentreflect"),
+) -> None:
+    """Run the full Agent Quality pipeline sequentially."""
+    run_command(path=path, skip=skip, benchmark=benchmark, json_output=json_output, notes=notes)
+
+
+@app.command("status")
+def status(
+    path: Optional[Path] = typer.Option(None, "--path", "-p", help="Project directory"),
+    json_output: bool = typer.Option(False, "--json", help="Emit status as JSON"),
+) -> None:
+    """Show health status of toolkit and current project."""
+    status_command(path=path, json_output=json_output)
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", "-V", help="Show version and exit"),
+) -> None:
+    if version:
+        from agentkit_cli import __version__
+        typer.echo(f"agentkit-cli v{__version__}")
+        raise typer.Exit()
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+
+
+if __name__ == "__main__":
+    app()

agentkit_cli/tools.py

@@ -0,0 +1,73 @@
+"""Tool detection and subprocess execution utilities."""
+from __future__ import annotations
+
+import shutil
+import subprocess
+from typing import Optional
+
+
+QUARTET_TOOLS = ["agentmd", "coderace", "agentlint", "agentreflect"]
+
+INSTALL_HINTS = {
+    "agentmd": "pip install agentmd",
+    "coderace": "pip install coderace",
+    "agentlint": "pip install agentlint",
+    "agentreflect": "pip install agentreflect",
+}
+
+
+def which(tool: str) -> Optional[str]:
+    """Return path to tool if installed, else None."""
+    return shutil.which(tool)
+
+
+def is_installed(tool: str) -> bool:
+    return which(tool) is not None
+
+
+def get_version(tool: str) -> Optional[str]:
+    """Try to get the version string for a tool."""
+    path = which(tool)
+    if not path:
+        return None
+    for flag in ["--version", "version"]:
+        try:
+            result = subprocess.run(
+                [path, flag],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            output = (result.stdout + result.stderr).strip()
+            if output:
+                # Return first line
+                return output.splitlines()[0]
+        except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+            continue
+    return "installed"
+
+
+def run_tool(tool: str, args: list[str], cwd: Optional[str] = None) -> subprocess.CompletedProcess:
+    """Run a quartet tool via subprocess."""
+    path = which(tool)
+    if not path:
+        raise FileNotFoundError(f"Tool not found: {tool}. Install with: {INSTALL_HINTS.get(tool, f'pip install {tool}')}")
+    return subprocess.run(
+        [path] + args,
+        capture_output=True,
+        text=True,
+        cwd=cwd,
+    )
+
+
+def tool_status() -> dict[str, dict]:
+    """Return status dict for all quartet tools."""
+    result = {}
+    for tool in QUARTET_TOOLS:
+        installed = is_installed(tool)
+        result[tool] = {
+            "installed": installed,
+            "path": which(tool) if installed else None,
+            "version": get_version(tool) if installed else None,
+        }
+    return result

agentkit_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: agentkit-cli
+Version: 0.1.0
+Summary: Unified CLI for the Agent Quality Toolkit (agentmd, coderace, agentlint, agentreflect)
+Project-URL: Homepage, https://github.com/mikiships/agentkit-cli
+Project-URL: Repository, https://github.com/mikiships/agentkit-cli
+Project-URL: Changelog, https://github.com/mikiships/agentkit-cli/blob/main/CHANGELOG.md
+Author-email: mikiships <frank.michaels2123@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: agents,ai,benchmark,cli,llm,quality,toolkit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.11
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Description-Content-Type: text/markdown
+
+# agentkit-cli
+
+**One install to rule them all.**
+
+```bash
+pip install agentkit-cli
+```
+
+Get the full Agent Quality Toolkit pipeline in a single command — no more juggling four separate `pip install` steps.
+
+---
+
+## What is it?
+
+`agentkit-cli` is a unified meta-CLI that wraps the **Agent Quality Toolkit quartet**:
+
+| Tool | Purpose |
+|------|---------|
+| [agentmd](https://pypi.org/project/agentmd/) | Generate CLAUDE.md context files |
+| [agentlint](https://pypi.org/project/agentlint/) | Lint AI context files and git diffs |
+| [coderace](https://pypi.org/project/coderace/) | Benchmark AI coding performance |
+| [agentreflect](https://pypi.org/project/agentreflect/) | Generate reflection reports from failures |
+
+## Pipeline Overview
+
+```
+agentkit run
+    │
+    ├── 1. agentmd generate        → produces CLAUDE.md
+    ├── 2. agentlint check-context → lints CLAUDE.md
+    ├── 3. agentlint (diff)        → lints recent changes
+    ├── 4. coderace benchmark      → (opt-in via --benchmark)
+    └── 5. agentreflect generate   → reflection on failures
+```
+
+Zero to full pipeline in 30 seconds.
+
+---
+
+## Installation
+
+```bash
+pip install agentkit-cli
+```
+
+Install the quartet tools too:
+
+```bash
+pip install agentmd agentlint coderace agentreflect
+```
+
+---
+
+## Usage
+
+### `agentkit init`
+
+Initialize agentkit in a project. Checks which tools are installed and creates `.agentkit.yaml`.
+
+```bash
+agentkit init
+agentkit init --path /my/project
+```
+
+Creates `.agentkit.yaml`:
+
+```yaml
+tools:
+  coderace: true
+  agentmd: true
+  agentlint: true
+  agentreflect: true
+defaults:
+  min_score: 80
+  context_file: CLAUDE.md
+```
+
+---
+
+### `agentkit run`
+
+Run the full quality pipeline sequentially.
+
+```bash
+agentkit run
+agentkit run --path /my/project
+agentkit run --skip generate
+agentkit run --skip lint
+agentkit run --skip benchmark
+agentkit run --skip reflect
+agentkit run --benchmark        # include benchmark step
+agentkit run --json             # emit summary as JSON
+agentkit run --notes "regression after refactor"
+```
+
+Missing tools are skipped automatically with a warning — you don't need all four installed.
+
+---
+
+### `agentkit status`
+
+Quick health check: tool versions, config presence, last run summary.
+
+```bash
+agentkit status
+agentkit status --path /my/project
+agentkit status --json
+```
+
+---
+
+## Links
+
+- [agentmd](https://pypi.org/project/agentmd/)
+- [agentlint](https://pypi.org/project/agentlint/)
+- [coderace](https://pypi.org/project/coderace/)
+- [agentreflect](https://pypi.org/project/agentreflect/)
+
+---
+
+## License
+
+MIT

agentkit_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+agentkit_cli/__init__.py,sha256=NIxS8CSOajv7vlg679bwFnr5MF-JZOr6Tset4YdbO38,86
+agentkit_cli/config.py,sha256=7TaODp9nTJjsPsFi59sCwumjbM9V258dZAynDE2-eHA,2015
+agentkit_cli/main.py,sha256=HmcBYJNDPFPHwAPJa012QLk4SymMCVm1_7ayO06_KK0,2182
+agentkit_cli/tools.py,sha256=__K3HXsYr62w09awmsENQmWriX231RNr8lAeQu114Go,2100
+agentkit_cli/commands/__init__.py,sha256=wl_DixJDOCreBHQKEeSeFo8eeHB8ua1IOw2ePGV4x-I,19
+agentkit_cli/commands/init_cmd.py,sha256=dFr4PPP7GXa4Xlb92RC3EVt95MVH_nvyCuXeEZf8rWw,2173
+agentkit_cli/commands/run_cmd.py,sha256=3btPldzn0GFBbgwgv63V1pribzESHKvk5v_G43mp11w,6423
+agentkit_cli/commands/status_cmd.py,sha256=k4ifWVglXQkje-bG5gKoc7CeOmYjY0uOSG7EnD9djPs,3239
+agentkit_cli-0.1.0.dist-info/METADATA,sha256=mZofFnJF8iHRPlO3Cq1Ds1D4hQZFn3xJvSJBMSPnSEk,3663
+agentkit_cli-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+agentkit_cli-0.1.0.dist-info/entry_points.txt,sha256=wTUbOJx7ZMH6KtzmS5zWfjXVUduScmdtris750nFKDs,51
+agentkit_cli-0.1.0.dist-info/licenses/LICENSE,sha256=_xg5HZ1WlLJEQpwpHZeQrhtyhgKC7ke4BL_qH6U3Jzo,1066
+agentkit_cli-0.1.0.dist-info/RECORD,,

agentkit_cli-0.1.0.dist-info/WHEEL

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

agentkit_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agentkit = agentkit_cli.main:app

agentkit_cli-0.1.0.dist-info/licenses/LICENSE

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