xone-cli 0.1.0__py3-none-any.whl

xone_cli/__init__.py

@@ -0,0 +1,4 @@
+from __future__ import annotations
+
+__version__ = "0.1.0"
+

xone_cli/__main__.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from xone_cli.cli import entrypoint
+
+
+if __name__ == "__main__":
+    entrypoint()
+

xone_cli/cli.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from collections.abc import Sequence
+
+from xone_cli import __version__
+from xone_cli.evidence import build_failure_packet, collect_evidence, collect_for_runbook, gate_evidence
+from xone_cli.lab import render_evidence_loop_lab
+from xone_cli.risk import render_risk_context
+from xone_cli.runbook import write_runbook
+from xone_cli.release import print_release_report, verify_release
+from xone_cli.tooling import doctor_status
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="xone")
+    parser.add_argument("--version", action="store_true", help="show version and exit")
+    subparsers = parser.add_subparsers(dest="command")
+
+    doctor = subparsers.add_parser("doctor", help="check local X-One tool availability")
+    doctor.add_argument("--json", action="store_true", help="write machine-readable status")
+    doctor.add_argument("--dry-run", action="store_true", help="show checks without running them")
+
+    evidence = subparsers.add_parser("evidence", help="work with PR evidence and failure packets")
+    evidence_subparsers = evidence.add_subparsers(dest="evidence_command")
+    collect = evidence_subparsers.add_parser("collect", help="collect PR evidence")
+    _add_evidence_collection_args(collect)
+    collect.add_argument("--output", type=Path, required=True, help="JSON evidence output path")
+    collect.add_argument("--dry-run", action="store_true")
+
+    gate = evidence_subparsers.add_parser("gate", help="run baseline gate")
+    _add_evidence_collection_args(gate)
+    gate.add_argument("--baseline", type=Path, required=True)
+    gate.add_argument("--dry-run", action="store_true")
+
+    packet = evidence_subparsers.add_parser("packet", help="build a redacted failure packet")
+    packet.add_argument("--input", type=Path, required=True)
+    packet.add_argument("--output", type=Path, required=True)
+    packet.add_argument("--profile", choices=("incident", "issue"), default="issue")
+    packet.add_argument("--dry-run", action="store_true")
+
+    risk = subparsers.add_parser("risk", help="work with MCP risk context")
+    risk_subparsers = risk.add_subparsers(dest="risk_command")
+    context = risk_subparsers.add_parser("context", help="render risk context")
+    context.add_argument("--catalog", type=Path, required=True)
+    context.add_argument("--output", type=Path, required=True)
+    context.add_argument("--dry-run", action="store_true")
+
+    lab = subparsers.add_parser("lab", help="work with safe-local lab scenarios")
+    lab_subparsers = lab.add_subparsers(dest="lab_command")
+    evidence_loop = lab_subparsers.add_parser("evidence-loop", help="render Agent Evidence Loop scenario")
+    evidence_loop.add_argument("--output", type=Path, required=True)
+    evidence_loop.add_argument("--dry-run", action="store_true")
+
+    release = subparsers.add_parser("release", help="verify local release readiness")
+    release_subparsers = release.add_subparsers(dest="release_command")
+    verify = release_subparsers.add_parser("verify", help="run release/package checks")
+    verify.add_argument("--project-root", type=Path, default=Path("."))
+    verify.add_argument("--build", action="store_true")
+    verify.add_argument("--install", action="store_true")
+    verify.add_argument("--smoke", action="store_true")
+    verify.add_argument("--json", action="store_true")
+
+    runbook = subparsers.add_parser("runbook", help="assemble a local X-One evidence runbook")
+    _add_evidence_collection_args(runbook)
+    runbook.add_argument("--output", type=Path)
+    runbook.add_argument("--dry-run", action="store_true", help="show underlying commands without running them")
+    runbook.add_argument("--json", action="store_true", help="write machine-readable summary")
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.version:
+        print(f"xone {__version__}")
+        return 0
+
+    if args.command == "doctor":
+        report = doctor_status()
+        payload = report.to_dict()
+        payload["dry_run"] = args.dry_run
+        if args.json:
+            print(json.dumps(payload, indent=2, sort_keys=True))
+        else:
+            _print_doctor(report)
+        return 0
+
+    if args.command == "evidence":
+        if args.evidence_command == "collect":
+            return collect_evidence(
+                repo=args.repo,
+                base=args.base,
+                head=args.head,
+                output=args.output,
+                test_logs=args.test_log,
+                profile=args.profile,
+                dry_run=args.dry_run,
+            )
+        if args.evidence_command == "gate":
+            return gate_evidence(
+                repo=args.repo,
+                base=args.base,
+                head=args.head,
+                baseline=args.baseline,
+                profile=args.profile,
+                dry_run=args.dry_run,
+            )
+        if args.evidence_command == "packet":
+            return build_failure_packet(
+                input_path=args.input,
+                output=args.output,
+                profile=args.profile,
+                dry_run=args.dry_run,
+            )
+
+    if args.command == "risk" and args.risk_command == "context":
+        return render_risk_context(catalog=args.catalog, output=args.output, dry_run=args.dry_run)
+
+    if args.command == "lab" and args.lab_command == "evidence-loop":
+        return render_evidence_loop_lab(output=args.output, dry_run=args.dry_run)
+
+    if args.command == "release" and args.release_command == "verify":
+        report = verify_release(
+            project_root=args.project_root,
+            build=args.build,
+            install=args.install,
+            smoke=args.smoke,
+        )
+        print_release_report(report, as_json=args.json)
+        return 0 if report["ok"] else 1
+
+    if args.command == "runbook":
+        code, report, message = collect_for_runbook(
+            repo=args.repo,
+            base=args.base,
+            head=args.head,
+            test_logs=args.test_log,
+            profile=args.profile,
+            dry_run=args.dry_run,
+        )
+        if code != 0:
+            print(message)
+            return code
+        if args.dry_run:
+            print(message)
+            return 0
+        payload = {
+            "schema_version": "xone.runbook.v1",
+            "handoff_decision": (report or {}).get("handoff_decision"),
+        }
+        if args.json:
+            print(json.dumps(payload, indent=2, sort_keys=True))
+        if args.output and report is not None:
+            write_runbook(report, args.output)
+        elif report is not None:
+            print(json.dumps(report, indent=2, sort_keys=True))
+        return 0
+
+    parser.print_help(sys.stderr)
+    return 2
+
+
+def entrypoint() -> None:
+    raise SystemExit(main())
+
+
+def _print_doctor(report) -> None:
+    print("X-One toolchain")
+    for tool in report.tools:
+        status = "ok" if tool.available else "missing"
+        print(f"- {tool.name}: {status}")
+        if tool.version:
+            print(f"  version: {tool.version}")
+        if not tool.available:
+            print(f"  install: {tool.install_hint}")
+
+
+def _add_evidence_collection_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--repo", default=".", help="git repository path")
+    parser.add_argument("--base", required=True, help="base git ref")
+    parser.add_argument("--head", required=True, help="head git ref")
+    parser.add_argument("--test-log", action="append", default=[], help="test log path; repeatable")
+    parser.add_argument("--profile", choices=("default", "strict"), default="strict")

xone_cli/evidence.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import json
+import tempfile
+from pathlib import Path
+
+from xone_cli.tooling import run_command
+
+
+def collect_evidence(
+    *,
+    repo: str,
+    base: str,
+    head: str,
+    output: Path | None,
+    test_logs: list[str],
+    profile: str,
+    dry_run: bool = False,
+) -> int:
+    command = [
+        "agent-pr-evidence",
+        "collect",
+        "--repo",
+        repo,
+        "--base",
+        base,
+        "--head",
+        head,
+        "--profile",
+        profile,
+        "--format",
+        "json",
+    ]
+    for test_log in test_logs:
+        command.extend(["--test-log", test_log])
+    if output:
+        command.extend(["--output", str(output)])
+    result = run_command(command, dry_run=dry_run)
+    print(result.stdout, end="" if result.stdout.endswith("\n") else "\n")
+    if result.stderr:
+        print(result.stderr, end="" if result.stderr.endswith("\n") else "\n")
+    return result.returncode
+
+
+def gate_evidence(
+    *,
+    repo: str,
+    base: str,
+    head: str,
+    baseline: Path,
+    profile: str,
+    dry_run: bool = False,
+) -> int:
+    command = [
+        "agent-pr-evidence",
+        "gate",
+        "--repo",
+        repo,
+        "--base",
+        base,
+        "--head",
+        head,
+        "--profile",
+        profile,
+        "--baseline",
+        str(baseline),
+        "--format",
+        "json",
+    ]
+    result = run_command(command, dry_run=dry_run)
+    print(result.stdout, end="" if result.stdout.endswith("\n") else "\n")
+    if result.stderr:
+        print(result.stderr, end="" if result.stderr.endswith("\n") else "\n")
+    return result.returncode
+
+
+def build_failure_packet(*, input_path: Path, output: Path, profile: str, dry_run: bool = False) -> int:
+    validate = run_command(["agent-failure-packet", "validate", "--input", str(input_path)], dry_run=dry_run)
+    print(validate.stdout, end="" if validate.stdout.endswith("\n") else "\n")
+    if validate.stderr:
+        print(validate.stderr, end="" if validate.stderr.endswith("\n") else "\n")
+    if validate.returncode != 0:
+        return validate.returncode
+
+    build = run_command(
+        [
+            "agent-failure-packet",
+            "build",
+            "--input",
+            str(input_path),
+            "--profile",
+            profile,
+            "--output",
+            str(output),
+        ],
+        dry_run=dry_run,
+    )
+    print(build.stdout, end="" if build.stdout.endswith("\n") else "\n")
+    if build.stderr:
+        print(build.stderr, end="" if build.stderr.endswith("\n") else "\n")
+    return build.returncode
+
+
+def collect_for_runbook(
+    *,
+    repo: str,
+    base: str,
+    head: str,
+    test_logs: list[str],
+    profile: str,
+    dry_run: bool,
+) -> tuple[int, dict | None, str]:
+    command = [
+        "agent-pr-evidence",
+        "collect",
+        "--repo",
+        repo,
+        "--base",
+        base,
+        "--head",
+        head,
+        "--profile",
+        profile,
+        "--format",
+        "json",
+    ]
+    for test_log in test_logs:
+        command.extend(["--test-log", test_log])
+    if dry_run:
+        result = run_command(command, dry_run=True)
+        return result.returncode, None, result.stdout
+    with tempfile.TemporaryDirectory(prefix="xone-runbook-") as tmp:
+        output = Path(tmp) / "evidence.json"
+        result = run_command([*command, "--output", str(output)])
+        if result.returncode != 0:
+            return result.returncode, None, result.stderr or result.stdout
+        return 0, json.loads(output.read_text(encoding="utf-8")), ""
+

xone_cli/lab.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+
+from xone_cli.tooling import run_command
+
+
+def render_evidence_loop_lab(*, output: Path, dry_run: bool = False) -> int:
+    with tempfile.TemporaryDirectory(prefix="xone-lab-") as tmp:
+        scenario_dir = Path(tmp) / "scenarios"
+        init = run_command(["ai-incident-lab", "init", "--output", str(scenario_dir)], dry_run=dry_run)
+        print(init.stdout, end="" if init.stdout.endswith("\n") else "\n")
+        if init.stderr:
+            print(init.stderr, end="" if init.stderr.endswith("\n") else "\n")
+        if init.returncode != 0:
+            return init.returncode
+
+        scenario = scenario_dir / "agent-evidence-loop.yml"
+        validate = run_command(["ai-incident-lab", "validate", "--scenarios", str(scenario_dir)], dry_run=dry_run)
+        print(validate.stdout, end="" if validate.stdout.endswith("\n") else "\n")
+        if validate.stderr:
+            print(validate.stderr, end="" if validate.stderr.endswith("\n") else "\n")
+        if validate.returncode != 0:
+            return validate.returncode
+
+        render = run_command(
+            ["ai-incident-lab", "render", "--scenarios", str(scenario), "--format", "markdown"],
+            dry_run=dry_run,
+        )
+        if render.returncode == 0 and not dry_run:
+            output.write_text(render.stdout, encoding="utf-8")
+        else:
+            print(render.stdout, end="" if render.stdout.endswith("\n") else "\n")
+        if render.stderr:
+            print(render.stderr, end="" if render.stderr.endswith("\n") else "\n")
+        return render.returncode
+

xone_cli/model.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+
+
+@dataclass(frozen=True)
+class CommandResult:
+    command: list[str]
+    returncode: int
+    stdout: str
+    stderr: str
+    dry_run: bool = False
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class ToolStatus:
+    name: str
+    executable: str | None
+    available: bool
+    version: str | None
+    install_hint: str
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class DoctorReport:
+    schema_version: str
+    tools: list[ToolStatus]
+
+    @property
+    def ok(self) -> bool:
+        return all(tool.available for tool in self.tools)
+
+    def to_dict(self) -> dict:
+        data = asdict(self)
+        data["ok"] = self.ok
+        return data
+

xone_cli/release.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from pathlib import Path
+
+from xone_cli.tooling import run_command
+
+RELEASE_VERIFY_SCHEMA_VERSION = "xone.release.verify.v1"
+
+REQUIRED_RELEASE_FILES = (
+    "pyproject.toml",
+    "README.md",
+    "README.zh-CN.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    ".github/workflows/ci.yml",
+    ".github/workflows/publish.yml",
+)
+
+
+def required_files_status(project_root: Path) -> dict[str, bool]:
+    return {name: (project_root / name).exists() for name in REQUIRED_RELEASE_FILES}
+
+
+def verify_release(
+    *,
+    project_root: Path,
+    build: bool,
+    install: bool,
+    smoke: bool,
+) -> dict:
+    project_root = project_root.resolve()
+    required_files = required_files_status(project_root)
+    checks: list[dict] = []
+    release_env = _release_subprocess_env()
+    smoke_commands: list[list[str]] = [
+        ["python", "-m", "xone_cli", "--version"],
+        ["python", "-m", "xone_cli", "doctor", "--json"],
+    ]
+
+    if build:
+        result = run_command(["python", "-m", "build"], dry_run=False, cwd=project_root, env=release_env)
+        checks.append(_check("build", result.returncode, result.stdout, result.stderr))
+
+    if install:
+        with tempfile.TemporaryDirectory(prefix="xone-release-venv-") as tmp:
+            venv_dir = Path(tmp) / "venv"
+            venv = run_command(["python", "-m", "venv", str(venv_dir)])
+            checks.append(_check("venv", venv.returncode, venv.stdout, venv.stderr))
+            if venv.returncode == 0:
+                wheel = _latest_wheel(project_root)
+                if wheel:
+                    pip = venv_dir / "bin" / "pip"
+                    installed = run_command([str(pip), "install", str(wheel)], env=release_env)
+                    checks.append(_check("wheel-install", installed.returncode, installed.stdout, installed.stderr))
+                    xone = venv_dir / "bin" / "xone"
+                    smoke_commands = [
+                        [str(xone), "--version"],
+                        [str(xone), "doctor", "--json"],
+                    ]
+                else:
+                    checks.append({"name": "wheel-install", "returncode": 1, "stdout": "", "stderr": "No wheel found in dist/"})
+
+            if smoke:
+                for name, command in (("cli-version", smoke_commands[0]), ("doctor-json", smoke_commands[1])):
+                    result = run_command(command, cwd=project_root, env=release_env)
+                    checks.append(_check(name, result.returncode, result.stdout, result.stderr))
+    elif smoke:
+        for name, command in (("cli-version", smoke_commands[0]), ("doctor-json", smoke_commands[1])):
+            result = run_command(command, cwd=project_root, env=release_env)
+            checks.append(_check(name, result.returncode, result.stdout, result.stderr))
+
+    ok = all(required_files.values()) and all(check["returncode"] == 0 for check in checks)
+    return {
+        "schema_version": RELEASE_VERIFY_SCHEMA_VERSION,
+        "ok": ok,
+        "required_files": required_files,
+        "checks": checks,
+    }
+
+
+def print_release_report(report: dict, *, as_json: bool) -> None:
+    if as_json:
+        print(json.dumps(report, indent=2, sort_keys=True))
+        return
+    print("X-One release verification")
+    print(f"ok: {str(report['ok']).lower()}")
+    print("required files:")
+    for name, exists in report["required_files"].items():
+        print(f"- {name}: {'ok' if exists else 'missing'}")
+    if report["checks"]:
+        print("checks:")
+        for check in report["checks"]:
+            print(f"- {check['name']}: {'ok' if check['returncode'] == 0 else 'failed'}")
+
+
+def _check(name: str, returncode: int, stdout: str, stderr: str) -> dict:
+    return {"name": name, "returncode": returncode, "stdout": stdout[-2000:], "stderr": stderr[-2000:]}
+
+
+def _latest_wheel(project_root: Path) -> Path | None:
+    wheels = sorted((project_root / "dist").glob("*.whl"), key=lambda path: path.stat().st_mtime, reverse=True)
+    return wheels[0] if wheels else None
+
+
+def _release_subprocess_env() -> dict[str, str]:
+    env = dict(os.environ)
+    env.pop("PYTHONPATH", None)
+    return env

xone_cli/risk.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from xone_cli.tooling import run_command
+
+RISK_CONTEXT_BOUNDARY = "This is review context, not an allow/deny decision."
+
+
+def render_risk_context(*, catalog: Path, output: Path, dry_run: bool = False) -> int:
+    validate = run_command(["mcp-risk-index", "validate", "--catalog", str(catalog), "--strict"], dry_run=dry_run)
+    print(validate.stdout, end="" if validate.stdout.endswith("\n") else "\n")
+    if validate.stderr:
+        print(validate.stderr, end="" if validate.stderr.endswith("\n") else "\n")
+    if validate.returncode != 0:
+        return validate.returncode
+
+    rendered = run_command(["mcp-risk-index", "render", "--catalog", str(catalog), "--format", "markdown"], dry_run=dry_run)
+    if rendered.returncode == 0 and not dry_run:
+        output.write_text(f"> {RISK_CONTEXT_BOUNDARY}\n\n{rendered.stdout}", encoding="utf-8")
+    else:
+        print(rendered.stdout, end="" if rendered.stdout.endswith("\n") else "\n")
+    if rendered.stderr:
+        print(rendered.stderr, end="" if rendered.stderr.endswith("\n") else "\n")
+    return rendered.returncode
+

xone_cli/runbook.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+def render_runbook(report: dict) -> str:
+    decision = report.get("handoff_decision") or {}
+    lines = [
+        "# X-One Evidence Runbook",
+        "",
+        "## Handoff Decision",
+        "",
+        f"- Decision: `{decision.get('decision', 'unknown')}`",
+        f"- Reason: {decision.get('reason', 'not provided')}",
+        f"- Evidence source: {decision.get('evidence_source', 'not provided')}",
+        f"- Handoff target: {decision.get('handoff_target', 'not provided')}",
+        f"- Revisit trigger: {decision.get('revisit_trigger', 'not provided')}",
+        "",
+        "## Next Action",
+        "",
+        _next_action(decision.get("decision")),
+        "",
+        "## Raw Summary",
+        "",
+        "```json",
+        json.dumps(report.get("summary", {}), indent=2, sort_keys=True),
+        "```",
+        "",
+    ]
+    return "\n".join(lines)
+
+
+def write_runbook(report: dict, output: Path) -> None:
+    output.write_text(render_runbook(report), encoding="utf-8")
+
+
+def _next_action(decision: str | None) -> str:
+    if decision == "create-failure-packet":
+        return "- Build a redacted failure packet with `xone evidence packet`."
+    if decision == "block-before-merge":
+        return "- Add passing tests, an accountable owner, or a remediation plan before merge."
+    if decision == "baseline-review":
+        return "- Review the baseline before accepting new or existing risk."
+    if decision == "request-test-evidence":
+        return "- Provide test logs or explain why tests are not required."
+    return "- Continue normal review."
+

xone_cli/tooling.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import shlex
+import shutil
+import subprocess
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+
+from xone_cli.model import CommandResult, DoctorReport, ToolStatus
+
+DOCTOR_SCHEMA_VERSION = "xone.doctor.v1"
+
+REQUIRED_TOOLS = (
+    "agent-pr-evidence",
+    "agent-failure-packet",
+    "mcp-risk-index",
+    "ai-incident-lab",
+)
+
+PACKAGE_BY_TOOL = {
+    "agent-pr-evidence": "xone-agent-pr-evidence",
+    "agent-failure-packet": "xone-agent-failure-packet",
+    "mcp-risk-index": "xone-mcp-risk-index",
+    "ai-incident-lab": "xone-ai-incident-lab",
+}
+
+
+def find_tool(name: str) -> str | None:
+    return shutil.which(name)
+
+
+def install_hint(name: str) -> str:
+    package = PACKAGE_BY_TOOL.get(name, name)
+    return f"python -m pip install {package}"
+
+
+def run_command(
+    command: Sequence[str],
+    *,
+    dry_run: bool = False,
+    cwd: Path | None = None,
+    env: Mapping[str, str] | None = None,
+) -> CommandResult:
+    command_list = [str(part) for part in command]
+    if dry_run:
+        return CommandResult(
+            command=command_list,
+            returncode=0,
+            stdout=f"DRY RUN: {_format_command(command_list)}",
+            stderr="",
+            dry_run=True,
+        )
+
+    try:
+        completed = subprocess.run(
+            command_list,
+            check=False,
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            cwd=cwd,
+            env=dict(env) if env is not None else None,
+        )
+    except FileNotFoundError as error:
+        return CommandResult(
+            command=command_list,
+            returncode=127,
+            stdout="",
+            stderr=str(error),
+        )
+    return CommandResult(
+        command=command_list,
+        returncode=completed.returncode,
+        stdout=completed.stdout,
+        stderr=completed.stderr,
+    )
+
+
+def doctor_status() -> DoctorReport:
+    tools = [_tool_status(name) for name in REQUIRED_TOOLS]
+    return DoctorReport(schema_version=DOCTOR_SCHEMA_VERSION, tools=tools)
+
+
+def _tool_status(name: str) -> ToolStatus:
+    executable = find_tool(name)
+    if not executable:
+        return ToolStatus(
+            name=name,
+            executable=None,
+            available=False,
+            version=None,
+            install_hint=install_hint(name),
+        )
+    version_result = run_command([name, "--version"])
+    version = version_result.stdout.strip() if version_result.returncode == 0 else None
+    return ToolStatus(
+        name=name,
+        executable=executable,
+        available=True,
+        version=version,
+        install_hint=install_hint(name),
+    )
+
+
+def _format_command(command: Sequence[str]) -> str:
+    return " ".join(shlex.quote(part) for part in command)

xone_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: xone-cli
+Version: 0.1.0
+Summary: Unified CLI entry point for X-One Agent Evidence Loop workflows.
+Author: X-One-AI
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/X-One-AI/xone-cli
+Project-URL: Repository, https://github.com/X-One-AI/xone-cli
+Project-URL: Issues, https://github.com/X-One-AI/xone-cli/issues
+Keywords: ai,agents,devsecops,mcp,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: build>=1.2.2; extra == "dev"
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
+# xone-cli
+
+Languages: English | [中文](./README.zh-CN.md)
+
+`xone-cli` is the unified local entry point for X-One Agent Evidence Loop workflows.
+
+It helps developers move from scattered tools to one clear path:
+
+```text
+collect PR evidence
+-> decide handoff
+-> create failure packet when needed
+-> attach MCP risk context when useful
+-> run safe-local training scenarios
+```
+
+## Install
+
+```bash
+python -m pip install xone-cli
+xone --version
+xone doctor
+```
+
+## First Run
+
+```bash
+xone doctor
+xone runbook --base main --head HEAD --dry-run
+```
+
+`xone-cli` orchestrates these X-One tools:
+
+- `agent-pr-evidence`
+- `agent-failure-packet`
+- `mcp-risk-index`
+- `ai-incident-lab`
+
+## Boundary
+
+- It does not replace the underlying tools.
+- It does not post GitHub comments.
+- It does not modify repositories automatically.
+- It does not make allow/deny runtime enforcement decisions.
+- It does not make hidden network calls.
+
+## Docs
+
+- [Product Foundation](./docs/product-foundation.md)
+- [Install](./docs/install.md)
+- [Release](./docs/release.md)
+- [Open-source Feedback Ledger](./docs/feedback/open-source-feedback-ledger.md)

xone_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+xone_cli/__init__.py,sha256=YosWCpCE15wFKb9PYPbECNR0HI0P7moX8U0yX319veg,59
+xone_cli/__main__.py,sha256=J4Wq8cwjCVitF0nyuoNwPmGAthKhoaPiVobP6l3_e-w,119
+xone_cli/cli.py,sha256=gek02J0PgTRYdnHOSdhCf5veIHzBTP4j73VFnFS1q1w,7760
+xone_cli/evidence.py,sha256=9Dbzb-GTVxaf2RVrKgLwvlI8S9qeEaXJoW2LfmB4bIA,3571
+xone_cli/lab.py,sha256=8KU7Pti_1Co9NY5wmR1zHcEgzOGMalA2zWu_3EWTtrk,1631
+xone_cli/model.py,sha256=XRm1-8n8HXCkfj8Nx7vDDpKnCGDF11MlMO1_Zem2J9o,804
+xone_cli/release.py,sha256=RcbjD-ydgOhzQfwagU1A3MqAtBOb9hFooEmMeJuBViY,4186
+xone_cli/risk.py,sha256=-XV6drlXUwrolpfU5lxxsJTpu3y5BbcebWNRpgoERXI,1142
+xone_cli/runbook.py,sha256=twUO0yjF4K8vpJA_dBMSa1HvF9-_vuzXDuInjtTpbBY,1649
+xone_cli/tooling.py,sha256=c2BRssDHRWFQaX2jvHd5yDLXNcrsj4nbEShtEtV5Les,2790
+xone_cli-0.1.0.dist-info/licenses/LICENSE,sha256=2AV3_k1rPe0sVkPEDXEeDKTvt3wS9rQm0Yu7wcRBCVw,1066
+xone_cli-0.1.0.dist-info/METADATA,sha256=5YVycYbFK3AVZh8OoMIaEx1i2UHZO788W7mdEDdCoFs,2157
+xone_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+xone_cli-0.1.0.dist-info/entry_points.txt,sha256=hH0QkGff99qEymxv5xd8lJE9zoXjVf7qsixgX4yMPMA,49
+xone_cli-0.1.0.dist-info/top_level.txt,sha256=Q8zVoHnDEJIJHvSd8tvff5HWUXeQgqfq7o3SA7Ir-lk,9
+xone_cli-0.1.0.dist-info/RECORD,,

xone_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

xone_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+xone = xone_cli.cli:entrypoint

xone_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 X-One-AI
+
+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.
+

xone_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+xone_cli