coding-cli-runtime 0.1.0__py3-none-any.whl

coding_cli_runtime/session_logs.py

@@ -0,0 +1,129 @@
+"""Session log discovery helpers shared across provider wrappers."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from pathlib import Path
+
+
+def normalize_path_str(path_str: str) -> str:
+    try:
+        return str(Path(path_str).resolve())
+    except OSError:
+        return os.path.normpath(path_str)
+
+
+def codex_session_roots() -> list[Path]:
+    base = Path.home() / ".codex"
+    return [base / "sessions", base / "archived_sessions"]
+
+
+def claude_project_roots() -> list[Path]:
+    return [Path.home() / ".claude" / "projects"]
+
+
+def claude_project_key(workdir: Path) -> str:
+    normalized = workdir.as_posix().lstrip("/")
+    if not normalized:
+        return "-"
+    slug = re.sub(r"[^A-Za-z0-9-]", "-", normalized)
+    return f"-{slug}"
+
+
+def codex_session_matches(log_path: Path, workdir: str, *, max_lines: int = 50) -> bool:
+    try:
+        with log_path.open("r", encoding="utf-8") as handle:
+            for _ in range(max_lines):
+                line = handle.readline()
+                if not line:
+                    break
+                try:
+                    record = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                payload = record.get("payload")
+                if not isinstance(payload, dict):
+                    continue
+                cwd = payload.get("cwd")
+                if isinstance(cwd, str) and normalize_path_str(cwd) == workdir:
+                    return True
+    except OSError:
+        return False
+    return False
+
+
+def find_codex_session(
+    workdir: str,
+    since_ts: float,
+    *,
+    session_roots: list[Path] | None = None,
+    max_scan: int = 200,
+) -> Path | None:
+    def safe_mtime(path: Path) -> float | None:
+        try:
+            return path.stat().st_mtime
+        except OSError:
+            return None
+
+    roots = session_roots if session_roots is not None else codex_session_roots()
+    candidates: list[tuple[float, Path]] = []
+    for root in roots:
+        if not root.exists():
+            continue
+        try:
+            for path in root.rglob("*.jsonl"):
+                mtime = safe_mtime(path)
+                if mtime is None:
+                    continue
+                if mtime >= since_ts - 15:
+                    candidates.append((mtime, path))
+        except (OSError, RuntimeError):
+            continue
+    if not candidates:
+        return None
+
+    candidates.sort(key=lambda item: item[0], reverse=True)
+    for _, path in candidates[:max_scan]:
+        if codex_session_matches(path, workdir):
+            return path
+    return None
+
+
+def find_claude_session(
+    workdir: str,
+    since_ts: float,
+    *,
+    project_roots: list[Path] | None = None,
+    max_scan: int = 200,
+) -> Path | None:
+    def safe_mtime(path: Path) -> float | None:
+        try:
+            return path.stat().st_mtime
+        except OSError:
+            return None
+
+    workdir_path = Path(normalize_path_str(workdir))
+    project_key = claude_project_key(workdir_path)
+    roots = project_roots if project_roots is not None else claude_project_roots()
+    candidates: list[tuple[float, Path]] = []
+    for root in roots:
+        project_dir = root / project_key
+        if not project_dir.exists():
+            continue
+        try:
+            for path in project_dir.glob("*.jsonl"):
+                mtime = safe_mtime(path)
+                if mtime is None:
+                    continue
+                if mtime >= since_ts - 10:
+                    candidates.append((mtime, path))
+        except (OSError, RuntimeError):
+            continue
+
+    if not candidates:
+        return None
+
+    candidates.sort(key=lambda item: item[0], reverse=True)
+    return candidates[:max_scan][0][1]

coding_cli_runtime/subprocess_runner.py

@@ -0,0 +1,346 @@
+"""Async subprocess execution wrapper with normalized result shape."""
+
+from __future__ import annotations
+
+import asyncio
+import subprocess
+import threading
+import time
+from pathlib import Path
+from typing import BinaryIO
+
+from .contracts import CliRunRequest, CliRunResult, ErrorCode
+
+
+def _decode_output(payload: bytes | str | None) -> str:
+    if payload is None:
+        return ""
+    if isinstance(payload, str):
+        return payload
+    return payload.decode("utf-8", errors="replace")
+
+
+def _open_stream_handle(path: Path | None) -> BinaryIO | None:
+    if path is None:
+        return None
+    path.parent.mkdir(parents=True, exist_ok=True)
+    return path.open("wb")
+
+
+def _stream_pipe(
+    pipe: BinaryIO | None,
+    chunks: list[bytes],
+    stream_handle: BinaryIO | None,
+) -> None:
+    if pipe is None:
+        return
+    while True:
+        chunk = pipe.read(4096)
+        if not chunk:
+            break
+        chunks.append(chunk)
+        if stream_handle is not None:
+            stream_handle.write(chunk)
+            stream_handle.flush()
+
+
+async def run_cli_command(request: CliRunRequest) -> CliRunResult:
+    started = time.monotonic()
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *request.cmd_parts,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            stdin=(
+                asyncio.subprocess.PIPE
+                if request.stdin_text is not None
+                else asyncio.subprocess.DEVNULL
+            ),
+            cwd=str(request.cwd),
+            env=request.env,
+        )
+    except Exception as exc:
+        duration = time.monotonic() - started
+        return CliRunResult(
+            command=list(request.cmd_parts),
+            returncode=None,
+            stdout_text="",
+            stderr_text="",
+            duration_seconds=duration,
+            timed_out=False,
+            error_code=ErrorCode.SPAWN_FAILED,
+            error_message=str(exc),
+        )
+
+    stdin_bytes = request.stdin_text.encode("utf-8") if request.stdin_text is not None else None
+    try:
+        if request.timeout_seconds and request.timeout_seconds > 0:
+            stdout, stderr = await asyncio.wait_for(
+                proc.communicate(input=stdin_bytes), timeout=request.timeout_seconds
+            )
+        else:
+            stdout, stderr = await proc.communicate(input=stdin_bytes)
+    except TimeoutError:
+        try:
+            proc.kill()
+        except ProcessLookupError:
+            pass
+        await proc.wait()
+        duration = time.monotonic() - started
+        return CliRunResult(
+            command=list(request.cmd_parts),
+            returncode=None,
+            stdout_text="",
+            stderr_text="",
+            duration_seconds=duration,
+            timed_out=True,
+            error_code=ErrorCode.TIMED_OUT,
+            error_message=f"process timed out after {request.timeout_seconds}s",
+        )
+
+    duration = time.monotonic() - started
+    stdout_text = stdout.decode("utf-8", errors="replace")
+    stderr_text = stderr.decode("utf-8", errors="replace")
+
+    if proc.returncode != 0:
+        return CliRunResult(
+            command=list(request.cmd_parts),
+            returncode=proc.returncode,
+            stdout_text=stdout_text,
+            stderr_text=stderr_text,
+            duration_seconds=duration,
+            timed_out=False,
+            error_code=ErrorCode.NON_ZERO_EXIT,
+            error_message=f"process exited with code {proc.returncode}",
+        )
+
+    return CliRunResult(
+        command=list(request.cmd_parts),
+        returncode=proc.returncode,
+        stdout_text=stdout_text,
+        stderr_text=stderr_text,
+        duration_seconds=duration,
+        timed_out=False,
+        error_code=ErrorCode.NONE,
+        error_message=None,
+    )
+
+
+def run_cli_command_sync(request: CliRunRequest) -> CliRunResult:
+    started = time.monotonic()
+    stdin_bytes = request.stdin_text.encode("utf-8") if request.stdin_text is not None else None
+    timeout = (
+        request.timeout_seconds if request.timeout_seconds and request.timeout_seconds > 0 else None
+    )
+    stream_requested = (
+        request.stdout_stream_path is not None or request.stderr_stream_path is not None
+    )
+    if stream_requested:
+        return _run_cli_command_sync_streaming(
+            request=request,
+            started=started,
+            stdin_bytes=stdin_bytes,
+            timeout=timeout,
+        )
+
+    try:
+        run_kwargs = {
+            "cwd": str(request.cwd),
+            "env": request.env,
+            "input": stdin_bytes,
+            "capture_output": True,
+            "timeout": timeout,
+            "check": False,
+        }
+        if request.stdin_text is None:
+            run_kwargs["stdin"] = subprocess.DEVNULL
+        completed = subprocess.run(
+            request.cmd_parts,
+            **run_kwargs,  # type: ignore[call-overload]
+        )
+        duration = time.monotonic() - started
+    except subprocess.TimeoutExpired as exc:
+        duration = time.monotonic() - started
+        return CliRunResult(
+            command=list(request.cmd_parts),
+            returncode=None,
+            stdout_text=_decode_output(exc.stdout),
+            stderr_text=_decode_output(exc.stderr),
+            duration_seconds=duration,
+            timed_out=True,
+            error_code=ErrorCode.TIMED_OUT,
+            error_message=f"process timed out after {request.timeout_seconds}s",
+        )
+    except Exception as exc:
+        duration = time.monotonic() - started
+        return CliRunResult(
+            command=list(request.cmd_parts),
+            returncode=None,
+            stdout_text="",
+            stderr_text="",
+            duration_seconds=duration,
+            timed_out=False,
+            error_code=ErrorCode.SPAWN_FAILED,
+            error_message=str(exc),
+        )
+
+    stdout_text = _decode_output(completed.stdout)
+    stderr_text = _decode_output(completed.stderr)
+    if completed.returncode != 0:
+        return CliRunResult(
+            command=list(request.cmd_parts),
+            returncode=completed.returncode,
+            stdout_text=stdout_text,
+            stderr_text=stderr_text,
+            duration_seconds=duration,
+            timed_out=False,
+            error_code=ErrorCode.NON_ZERO_EXIT,
+            error_message=f"process exited with code {completed.returncode}",
+        )
+
+    return CliRunResult(
+        command=list(request.cmd_parts),
+        returncode=completed.returncode,
+        stdout_text=stdout_text,
+        stderr_text=stderr_text,
+        duration_seconds=duration,
+        timed_out=False,
+        error_code=ErrorCode.NONE,
+        error_message=None,
+    )
+
+
+def _run_cli_command_sync_streaming(
+    *,
+    request: CliRunRequest,
+    started: float,
+    stdin_bytes: bytes | None,
+    timeout: float | None,
+) -> CliRunResult:
+    stdout_chunks: list[bytes] = []
+    stderr_chunks: list[bytes] = []
+    stdout_stream = _open_stream_handle(request.stdout_stream_path)
+    stderr_stream = _open_stream_handle(request.stderr_stream_path)
+    proc: subprocess.Popen[bytes] | None = None
+    stdin_thread: threading.Thread | None = None
+    stdout_thread: threading.Thread | None = None
+    stderr_thread: threading.Thread | None = None
+    try:
+        proc = subprocess.Popen(
+            request.cmd_parts,
+            cwd=str(request.cwd),
+            env=request.env,
+            stdin=(subprocess.PIPE if request.stdin_text is not None else subprocess.DEVNULL),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        def _write_stdin() -> None:
+            if proc is None or proc.stdin is None:
+                return
+            try:
+                if stdin_bytes is not None:
+                    proc.stdin.write(stdin_bytes)
+                    proc.stdin.flush()
+            except (BrokenPipeError, OSError):
+                pass
+            finally:
+                try:
+                    proc.stdin.close()
+                except OSError:
+                    pass
+
+        if request.stdin_text is not None:
+            stdin_thread = threading.Thread(target=_write_stdin, daemon=True)
+            stdin_thread.start()
+        stdout_thread = threading.Thread(
+            target=_stream_pipe,
+            args=(proc.stdout, stdout_chunks, stdout_stream),
+            daemon=True,
+        )
+        stderr_thread = threading.Thread(
+            target=_stream_pipe,
+            args=(proc.stderr, stderr_chunks, stderr_stream),
+            daemon=True,
+        )
+        stdout_thread.start()
+        stderr_thread.start()
+
+        timed_out = False
+        try:
+            proc.wait(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            timed_out = True
+            try:
+                proc.kill()
+            except ProcessLookupError:
+                pass
+            proc.wait()
+
+        if stdin_thread is not None:
+            stdin_thread.join()
+        if stdout_thread is not None:
+            stdout_thread.join()
+        if stderr_thread is not None:
+            stderr_thread.join()
+
+        duration = time.monotonic() - started
+        stdout_text = _decode_output(b"".join(stdout_chunks))
+        stderr_text = _decode_output(b"".join(stderr_chunks))
+        if timed_out:
+            return CliRunResult(
+                command=list(request.cmd_parts),
+                returncode=None,
+                stdout_text=stdout_text,
+                stderr_text=stderr_text,
+                duration_seconds=duration,
+                timed_out=True,
+                error_code=ErrorCode.TIMED_OUT,
+                error_message=f"process timed out after {request.timeout_seconds}s",
+            )
+        if proc.returncode != 0:
+            return CliRunResult(
+                command=list(request.cmd_parts),
+                returncode=proc.returncode,
+                stdout_text=stdout_text,
+                stderr_text=stderr_text,
+                duration_seconds=duration,
+                timed_out=False,
+                error_code=ErrorCode.NON_ZERO_EXIT,
+                error_message=f"process exited with code {proc.returncode}",
+            )
+        return CliRunResult(
+            command=list(request.cmd_parts),
+            returncode=proc.returncode,
+            stdout_text=stdout_text,
+            stderr_text=stderr_text,
+            duration_seconds=duration,
+            timed_out=False,
+            error_code=ErrorCode.NONE,
+            error_message=None,
+        )
+    except Exception as exc:
+        duration = time.monotonic() - started
+        return CliRunResult(
+            command=list(request.cmd_parts),
+            returncode=None,
+            stdout_text=_decode_output(b"".join(stdout_chunks)),
+            stderr_text=_decode_output(b"".join(stderr_chunks)),
+            duration_seconds=duration,
+            timed_out=False,
+            error_code=ErrorCode.SPAWN_FAILED,
+            error_message=str(exc),
+        )
+    finally:
+        if proc is not None:
+            for pipe in (proc.stdin, proc.stdout, proc.stderr):
+                if pipe is None:
+                    continue
+                try:
+                    pipe.close()
+                except OSError:
+                    pass
+        if stdout_stream is not None:
+            stdout_stream.close()
+        if stderr_stream is not None:
+            stderr_stream.close()

coding_cli_runtime-0.1.0.dist-info/METADATA

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: coding-cli-runtime
+Version: 0.1.0
+Summary: Reusable CLI runtime primitives for provider-backed automation workflows
+Author-email: LLM Eval maintainers <llm-eval-maintainers@users.noreply.github.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pj-ms/llm-eval/tree/main/packages/coding-cli-runtime
+Project-URL: Repository, https://github.com/pj-ms/llm-eval
+Project-URL: Issues, https://github.com/pj-ms/llm-eval/issues
+Project-URL: Changelog, https://github.com/pj-ms/llm-eval/blob/main/packages/coding-cli-runtime/CHANGELOG.md
+Keywords: cli,runtime,llm,automation,schema-validation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# coding-cli-runtime
+
+[![PyPI](https://img.shields.io/pypi/v/coding-cli-runtime)](https://pypi.org/project/coding-cli-runtime/)
+[![Python](https://img.shields.io/pypi/pyversions/coding-cli-runtime)](https://pypi.org/project/coding-cli-runtime/)
+[![Build](https://github.com/pj-ms/llm-eval/actions/workflows/ci.yml/badge.svg)](https://github.com/pj-ms/llm-eval/actions/workflows/ci.yml)
+[![License](https://img.shields.io/pypi/l/coding-cli-runtime)](LICENSE)
+
+A Python library for orchestrating LLM coding agent CLIs — [Claude Code](https://docs.anthropic.com/en/docs/claude-code), [Codex](https://github.com/openai/codex), [Gemini CLI](https://github.com/google-gemini/gemini-cli), and [GitHub Copilot](https://docs.github.com/en/copilot).
+
+These CLIs each have different invocation patterns, output formats, error
+shapes, and timeout behaviors. This library normalizes all of that behind
+a common `CliRunRequest` → `CliRunResult` contract, so your automation
+code doesn't need provider-specific subprocess handling.
+
+**What it does (and why not just `subprocess.run`):**
+
+- Unified request/result types across all four CLIs
+- Timeout enforcement with graceful process termination
+- Provider-aware failure classification (retryable vs fatal)
+- Built-in model catalog with defaults, reasoning levels, and capabilities
+- Interactive session management for long-running generation tasks
+- Zero runtime dependencies
+
+## Installation
+
+```bash
+pip install coding-cli-runtime
+```
+
+Requires Python 3.10+.
+
+## Examples
+
+### Execute a provider CLI
+
+```python
+import asyncio
+from pathlib import Path
+from coding_cli_runtime import CliRunRequest, run_cli_command
+
+request = CliRunRequest(
+    cmd_parts=("codex", "--model", "o4-mini", "--quiet", "exec", "fix the tests"),
+    cwd=Path("/tmp/my-project"),
+    timeout_seconds=120,
+)
+result = asyncio.run(run_cli_command(request))
+
+print(result.returncode)        # 0
+print(result.error_code)        # "none"
+print(result.duration_seconds)  # 14.2
+print(result.stdout_text[:200])
+```
+
+Swap `codex` for `claude`, `gemini`, or `copilot` — the request/result
+shape stays the same. A synchronous variant `run_cli_command_sync` is also
+available.
+
+### Pick a model from the provider catalog
+
+```python
+from coding_cli_runtime import get_provider_spec
+
+codex = get_provider_spec("codex")
+print(codex.default_model)   # "gpt-5.3-codex"
+print(codex.model_source)    # "codex_cli_cache", "override", or "code"
+
+for model in codex.models:
+    print(f"  {model.name}: {model.description}")
+```
+
+The catalog covers all four providers — each with model names, reasoning
+levels, default settings, and visibility flags.
+
+Model lists are resolved with a three-tier fallback:
+
+1. **User override** — drop a JSON file at
+   `~/.config/coding-cli-runtime/providers/<provider>.json` to use your own
+   model list immediately, without waiting for a package update.
+2. **Live CLI cache** — for Codex, the library reads
+   `~/.codex/models_cache.json` (auto-refreshed by the Codex CLI) when
+   present. Other providers fall through because their CLIs don't expose a
+   machine-readable model list.
+3. **Hardcoded fallback** — the model list shipped with the package.
+
+Override file format:
+
+```json
+{
+  "default_model": "claude-sonnet-4-7",
+  "models": [
+    "claude-sonnet-4-7",
+    {
+      "name": "claude-opus-5",
+      "description": "Latest opus model",
+      "controls": [
+        { "name": "effort", "kind": "choice", "choices": ["low", "high"], "default": "low" }
+      ]
+    }
+  ]
+}
+```
+
+Set `CODING_CLI_RUNTIME_CONFIG_DIR` to change the config directory
+(default: `~/.config/coding-cli-runtime`).
+
+### Decide whether to retry a failed run
+
+```python
+from coding_cli_runtime import classify_provider_failure
+
+classification = classify_provider_failure(
+    provider="gemini",
+    stderr_text="429 Resource exhausted: rate limit exceeded",
+)
+
+if classification.retryable:
+    print(f"Retryable ({classification.category}) — will retry")
+else:
+    print(f"Fatal ({classification.category}) — giving up")
+```
+
+Works for all four providers. Recognizes auth failures, rate limits,
+network transients, and other provider-specific error patterns.
+
+## Key types
+
+| Type | Purpose |
+|------|---------|
+| `CliRunRequest` | Command spec: cmd, cwd, env, timeout, stream paths |
+| `CliRunResult` | Result: returncode, stdout/stderr, duration, error code |
+| `ErrorCode` | `none` · `spawn_failed` · `timed_out` · `non_zero_exit` |
+| `ProviderSpec` | Provider catalog entry with models, controls, defaults |
+| `FailureClassification` | Classified error with retryable flag and category |
+
+`run_interactive_session()` manages long-running CLI processes with
+timeout enforcement, process-group cleanup, transcript mirroring, and
+automatic retries. Only `cmd_parts`, `cwd`, `stdin_text`, and `logger` are
+required — observability labels like `job_name` and `phase_tag` default to
+sensible values so external callers don't need to invent them.
+
+## Prerequisites
+
+This package does **not** bundle any CLI binaries or credentials. You must
+install and authenticate the relevant provider CLI yourself before using the
+execution helpers.
+
+## Status
+
+Pre-1.0. API may change between minor versions.
+
+## License
+
+MIT

coding_cli_runtime-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+coding_cli_runtime/__init__.py,sha256=edCw6YCLaukPFtSjw-EEnLiPiUYnwyKfGl0UhlGxx2M,2979
+coding_cli_runtime/auth.py,sha256=LVQwdODVSLv-MkDBCeB_0J1R8uE3DsL9mYeF4ljil0Y,1644
+coding_cli_runtime/codex_cli.py,sha256=HFsA7Bd1vW9TWUZSsMANezVGbwTKxuuQZihxu9Hf9U8,2988
+coding_cli_runtime/contracts.py,sha256=teYMPDYCjL6HRwRBucJKetfZKlRnxpG82BrC1Y1OMNg,1764
+coding_cli_runtime/copilot_reasoning_baseline.json,sha256=hEIsqm03-D8T9Snn_FvbC2RD367fXGziyTK0Ajpxrmk,1649
+coding_cli_runtime/copilot_reasoning_logs.py,sha256=S2GD0zGgwVXAPe-DyJPKMR5j-EgOGlANnIt315mIWuo,2327
+coding_cli_runtime/failure_classification.py,sha256=fjGOjtQaBh6Y13gEIS7ystmadcrFKsLAN-fccBuerBs,6027
+coding_cli_runtime/json_io.py,sha256=1RseVXV-uPWRm_-pGIUTAvhALnMAEivCX46zvlVpri0,2665
+coding_cli_runtime/provider_controls.py,sha256=2rl1XxGYFODu6LRx3bLhptgN5M_T3klx2lqT_gAAkb0,3328
+coding_cli_runtime/provider_specs.py,sha256=n9cptkPVI5sIBVuJlqE8nuTU7SyJwG8rkUF2enM_KZc,26777
+coding_cli_runtime/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+coding_cli_runtime/reasoning.py,sha256=Ggyw1K9Ry4bytzeS-Jy8jmNHVJR891zH_4jRpYAswoA,3216
+coding_cli_runtime/redaction.py,sha256=PALvJoNt7r0E_Dd3N02tCV9RI_0nPfSgoVAeaWxeLAY,559
+coding_cli_runtime/schema_validation.py,sha256=WZvl2_LkAnuxNMmpS2-vjtLqny034G9xT7wh1BZ1gwM,3929
+coding_cli_runtime/session_execution.py,sha256=U9oRrz2ORuZJzUf4WK2BS6ubCSLOHe94izg6xmn6d3E,20714
+coding_cli_runtime/session_logs.py,sha256=B3B7MB9oe829cRyLyT4GyYySTXDjHOG3TG-WqbNfRzE,3750
+coding_cli_runtime/subprocess_runner.py,sha256=WqYMI6ALWFhEUySycfHXEtXuCX3m5x7s1n3Bd0TyPm0,11419
+coding_cli_runtime/schemas/normalized_run_result.v1.json,sha256=ogVKJbDFAd9dJklmp8SUkdR9L5EX1rdHGj5leJJHXGs,1110
+coding_cli_runtime/schemas/reasoning_metadata.v1.json,sha256=nQWhqp9-dlzJM18OARDUwAyaA-3-I8rETZYvkgTAnOc,467
+coding_cli_runtime-0.1.0.dist-info/licenses/LICENSE,sha256=hVIuaMVAgQkhTh44et0cpDtN3kGOZnKQ2bY1rJJw-MI,1078
+coding_cli_runtime-0.1.0.dist-info/METADATA,sha256=QdR4cw7AAY-6AhqVwjvwEHMbCXYoC3dS-ovuuot_FB0,6465
+coding_cli_runtime-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+coding_cli_runtime-0.1.0.dist-info/top_level.txt,sha256=-tzjii3Qf_GTevxT5M46tITBY02R-K8Ew04hJRHOB2Y,19
+coding_cli_runtime-0.1.0.dist-info/RECORD,,

coding_cli_runtime-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
+