callai-cli 0.9.0__py3-none-any.whl

callai/runner.py

@@ -0,0 +1,233 @@
+"""Runs a harness command line as a subprocess (DESIGN.md §4, §8).
+
+The harness gets its own process group, so a timeout or Ctrl-C reaches the whole tree it
+spawned, and an empty stdin, because the prompt always travels in argv.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import io
+import os
+import shutil
+import signal
+import subprocess
+import sys
+import threading
+import time
+from collections.abc import Callable, Mapping, Sequence
+from typing import IO
+
+from .adapters.base import strip_ansi
+from .errors import HarnessNotFound, HarnessTimeout, Interrupted, UsageError
+from .result import Completed
+
+_POSIX = os.name == "posix"
+_GRACE_SECONDS = 3
+# Harnesses running right now, so a fan-out's Ctrl-C can stop the ones in other threads (stop_all).
+_LIVE: set[subprocess.Popen] = set()
+_LIVE_LOCK = threading.Lock()
+
+
+def resolve_binary(binary: str, harness_name: str | None = None, install_url: str | None = None) -> str:
+    """Find a harness executable on PATH.
+
+    Args:
+        binary: Executable name, e.g. ``"claude"``.
+        harness_name: The ``--name`` (harness) that needs it (for the error message).
+        install_url: Install docs (for the error message).
+
+    Returns:
+        The absolute path of the executable.
+
+    Raises:
+        HarnessNotFound: If it is not on PATH.
+    """
+    path = shutil.which(binary)
+    if path is None:
+        raise HarnessNotFound(binary, harness_name=harness_name, install_url=install_url)
+    return path
+
+
+def harness_version(path: str, timeout: float = 10) -> str | None:
+    """Ask a harness binary for its version (``BINARY --version``).
+
+    The version is the first non-empty line of stdout (else stderr), whatever the exit code:
+    hermes 0.19.0 prints its version and exits 1.
+
+    Args:
+        path: The executable.
+        timeout: Seconds to wait for it.
+
+    Returns:
+        The version line, or ``None`` if it printed nothing, failed to start or timed out.
+    """
+    try:
+        proc = subprocess.run(
+            [path, "--version"],
+            stdin=subprocess.DEVNULL,
+            capture_output=True,
+            timeout=timeout,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    for raw in (proc.stdout, proc.stderr):
+        for line in raw.decode("utf-8", errors="replace").splitlines():
+            if line.strip():
+                return strip_ansi(line).strip()
+    return None
+
+
+def _pump(stream: IO[str], sink: list[str], tee: IO[str] | None, on_line: Callable[[str], None] | None = None) -> None:
+    """Drain a pipe line by line into ``sink``, optionally copying each line to ``tee`` or ``on_line``.
+
+    Args:
+        stream: The harness's stdout or stderr pipe.
+        sink: Collected lines.
+        tee: Where to echo lines live, or ``None``.
+        on_line: Called with each line as it arrives, or ``None``.
+    """
+    for line in iter(stream.readline, ""):
+        sink.append(line)
+        if tee is not None:
+            tee.write(line)
+            tee.flush()
+        if on_line is not None:
+            on_line(line)
+    stream.close()
+
+
+def _signal_group(proc: subprocess.Popen, sig: int) -> None:
+    """Send ``sig`` to the harness's whole process group; a group that already exited is fine.
+
+    Args:
+        proc: The harness process (leader of its own group).
+        sig: Signal to send (POSIX); Windows always kills the process.
+    """
+    if _POSIX:
+        with contextlib.suppress(ProcessLookupError):
+            os.killpg(proc.pid, sig)
+    else:  # pragma: no cover - Windows
+        proc.kill()
+
+
+def _kill_group(proc: subprocess.Popen) -> None:
+    """SIGTERM the harness's process group, then SIGKILL whatever is left after a grace period.
+
+    Args:
+        proc: The harness process (leader of its own group).
+    """
+    _signal_group(proc, signal.SIGTERM)
+    with contextlib.suppress(subprocess.TimeoutExpired):  # harness ignored SIGTERM: SIGKILL below
+        proc.wait(timeout=_GRACE_SECONDS)
+    if _POSIX:
+        _signal_group(proc, signal.SIGKILL)  # also reaps grandchildren that outlived the leader
+    proc.wait()
+
+
+def stop_all() -> None:
+    """Stop every harness still running (Ctrl-C during a fan-out): SIGINT, then kill after a grace period.
+
+    Each harness's own :func:`run` call then returns normally with the exit status it got.
+    """
+    with _LIVE_LOCK:
+        procs = list(_LIVE)
+    for proc in procs:
+        _signal_group(proc, signal.SIGINT)
+    deadline = time.monotonic() + _GRACE_SECONDS
+    for proc in procs:
+        with contextlib.suppress(subprocess.TimeoutExpired):  # ignored SIGINT: killed below
+            proc.wait(timeout=max(0.0, deadline - time.monotonic()))
+    for proc in procs:
+        if proc.poll() is None:
+            _kill_group(proc)
+
+
+def run(
+    argv: Sequence[str],
+    *,
+    cwd: str | None = None,
+    timeout: float | None = None,
+    verbose: bool = False,
+    harness_name: str | None = None,
+    install_url: str | None = None,
+    env: Mapping[str, str] | None = None,
+    on_stdout_line: Callable[[str], None] | None = None,
+) -> Completed:
+    """Run a harness and capture its output.
+
+    Args:
+        argv: Command line; ``argv[0]`` is the bare binary name, resolved on PATH.
+        cwd: Working directory, or ``None`` for the current one.
+        timeout: Seconds before the process group is killed, or ``None`` for no limit.
+        verbose: Copy the harness's stderr to ours as it arrives (it is still captured).
+        harness_name: The ``--name`` (harness) being run (for error messages).
+        install_url: Install docs for the binary (for error messages).
+        env: Variables to set for the harness on top of callai's environment (an adapter's ``build_env``).
+        on_stdout_line: Called with each stdout line as it arrives (``-o stream-json``), from a reader
+            thread; stdout is still captured in full.
+
+    Returns:
+        The captured outcome; ``argv`` is reported exactly as given.
+
+    Raises:
+        UsageError: If ``cwd`` is not a directory.
+        HarnessTimeout: If ``timeout`` elapsed (the process group has been killed).
+        Interrupted: On Ctrl-C (SIGINT was forwarded to the process group).
+    """
+    argv = list(argv)
+    if cwd is not None and not os.path.isdir(cwd):
+        raise UsageError(f"--cwd {cwd!r} is not a directory")
+    executable = resolve_binary(argv[0], harness_name=harness_name, install_url=install_url)
+    group_kw = {"start_new_session": True} if _POSIX else {"creationflags": subprocess.CREATE_NEW_PROCESS_GROUP}
+
+    start = time.monotonic()
+    proc = subprocess.Popen(
+        argv,
+        executable=executable,  # keeps argv[0] as the bare name the harness expects
+        cwd=cwd,
+        env={**os.environ, **env} if env else None,
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        **group_kw,
+    )
+    out: list[str] = []
+    err: list[str] = []
+    # Decode ourselves with newline="": text=True would translate \r\n to \n, and the output must be
+    # the harness's own (hermes marks display lines with \r\n; -o raw must be byte-faithful).
+    stdout, stderr = (
+        io.TextIOWrapper(s, encoding="utf-8", errors="replace", newline="") for s in (proc.stdout, proc.stderr)
+    )
+    pumps = [
+        threading.Thread(target=_pump, args=(stdout, out, None, on_stdout_line), daemon=True),
+        threading.Thread(target=_pump, args=(stderr, err, sys.stderr if verbose else None), daemon=True),
+    ]
+    for t in pumps:
+        t.start()
+    with _LIVE_LOCK:
+        _LIVE.add(proc)
+    try:
+        proc.wait(timeout=timeout)
+    except subprocess.TimeoutExpired:
+        _kill_group(proc)
+        raise HarnessTimeout(argv[0], timeout) from None
+    except KeyboardInterrupt:
+        _signal_group(proc, signal.SIGINT)
+        with contextlib.suppress(subprocess.TimeoutExpired):  # harness ignored SIGINT: killed below
+            proc.wait(timeout=_GRACE_SECONDS)
+        _kill_group(proc)
+        raise Interrupted() from None
+    finally:
+        with _LIVE_LOCK:
+            _LIVE.discard(proc)
+    for t in pumps:
+        t.join()
+    return Completed(
+        argv=argv,
+        exit_code=proc.returncode,
+        stdout="".join(out),
+        stderr="".join(err),
+        duration_ms=int((time.monotonic() - start) * 1000),
+    )

callai_cli-0.9.0.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.4
+Name: callai-cli
+Version: 0.9.0
+Summary: One CLI to run a prompt non-interactively through any coding-agent harness (claude-code, codex, opencode, pi, hermes, grok).
+Author-email: Sugato Ray <sugatoray.dev@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/sugatoray/callai
+Project-URL: Issues, https://github.com/sugatoray/callai/issues
+Project-URL: Documentation, https://github.com/sugatoray/callai/blob/master/docs/callai/README.md
+Project-URL: Source, https://github.com/sugatoray/callai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Utilities
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0; extra == "test"
+Provides-Extra: dev
+Requires-Dist: ruff>=0.6.0; extra == "dev"
+Requires-Dist: interrogate>=1.7.0; extra == "dev"
+Dynamic: license-file
+
+![callai: one command line for every coding-agent harness](https://raw.githubusercontent.com/sugatoray/callai/master/docs/assets/images/banner_2x.png)
+
+# callai
+
+`callai` is one command line for every coding-agent harness. It runs a single prompt non-interactively, like `claude -p`, through the harness you pick and prints the result:
+
+```bash
+callai -n {claude-code,codex,opencode,pi,hermes,grok} -p "PROMPT" [-m MODEL]
+```
+
+**User documentation:** [`docs/callai/`](docs/callai/README.md) has a tutorial, how-to guides, concepts and a full reference, with `llms.txt` for AI agents.
+
+**Status:** Python implementation, version 0.9.0 (Red/Green TDD). All six harnesses work: `claude-code`, `codex`, `opencode`, `pi`, `grok` and `hermes`. The shared test suite is in [`conformance/`](conformance/README.md). PyPI distribution name: `callai-cli` (command `callai`). See [`SCOPE.md`](SCOPE.md) for scope, language/distribution decisions and the roadmap. See [`docs/DESIGN.md`](docs/DESIGN.md) for the CLI surface, adapter architecture, output schema and open decisions, and [`docs/.scrolls/PLAN.md`](docs/.scrolls/PLAN.md) for the build order.
+
+## Usage
+
+```bash
+callai -n claude-code -p "Summarise README.md"            # prints the answer
+callai -n codex -p "Fix the failing test" --permission auto
+git diff | callai -n grok -p "Review this diff" -o json   # piped stdin is appended to the prompt
+callai -n codex -p "Fix the test" -o stream-json          # JSON-lines events (tool calls, text) as they happen
+callai -n pi -p "hello" -m stub/stub-model --dry-run      # show the harness command, don't run it
+callai -n opencode -p "hello" -- --agent build            # args after -- go to the harness unchanged
+callai -n codex -p "hello" -m fast                        # a model alias from the config file
+callai -n claude-code -p "and the tests?" --resume SESSION_ID   # continue a session (-o json reports session_id)
+callai -n pi -p "and now?" --continue                     # continue the harness's most recent session
+callai -n codex/claude-code/grok -p "Explain main.py"     # several harnesses at the same time ('/' = parallel)
+callai -n codex,pi -p "Explain main.py"                   # one after another (',' = sequential)
+callai -n all -p "Explain main.py" -o json                # every installed harness, at the same time
+callai --list-harnesses                                   # which harnesses are installed, and their versions
+```
+
+Harnesses: `claude-code`, `codex`, `opencode`, `pi`, `grok`, `hermes`. `-o text|json|stream-json|raw`
+(json is one normalised object: `harness_name`, `text`, `is_error`, `session_id`, `usage`, `cost_usd`, `model`, ...;
+stream-json is one event per line, `start`, then `text`/`tool_use`/`tool_result` as they happen, then `result`,
+the json object; hermes has no event stream, so it gives only `start` and `result`; see DESIGN §5).
+With several harnesses, each answer is printed under a `== name ==` header (`-o json`: `{"results": [...]}`;
+stream-json events carry `harness_name`). One failure doesn't stop the others; the exit code is the first
+failure's. `-n all` skips harnesses that can't honour the options, with a note. Parallel runs share the
+working directory, so prefer `,` for tasks that edit files. See DESIGN §3 "Fan-out".
+Exit codes: the harness's own; 1 if it reported an error but exited 0; 2 usage error; 124 timeout;
+127 harness not installed; 130 interrupted.
+
+Stdin: with `-p TEXT`, piped stdin is optional. If it's a pipe that stays open with nothing on it
+(common when an agent or script runs callai), callai waits 3 seconds (`CALLAI_STDIN_WAIT`), warns and
+runs with the prompt alone, like `claude -p`. Use `< /dev/null` to skip the wait. With `-p -` or no
+`-p`, stdin is the prompt, so callai waits for it to close.
+
+### Defaults: environment and config file
+
+Each option comes from the first of: command-line flag, `CALLAI_*` environment variable, config
+file, built-in default.
+
+| setting | flag | environment | config file |
+|---|---|---|---|
+| harness | `-n/--name` | `CALLAI_HARNESS_NAME` | `default_harness` |
+| model | `-m/--model` | `CALLAI_MODEL` | `[harnesses.<name>] model`, then top-level `model` |
+| timeout | `--timeout` | `CALLAI_TIMEOUT` | `timeout` |
+| stdin wait | | `CALLAI_STDIN_WAIT` | |
+
+The config file is `~/.config/callai/config.toml` (or `$XDG_CONFIG_HOME/callai/config.toml`, or the
+path in `CALLAI_CONFIG`). It is optional; unknown keys are an error (exit 2), so a typo never
+silently does nothing.
+
+```toml
+default_harness = "claude-code"
+model = "fast"                       # default model for every harness (here an alias)
+timeout = 600
+
+[harnesses.codex]
+binary = "~/bin/codex"               # run this instead of `codex` from PATH
+model = "gpt-5-codex"                # codex's default; beats the top-level model
+extra_args = ["--skip-git-repo-check"]   # passed before anything after --
+
+[aliases]                            # -m fast / -m smart, resolved per harness
+fast  = { claude-code = "haiku", codex = "gpt-5-codex-mini", opencode = "anthropic/claude-haiku-4-5" }
+smart = { claude-code = "opus",  codex = "gpt-5-codex" }
+```
+
+Any model that isn't an alias goes to the harness unchanged. An alias with no entry for the chosen
+harness is an error (`model alias 'smart' has no entry for pi`) rather than passing `smart` on.
+
+`callai --list-harnesses` shows each harness's binary (including a configured one), where it is on
+PATH and its `--version`, or where to install it; `-o json` gives the same as JSON.
+
+`--permission default|read-only|auto|bypass` is translated per harness; a level a harness can't honour
+is refused (exit 2) rather than run with more access. What each level really allows was checked with
+scripted tool calls; see [DESIGN.md §7](docs/DESIGN.md#7-permissions-and-safety):
+
+| level | claude-code | codex | opencode | pi | grok | hermes |
+|---|---|---|---|---|---|---|
+| `read-only` | plan mode: no writes, no shell | read-only sandbox | refused | read tools only | read tools only | refused |
+| `auto` | edits inside the workspace | writes inside the workspace (sandboxed shell) | refused | file writes/edits, no shell | file writes/edits, no shell | file writes/edits, no shell |
+| `bypass` | everything | everything | everything | everything | everything | everything |
+
+With `default`, opencode, pi and hermes already write files and run shell commands without asking;
+claude-code, codex and grok don't. `bypass` prints a warning on stderr. As root, claude refuses
+`bypass` unless `IS_SANDBOX=1` is set (callai never sets it).
+
+> [!CAUTION]
+> **grok `auto` and `bypass` can write outside the working directory.** callai's `auto` for grok
+> allows only file writes and edits (no shell), but grok will write them **anywhere** the user
+> running it can write, not just in the working directory. Unlike codex's `auto`, which is sandboxed
+> to the workspace. callai does not add a sandbox for you: grok's sandbox needs
+> [bubblewrap](https://github.com/containers/bubblewrap) on Linux, and grok refuses to start without
+> it, so adding it would break `auto` on machines that don't have it.
+>
+> To confine grok's writes to the working directory, opt in with grok's `workspace` sandbox:
+>
+> ```bash
+> sudo apt install -y bubblewrap                                      # Linux only, once
+> callai -n grok -p "Fix the failing test" --permission auto -- --sandbox workspace
+> callai -n grok -p "Refactor utils.py" --permission bypass -C ~/proj -- --sandbox workspace
+> GROK_SANDBOX=workspace callai -n grok -p "Fix the failing test" --permission auto   # same, via grok's env var
+> ```
+>
+> Writes inside the working directory (`-C`, or the current directory) still work; writes elsewhere
+> fail with "Permission denied", and so do shell commands that write outside it under `bypass`.
+> Without bubblewrap, grok exits 1 with "bwrap exec failed ... Install bubblewrap" instead of
+> running unconfined. grok's other profiles (`read-only`, `strict`) behave the same way for the
+> working directory: they also allow writes inside it, so `-- --sandbox read-only` does **not** make
+> grok read-only. Use callai's `--permission read-only` for that (no write or shell tools are offered).
+
+A few prompts are refused because the harness would not send them as text: pi reads a prompt starting
+with `@` as a file, and grok runs one starting with `/` as a slash command.
+
+## From Python
+
+```python
+import callai
+
+result = callai.run("codex", "Fix the failing test", permission="auto", timeout=600)
+print(result.text, result.is_error, result.session_id, result.usage)
+
+# Continue that session, and watch tool calls as they happen
+callai.run("codex", "Now add a test for it", resume=result.session_id, on_event=print)
+```
+
+`run()` takes the CLI's options as keyword arguments (`model`, `cwd`, `timeout`, `permission`,
+`system_prompt`, `extra_args`, `resume`, `continue_session`, `binary`, `on_event`) and returns the same
+result as `-o json`. It ignores `CALLAI_*` variables and the config file: pass what you want. A harness
+that fails gives a result with `is_error=True`; `callai.CallaiError` subclasses (`UsageError`,
+`HarnessNotFound`, `HarnessTimeout`, `Interrupted`) mean the run couldn't start or finish.
+
+## Development
+
+```bash
+make install.harnesses             # all harness CLIs at their verified versions (or make install.<tool>)
+make docs.html                     # the docs as one HTML page with tabs and a theme toggle -> build/docs.html
+uv sync --extra test --extra dev   # Python >= 3.11, no runtime dependencies; develops on the pinned 3.11 (.python-version)
+make test                          # tests + coverage gate (95%) on the pinned Python (same as: uv run pytest)
+make test.matrix                   # the same on every supported Python, 3.11-3.14 (or PYTHON_VERSIONS=3.13)
+make pkg.build                     # sdist + wheel -> dist/ (uv build)
+make pkg.publish                   # build, then upload to PyPI (uv publish; set UV_PUBLISH_TOKEN)
+make pkg.install.e                 # editable install of this checkout into .venv
+make pkg.install.local             # install callai-cli from the built dist/
+make pkg.install.pypi              # install callai-cli from PyPI (PKG_VERSION=0.9.0 to pin)
+uv run ruff check . && uv run ruff format --check .
+uv run interrogate src             # docstring coverage (100%)
+uv run callai --version
+CALLAI_LIVE=claude-code uv run pytest -m live   # live smoke test: real harness, real model (or CALLAI_LIVE=all)
+```
+
+Development follows Red/Green TDD. Shared behaviour cases live in [`conformance/`](conformance/README.md).
+
+## Layout
+
+- `docs/` — the user documentation in [`docs/callai/`](docs/callai/README.md), [`DESIGN.md`](docs/DESIGN.md), plus the project's own [`docs/.scrolls/`](docs/.scrolls/STARTER.md) working-memory system.
+- `.trash/` — scratch/disposable files local to this repository (git-ignored).
+- `conformance/` — language-agnostic test cases (argv, parse, CLI) shared by every implementation, plus `tools/`: a local stub model (with scripted tool calls) and the permission probe.
+- `src/` — `src/callai/` (CLI, runner, one adapter per harness in `adapters/`) and `src/tests/`.
+- [`CHANGELOG.md`](CHANGELOG.md) — notable changes to callai, [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) style with [SemVer](https://semver.org/) versions.
+
+See [SCROLLS.md](SCROLLS.md) for how the memory system works.
+
+## License
+
+[Apache-2.0](LICENSE).

callai_cli-0.9.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+callai/__init__.py,sha256=0LuTDPxYR3BgpX3BYvRs16UnojqGBRIUWgzRh-bG304,1028
+callai/__main__.py,sha256=xfIr6ypBYmw-uuC00AVHQSTxAOOMAbubZJlypbJtzp0,158
+callai/api.py,sha256=z8tMdrVy6Iv5a9mPhmLN6In9hn61zaV6m9pcBQpjDaM,5081
+callai/cli.py,sha256=ZZJJhanGGlMQXIIlp_N2nApL23AuriZ_2uCYcre8O0M,25750
+callai/config.py,sha256=duKGhbVaKArU_5go8BJXz61Ldu0b1ZXWiIwyidRpRzI,9153
+callai/errors.py,sha256=QG-0e3bRQ6K4lJlz63d2jGVzZBPocjM4g72Xf7KQe3c,1932
+callai/fanout.py,sha256=HHjp_tYxZO0AHF4u0kKsIhOznajDWQcijxkJIFSVHM0,5500
+callai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+callai/request.py,sha256=1vHwcze5i2K7bk3rqu1unDckNiEBz3djzppdnB_oy6Q,3328
+callai/result.py,sha256=YHZoZI16fvMf4Piuiv3Dha5d75jOF48lN45xsV-li2I,3127
+callai/runner.py,sha256=nfru9A7mOuPFOsSdvpxQbzr5QhDfzjo_hIdaoirNKJ8,8356
+callai/adapters/__init__.py,sha256=vkjHzZE2RS9FyaGvAdw9Xj_AZkJDEtehYso2jSeSs88,2322
+callai/adapters/base.py,sha256=BKUgVy3kFFCBVHD7ABtJjF7-veOt7fOWVL0-ykJjQyw,5964
+callai/adapters/claude_code.py,sha256=77xfizhpCeDQADgRi6YHlHSo1dBINgUsKmUL4mEx7YY,6918
+callai/adapters/codex.py,sha256=I_KCbWxpnQWoeTElJeNMx3gN03zRmoHGmLuVvTWVsM4,6658
+callai/adapters/grok.py,sha256=F9jPw07WfxEm70jw8PCZ-PHthvVC0OFTnLorVlhD9eY,8646
+callai/adapters/hermes.py,sha256=ZPHF3sYZwhlvqHYtjvRFFxAi05KwCdG8_Ze7O_8dTdk,4538
+callai/adapters/opencode.py,sha256=crvAlT9yhbKbQNVihqx9e1jsex9kFuiI-Yp490ZULcY,7546
+callai/adapters/pi.py,sha256=W8acocSBL_p8LEU22-9DqE4WL0xSZpquyL-lfUW2oZA,6993
+callai_cli-0.9.0.dist-info/licenses/LICENSE,sha256=ErA_fMqfhQnPFERDycWnCvEzyXkKIamFv10AJbPWI9s,11340
+callai_cli-0.9.0.dist-info/METADATA,sha256=r0uutgBEpx1EIPywO_fgqjPnoY5r8m7nYtzJv-j6Y2k,13280
+callai_cli-0.9.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+callai_cli-0.9.0.dist-info/entry_points.txt,sha256=21U8Nb-AyWuGAViIdTFZMT601gx3dYspErVfSfYzoGk,43
+callai_cli-0.9.0.dist-info/top_level.txt,sha256=JyuQQSsmwPtkHNaLf1FOKiNWo9TvuvzEDx4AWmODigk,7
+callai_cli-0.9.0.dist-info/RECORD,,

callai_cli-0.9.0.dist-info/WHEEL

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

callai_cli-0.9.0.dist-info/entry_points.txt

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