lithe-cli 0.1.0__py3-none-any.whl

lithe_cli/__init__.py

@@ -0,0 +1,3 @@
+"""lithe-cli: the command-line interface for the lithe agent kernel."""
+
+__version__ = "0.1.0"

lithe_cli/__main__.py

@@ -0,0 +1,7 @@
+"""Support ``python -m lithe_cli`` alongside the console script."""
+import sys
+
+from .main import main
+
+if __name__ == "__main__":
+    sys.exit(main())

lithe_cli/agent.py

@@ -0,0 +1,123 @@
+"""Host wiring: tools, store, LLM config, and the event printer.
+
+Everything here maps lithe's host contract onto CLI defaults:
+
+- workspace — the sandboxed file root the agent reads/writes (``--workspace``,
+  default the current directory);
+- store — ``JsonlRunStore`` under ``~/.lithe/runs`` (``--store``), the
+  kernel's zero-database default;
+- tools — the workspace bundle (read/write/edit/list/search/glob +
+  apply_patch) and todos; ``download_file`` is opt-in (``--download``)
+  because it grants the agent network fetch access;
+- undo — the bundled tools register reverters, so ``lithe undo`` works with
+  zero configuration.
+"""
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from lithe import AgentContext, LLMConfig, ToolRegistry
+from lithe.bundles import (
+    AgentHost, JsonlRunStore, JsonTodoStore, Workspace, undo_run,
+)
+from lithe.bundles.download import register_download_tools
+from lithe.bundles.patch import register_apply_patch_tool
+from lithe.bundles.workspace import register_file_tools
+from lithe.bundles.todos import register_todo_tools
+
+from .config import Config
+
+SYSTEM_PROMPT = (
+    "你是运行在命令行里的助理，工作区是用户的当前目录。"
+    "用提供的文件工具完成任务（读写前先读、谨慎修改），"
+    "需要多步任务时先用 update_todos 列出计划，最后用简洁中文汇报结果。"
+)
+
+
+def build_registry(cfg: Config) -> ToolRegistry:
+    """Register the CLI's tool set against the configured workspace."""
+    reg = ToolRegistry()
+    ws_root = cfg.workspace_dir.resolve()
+    workspace_for = lambda ctx: Workspace(ws_root)  # noqa: E731
+    register_file_tools(reg, workspace_for)
+    register_apply_patch_tool(reg, workspace_for)
+    todo_path = cfg.store_dir / f"todos-{cfg.user_id}.json"
+    register_todo_tools(reg, lambda ctx: JsonTodoStore(todo_path))
+    if cfg.download:
+        register_download_tools(reg, workspace_for)
+    return reg
+
+
+def build_host(cfg: Config, reg: ToolRegistry) -> AgentHost:
+    """Build the AgentHost; the store lands under cfg.store_dir."""
+    store = JsonlRunStore(cfg.store_dir)
+    llm = LLMConfig(
+        model=cfg.model or "unused",
+        base_url=cfg.base_url or "unused",
+        api_key=cfg.api_key or "unused",
+        timeout=cfg.timeout,
+        attempts=cfg.attempts,
+        stream=cfg.stream,
+        context_window=cfg.context_window,
+        transport=cfg.transport,
+    )
+    return AgentHost(
+        reg, llm, store, max_steps=cfg.max_steps,
+        build_system_prompt=lambda ctx, mode, anchor: SYSTEM_PROMPT,
+    )
+
+
+def print_event(ev: dict, verbose: bool = False) -> None:
+    """Render one runtime event onto the terminal."""
+    t = ev.get("type")
+    if t == "assistant_delta":
+        print(ev.get("text", ""), end="", flush=True)
+    elif t == "assistant":
+        if ev.get("text"):
+            print(ev.get("text", ""))
+    elif t == "tool_call":
+        args = json.dumps(ev.get("args", {}), ensure_ascii=False)
+        print(f"  ⚒ {ev.get('name')} {args[:120]}")
+    elif t == "tool_result":
+        summary = (ev.get("summary") or "").replace("\n", " ")
+        mark = "✓" if ev.get("ok") else "✗"
+        print(f"  {mark} {summary[:160]}")
+    elif t == "error":
+        print(f"  ! {ev.get('message')}")
+    elif verbose and t == "usage":
+        print(f"  · tokens p{ev.get('prompt_tokens')}/c{ev.get('completion_tokens')}"
+              f" ctx={ev.get('context_tokens') or '?'}tk"
+              f" ({ev.get('context_percent')}%)")
+    elif verbose and t == "reasoning":
+        digest = (ev.get("summary") or "").replace("\n", " ")
+        if digest:
+            print(f"  ~ {digest[:120]}")
+
+
+async def execute(
+    cfg: Config, task: str, history: list[dict] | None = None,
+    run_id: str | None = None,
+) -> tuple[str, dict, Any]:
+    """Run one task end-to-end; returns (run_id, done_event, host)."""
+    import uuid
+
+    reg = build_registry(cfg)
+    host = build_host(cfg, reg)
+    rid = run_id or uuid.uuid4().hex[:12]
+    ctx = AgentContext(run_id=rid, user_id=cfg.user_id)
+    ev: dict = {}
+    async for ev in host.run(ctx, task, history=history):
+        print_event(ev, cfg.verbose)
+    if cfg.stream:
+        print()  # close the streaming line
+    return rid, ev, host
+
+
+async def undo(cfg: Config, run_id: str) -> int:
+    """Revert a run's mutations with the bundled tools' reverters."""
+    reg = build_registry(cfg)
+    host = build_host(cfg, reg)
+    report = await undo_run(host, run_id, cfg.user_id)
+    print(f"已撤销 {report.reverted} 个操作（run {run_id}）")
+    return 0

lithe_cli/config.py

@@ -0,0 +1,91 @@
+"""Configuration resolved from CLI flags and the environment.
+
+Endpoint credentials follow the same convention as lithe's ``live_host``
+example: ``LITHE_API_KEY`` / ``LITHE_BASE_URL`` / ``LITHE_MODEL`` — flags
+override env vars. There is no default endpoint on purpose: the CLI refuses
+to run rather than silently hitting some third-party URL.
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+ENV_API_KEY = "LITHE_API_KEY"
+ENV_BASE_URL = "LITHE_BASE_URL"
+ENV_MODEL = "LITHE_MODEL"
+ENV_HOME = "LITHE_HOME"
+
+DEFAULT_USER = "cli"
+
+
+@dataclass
+class Config:
+    """Everything one CLI invocation needs (endpoint, store, workspace)."""
+
+    api_key: str | None = None
+    base_url: str | None = None
+    model: str | None = None
+    store_dir: Path = field(default_factory=lambda: default_store_dir())
+    workspace_dir: Path = field(default_factory=lambda: Path.cwd())
+    user_id: str = DEFAULT_USER
+    stream: bool = False
+    max_steps: int = 35
+    context_window: int | None = None
+    timeout: float = 180.0
+    attempts: int = 2
+    download: bool = False
+    verbose: bool = False
+    # Wire protocol ("chat" | "responses") or a custom LLMTransport instance.
+    # Not exposed as a flag: the injection point for offline tests.
+    transport: Any = "chat"
+
+    @property
+    def has_endpoint(self) -> bool:
+        if not isinstance(self.transport, str):
+            return True  # scripted/custom transport needs no endpoint
+        return bool(self.api_key and self.base_url and self.model)
+
+
+def default_store_dir() -> Path:
+    home = Path(os.environ.get(ENV_HOME, "~/.lithe")).expanduser()
+    return home / "runs"
+
+
+def load_config(args: Any) -> Config:
+    """Merge parsed argparse flags over environment defaults."""
+    store_dir = Path(args.store).expanduser() if args.store else default_store_dir()
+    workspace_dir = (Path(args.workspace).expanduser()
+                     if args.workspace else Path.cwd())
+    # Capability flags only run/chat define; getattr keeps tools/runs/log/undo
+    # parsers minimal while sharing one Config shape.
+    g = lambda name, default: getattr(args, name, default)  # noqa: E731
+    return Config(
+        api_key=args.api_key or os.environ.get(ENV_API_KEY),
+        base_url=args.base_url or os.environ.get(ENV_BASE_URL),
+        model=args.model or os.environ.get(ENV_MODEL),
+        store_dir=store_dir,
+        workspace_dir=workspace_dir,
+        user_id=args.user or DEFAULT_USER,
+        stream=g("stream", False),
+        max_steps=g("max_steps", 35),
+        context_window=g("context_window", None),
+        timeout=g("timeout", 180.0),
+        attempts=g("attempts", 2),
+        download=g("download", False),
+        verbose=args.verbose,
+    )
+
+
+def require_endpoint(cfg: Config) -> None:
+    """Exit with a how-to message when no endpoint is configured."""
+    if cfg.has_endpoint:
+        return
+    raise SystemExit(
+        "缺少模型端点配置。请设置环境变量（或使用对应flag）：\n"
+        f"  export {ENV_API_KEY}=sk-...\n"
+        f"  export {ENV_BASE_URL}=https://your-endpoint/api/v1\n"
+        f"  export {ENV_MODEL}=your-model\n"
+        "本 CLI 不内置任何默认端点。"
+    )

lithe_cli/main.py

@@ -0,0 +1,201 @@
+"""The `lithe` command-line entry point.
+
+Subcommands:
+  run TASK     one-shot task against the configured endpoint
+  chat         interactive session (history carried across turns)
+  tools        list the tools this CLI registers
+  runs         list stored runs
+  log RUN_ID   show a stored run's messages and actions
+  undo RUN_ID  revert a run's file/todo mutations
+
+Endpoint config: LITHE_API_KEY / LITHE_BASE_URL / LITHE_MODEL (flags
+override). Storage lands in ~/.lithe/runs (LITHE_HOME to move it); the
+agent's workspace is the current directory unless --workspace says else.
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+from typing import Any
+
+from lithe import __version__ as lithe_version
+from lithe.bundles import JsonlRunStore
+
+from . import __version__
+from .agent import build_registry, execute, undo
+from .config import load_config, require_endpoint
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="lithe",
+        description="Command-line interface for the lithe agent kernel.",
+    )
+    p.add_argument("--version", action="version",
+                   version=f"lithe-cli {__version__} (lithe {lithe_version})")
+    sub = p.add_subparsers(dest="command")
+
+    def common(sp: argparse.ArgumentParser) -> None:
+        sp.add_argument("--api-key", help="endpoint API key (env LITHE_API_KEY)")
+        sp.add_argument("--base-url", help="endpoint base URL (env LITHE_BASE_URL)")
+        sp.add_argument("--model", help="model name (env LITHE_MODEL)")
+        sp.add_argument("--workspace", help="agent workspace dir (default: cwd)")
+        sp.add_argument("--store", help="run store dir (default: ~/.lithe/runs)")
+        sp.add_argument("--user", help="user id for the store (default: cli)")
+        sp.add_argument("--download", action="store_true",
+                        help="grant the agent download_file (network fetch)")
+        sp.add_argument("--verbose", "-v", action="store_true",
+                        help="show usage/reasoning events")
+
+    def runtime(sp: argparse.ArgumentParser) -> None:
+        common(sp)
+        sp.add_argument("--stream", action="store_true",
+                        help="stream tokens as they generate")
+        sp.add_argument("--max-steps", type=int, default=35,
+                        help="tool-loop step budget (default: 35)")
+        sp.add_argument("--context-window", type=int, default=None,
+                        help="model context window, for fullness gauges")
+        sp.add_argument("--timeout", type=float, default=180.0,
+                        help="per-call timeout in seconds")
+        sp.add_argument("--attempts", type=int, default=2,
+                        help="per-call retry attempts")
+
+    run_p = sub.add_parser("run", help="run one task")
+    runtime(run_p)
+    run_p.add_argument("task", help="the task for the agent")
+
+    chat_p = sub.add_parser("chat", help="interactive session")
+    runtime(chat_p)
+
+    tools_p = sub.add_parser("tools", help="list registered tools")
+    common(tools_p)
+
+    runs_p = sub.add_parser("runs", help="list stored runs")
+    common(runs_p)
+    runs_p.add_argument("--limit", type=int, default=30)
+
+    log_p = sub.add_parser("log", help="show a run's messages and actions")
+    common(log_p)
+    log_p.add_argument("run_id")
+
+    undo_p = sub.add_parser("undo", help="revert a run's mutations")
+    common(undo_p)
+    undo_p.add_argument("run_id")
+
+    return p
+
+
+def _cmd_tools(cfg: Any) -> int:
+    reg = build_registry(cfg)
+    for name in sorted(reg.names()):
+        spec = reg.spec(name)
+        cat = spec.category.name if spec.category is not None else "?"
+        desc = (spec.description or "").splitlines()[0]
+        print(f"{name:<16} {cat:<6} {desc}")
+    return 0
+
+
+def _cmd_runs(cfg: Any, limit: int) -> int:
+    store = JsonlRunStore(cfg.store_dir)
+    runs = store.list_runs(cfg.user_id, limit=limit)
+    if not runs:
+        print(f"（{cfg.store_dir} 下没有 run 记录）")
+        return 0
+    for r in reversed(runs):  # newest last, like a log
+        task = (r.task or "").replace("\n", " ")
+        print(f"{r.run_id:<14} {r.status:<12} steps={r.steps:<3} "
+              f"cost={r.cost:<8.4f} {task[:60]}")
+    return 0
+
+
+def _cmd_log(cfg: Any, run_id: str) -> int:
+    store = JsonlRunStore(cfg.store_dir)
+    run = store.get_run(run_id, cfg.user_id)
+    if run is None:
+        print(f"找不到 run {run_id}（user={cfg.user_id}）")
+        return 1
+    print(f"run {run.run_id}  status={run.status}  steps={run.steps}  "
+          f"model={run.model}")
+    print(f"task: {run.task}")
+    if run.final:
+        print(f"final: {run.final[:500]}")
+    print("-- messages --")
+    for row in store.messages_for_run(run_id, cfg.user_id):
+        role = row.get("role", "?")
+        content = row.get("content") or ""
+        calls = row.get("tool_calls")
+        extra = f" tool_calls={len(calls)}" if calls else ""
+        print(f"[{role}] {str(content)[:300]}{extra}")
+    print("-- actions --")
+    actions = store.list_actions(run_id, cfg.user_id)
+    if not actions:
+        print("（无）")
+    for a in actions:
+        print(f"#{a.id} {a.kind:<14} {a.target:<40} {a.status}")
+    return 0
+
+
+def _cmd_run(cfg: Any, task: str) -> int:
+    require_endpoint(cfg)
+    _, done, _ = asyncio.run(execute(cfg, task))
+    return 0 if done.get("status") == "done" else 1
+
+
+def _cmd_chat(cfg: Any) -> int:
+    require_endpoint(cfg)
+    return _chat_loop(cfg)
+
+
+def _chat_loop(cfg: Any) -> int:
+    store = JsonlRunStore(cfg.store_dir)
+    run_ids: list[str] = []
+    print(f"lithe {__version__} — /exit 退出，输入任务开始。")
+    while True:
+        try:
+            line = input("lithe> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            break
+        if not line:
+            continue
+        if line in ("/exit", "/quit", "exit", "quit"):
+            break
+        history = (store.messages_for_runs(run_ids, cfg.user_id)
+                   if run_ids else None)
+        try:
+            # One asyncio.run per turn: each run is self-contained, and the
+            # blocking input() stays out of async context.
+            rid, done, _ = asyncio.run(execute(cfg, line, history=history))
+        except KeyboardInterrupt:
+            print("\n（已中断本轮；输入继续）")
+            continue
+        run_ids.append(rid)
+        if done.get("status") != "done":
+            print(f"（本轮状态：{done.get('status')}）")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    if args.command is None:
+        build_parser().print_help()
+        return 2
+    cfg = load_config(args)
+    if args.command == "run":
+        return _cmd_run(cfg, args.task)
+    if args.command == "chat":
+        return _cmd_chat(cfg)
+    if args.command == "tools":
+        return _cmd_tools(cfg)
+    if args.command == "runs":
+        return _cmd_runs(cfg, args.limit)
+    if args.command == "log":
+        return _cmd_log(cfg, args.run_id)
+    if args.command == "undo":
+        return asyncio.run(undo(cfg, args.run_id))
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

lithe_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: lithe-cli
+Version: 0.1.0
+Summary: Command-line interface for the lithe agent kernel: chat, one-shot runs, undo, and run inspection.
+License: MIT License
+        
+        Copyright (c) 2026 betaloop contributors
+        
+        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.
+        
+Keywords: agent,llm,react,cli,tool-calling
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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 :: Application Frameworks
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lithe>=0.9.5
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Dynamic: license-file
+
+# lithe-cli
+
+[![PyPI](https://img.shields.io/pypi/v/lithe-cli.svg)](https://pypi.org/project/lithe-cli/)
+[![Python](https://img.shields.io/pypi/pyversions/lithe-cli.svg)](https://pypi.org/project/lithe-cli/)
+[![License: MIT](https://img.shields.io/pypi/l/lithe-cli.svg)](https://pypi.org/project/lithe-cli/)
+
+**lithe-cli** is the command-line interface for
+[lithe](https://pypi.org/project/lithe/) — the storage-free ReAct agent
+kernel. Installing it pulls in `lithe` automatically and gives you a `lithe`
+command: chat with an agent that reads and writes files in your workspace,
+run one-shot tasks, inspect stored runs, and undo a run's mutations.
+
+```bash
+pip install lithe-cli
+```
+
+## Configure
+
+There is no default endpoint — the CLI refuses to run rather than silently
+hitting some third-party URL. Point it at any OpenAI-compatible endpoint:
+
+```bash
+export LITHE_API_KEY=sk-...
+export LITHE_BASE_URL=https://your-endpoint/api/v1
+export LITHE_MODEL=your-model
+```
+
+Flags (`--api-key`, `--base-url`, `--model`) override the environment.
+`LITHE_HOME` (default `~/.lithe`) locates the run store; the agent's
+workspace defaults to the current directory (`--workspace` to change).
+
+## Use
+
+### One-shot task
+
+```bash
+$ cd my-project
+$ lithe run "总结 README.md 的要点，存到 SUMMARY.md"
+  ⚒ read_file {"path": "README.md"}
+  ✓ 已读取 README.md（120 行）
+  ⚒ write_file {"path": "SUMMARY.md", "content": "..."}
+  ✓ 写入 SUMMARY.md
+已把要点写入 SUMMARY.md。
+```
+
+`--stream` streams tokens as they generate; `-v` adds per-call
+usage/context gauges; `--max-steps` caps the tool loop;
+`--context-window` enables fullness gauges.
+
+### Interactive chat
+
+```bash
+$ lithe chat
+lithe 0.1.0 — /exit 退出，输入任务开始。
+lithe> 把 a.txt 改成三行待办清单
+  ⚒ write_file {"path": "a.txt", ...}
+  ✓ 写入 a.txt
+已完成。
+lithe> /exit
+```
+
+History carries across turns within a session (each turn is its own run in
+the store, replayed as context for the next).
+
+### Undo a run
+
+The bundled file and todo tools register reverters, so undo works with zero
+configuration:
+
+```bash
+$ lithe runs                     # find the run
+abc123def456   done        steps=3  ...
+$ lithe undo abc123def456
+已撤销 2 个操作（run abc123def456）
+```
+
+A file the run created is deleted; a file it overwrote is restored.
+
+### Inspect
+
+```bash
+$ lithe runs                     # stored runs (newest last)
+$ lithe log abc123def456         # messages + actions of one run
+```
+
+### Tools
+
+```bash
+$ lithe tools                    # what the agent can do
+apply_patch      WRITE  以行级 patch 一次修改多个文件...
+edit_file        WRITE  局部替换文件中的文本...
+read_file        READ   读取文件内容...
+...
+```
+
+The default tool set is the workspace bundle (`read_file` / `write_file` /
+`edit_file` / `list_files` / `search_files` / `glob_files` /
+`apply_patch`) plus todos (`update_todos` / `list_todos`).
+`--download` additionally grants `download_file` — the SSRF-guarded,
+size-capped network fetch — for runs and chats.
+
+## Where things land
+
+| Path | Contents |
+| --- | --- |
+| current dir (or `--workspace`) | the agent's sandboxed workspace — every tool path resolves strictly inside it |
+| `~/.lithe/runs` (or `--store`) | JSONL run store: messages, actions, undo records |
+| `~/.lithe/runs/todos-<user>.json` | the agent's task list |
+
+## Design notes
+
+- The CLI is a thin host: it supplies tools, a system prompt, and the
+  kernel's `JsonlRunStore`; everything else (ReAct loop, streaming, budgets,
+  replay, undo engine) is reused from lithe.
+- End-to-end behavior is tested offline against a scripted transport — no
+  test spends tokens.
+- `python -m lithe_cli` works alongside the `lithe` console script.
+
+## License
+
+MIT

lithe_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+lithe_cli/__init__.py,sha256=q1xPbNFxhW5ddYQe-uaaDxqRlBmmyAr0I3hoWZ2T9Nc,95
+lithe_cli/__main__.py,sha256=i_VzFEuvHPLVcXcqC1UBy_7nfk0H86nyJLvTB3yF_0w,152
+lithe_cli/agent.py,sha256=AXWPDbRzNqm-AkgaAXLrkxgqCkd6BUlMmLIyR1u0AJM,4615
+lithe_cli/config.py,sha256=KlhI2HRtqGcCiNGPbOFVUeaxrginz9IQPEz7tduhMMs,3275
+lithe_cli/main.py,sha256=s7TtMHyQ40U7HyJzePwREPGYJTEVr5w3imwSQ6NS_No,7226
+lithe_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lithe_cli-0.1.0.dist-info/licenses/LICENSE,sha256=MLG-37iuP9mqLJOtdaLDjt-_hTW-rKE4CLQaCz_215c,1078
+lithe_cli-0.1.0.dist-info/METADATA,sha256=cbw3SaEaX3wc07viP8aXog6ig2KE5h563tTb-41GlKU,6031
+lithe_cli-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+lithe_cli-0.1.0.dist-info/entry_points.txt,sha256=HzDcc8FMDzt1FbPppIi21MgGAy2f8tJqnpmFiiQzDGw,78
+lithe_cli-0.1.0.dist-info/top_level.txt,sha256=Zep9WGTghjOTFQJvKKLf3w7zy1E_ZUgmUbXb8gPqOD8,10
+lithe_cli-0.1.0.dist-info/RECORD,,

lithe_cli-0.1.0.dist-info/WHEEL

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

lithe_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+lithe = lithe_cli.main:main
+lithe-cli = lithe_cli.main:main

lithe_cli-0.1.0.dist-info/licenses/LICENSE

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

lithe_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lithe_cli