tars-cli 0.1.0__py3-none-any.whl

tars_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

tars_cli/__main__.py

@@ -0,0 +1,4 @@
+from tars_cli.app import app
+
+if __name__ == "__main__":
+    app()

tars_cli/app.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from tars_cli import __version__
+
+console = Console()
+
+app = typer.Typer(
+    name="tars",
+    help=(
+        "tars CLI - 评估平台命令行工具\n\n"
+        "🚀 快速上手:\n"
+        "  路线 A（智能生成）: tars auth login → tars plugin import → tars dataset generate → tars eval run\n"
+        "  路线 B（手动上传）: tars auth login → tars plugin import → tars template download → tars dataset upload → tars eval run\n\n"
+        "运行 tars quickstart 查看完整示例"
+    ),
+)
+
+auth_app = typer.Typer(
+    name="auth",
+    help="认证管理\n\n典型流程: tars auth login --server <url>",
+    no_args_is_help=True,
+)
+plugin_app = typer.Typer(
+    name="plugin",
+    help="Plugin 管理\n\n典型流程: tars plugin import <git_url> → tars plugin export-report <plugin_id>",
+    no_args_is_help=True,
+)
+dataset_app = typer.Typer(
+    name="dataset",
+    help="数据集管理\n\n典型流程: tars dataset generate <plugin_id> → tars dataset publish <version_id>",
+    no_args_is_help=True,
+)
+eval_app = typer.Typer(
+    name="eval",
+    help="评估管理\n\n典型流程: tars eval run <plugin_id> → tars eval status <task_id>",
+    no_args_is_help=True,
+)
+template_app = typer.Typer(
+    name="template",
+    help="模板管理\n\n典型流程: tars template download plan → tars template download testcase-single",
+    no_args_is_help=True,
+)
+
+app.add_typer(auth_app, name="auth")
+app.add_typer(plugin_app, name="plugin")
+app.add_typer(dataset_app, name="dataset")
+app.add_typer(eval_app, name="eval")
+app.add_typer(template_app, name="template")
+
+# Global options stored in context
+_output_format: str = "table"
+_quiet: bool = False
+_verbose: bool = False
+_server: Optional[str] = None
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    output: str = typer.Option("table", "--output", "-o", help="输出格式: table, json, yaml"),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="静默模式，仅输出核心结果"),
+    verbose: bool = typer.Option(False, "--verbose", help="详细模式，输出 HTTP 请求日志"),
+    server: Optional[str] = typer.Option(None, "--server", help="服务端地址"),
+    version: bool = typer.Option(False, "--version", "-V", help="显示版本号"),
+) -> None:
+    global _output_format, _quiet, _verbose, _server
+    if version:
+        typer.echo(f"tars-cli {__version__}")
+        raise typer.Exit()
+    _output_format = output
+    _quiet = quiet
+    _verbose = verbose
+    _server = server
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit()
+
+
+def get_global_options() -> tuple[str, bool, bool, Optional[str]]:
+    return _output_format, _quiet, _verbose, _server
+
+
+QUICKSTART_TEXT = """\
+🚀 tars CLI 快速上手
+
+━━━ 路线 A: 智能生成 ━━━
+
+  # 1. 登录
+  tars auth login --server https://tars.example.com
+
+  # 2. 导入 Plugin
+  tars plugin import https://git.example.com/my-plugin.git
+
+  # 3. 智能生成数据集（Agent / Skill）
+  tars dataset generate <plugin_id> --agent-name <name> --publish
+  tars dataset generate <plugin_id> --skill-name <name> --publish
+
+  # 多轮场景
+  tars dataset generate <plugin_id> --agent-name <name> -t multi_turn --publish
+
+  # 4. 运行评估
+  tars eval run <plugin_id> --agent-name <name> --dataset-version <version_id>
+  tars eval run <plugin_id> --skill-name <name> --dataset-version <version_id>
+
+  # 5. 导出报告（可选）
+  tars plugin export-report <plugin_id>
+
+━━━ 路线 B: 手动上传 ━━━
+
+  # 1. 登录
+  tars auth login --server https://tars.example.com
+
+  # 2. 导入 Plugin
+  tars plugin import https://git.example.com/my-plugin.git
+
+  # 3. 下载模板
+  tars template download plan
+  tars template download testcase-single
+  tars template download testcase-multi
+
+  # 4. 填写模板后上传（Agent / Skill）
+  tars dataset upload <plugin_id> --agent-name <name> --plan plan.yaml --cases cases.yaml
+  tars dataset upload <plugin_id> --skill-name <name> --plan plan.yaml --cases cases.yaml
+
+  # 5. 运行评估
+  tars eval run <plugin_id> --agent-name <name> --dataset-version <version_id>
+
+━━━ 其他常用命令 ━━━
+
+  # 查看数据集版本列表
+  tars dataset list <plugin_id> --agent-name <name>
+  tars dataset list <plugin_id> --skill-name <name> -t multi_turn
+
+  # 发布草稿数据集
+  tars dataset publish <version_id>
+
+  # 查看评估任务状态
+  tars eval status <task_id>
+
+━━━ CI/CD 集成 ━━━
+
+  export TARS_ACCESS_TOKEN=eyJhbGc...
+  export TARS_SERVER_URL=https://tars.example.com
+  tars eval run <plugin_id> --agent-name <name> --dataset-version <id> -o json --threshold 0.8
+  # 退出码: 0=通过, 1=未通过, 2=错误
+"""
+
+
+@app.command()
+def quickstart() -> None:
+    """输出完整的端到端使用示例"""
+    typer.echo(QUICKSTART_TEXT)
+
+
+import tars_cli.commands.auth_cmd  # noqa: E402, F401
+import tars_cli.commands.plugin_cmd  # noqa: E402, F401
+import tars_cli.commands.dataset_cmd  # noqa: E402, F401
+import tars_cli.commands.eval_cmd  # noqa: E402, F401
+import tars_cli.commands.template_cmd  # noqa: E402, F401

tars_cli/auth.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import json
+import os
+import stat
+from dataclasses import dataclass
+
+from tars_cli.config import get_credentials_path, get_env_token, resolve_server_url
+
+
+@dataclass
+class Credentials:
+    server_url: str
+    access_token: str
+    refresh_token: str
+    expires_at: str = ""
+
+
+def save_credentials(creds: Credentials) -> None:
+    path = get_credentials_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps({
+        "server_url": creds.server_url,
+        "access_token": creds.access_token,
+        "refresh_token": creds.refresh_token,
+        "expires_at": creds.expires_at,
+    }, indent=2))
+    os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)
+
+
+def load_credentials(cli_server: str | None = None) -> Credentials | None:
+    env_token = get_env_token()
+    if env_token:
+        return Credentials(
+            server_url=resolve_server_url(cli_server),
+            access_token=env_token,
+            refresh_token="",
+        )
+
+    path = get_credentials_path()
+    if not path.exists():
+        return None
+    try:
+        data = json.loads(path.read_text())
+        return Credentials(
+            server_url=resolve_server_url(cli_server) if cli_server else data.get("server_url", ""),
+            access_token=data["access_token"],
+            refresh_token=data.get("refresh_token", ""),
+            expires_at=data.get("expires_at", ""),
+        )
+    except (json.JSONDecodeError, KeyError):
+        return None
+
+
+def clear_credentials() -> None:
+    path = get_credentials_path()
+    if path.exists():
+        path.unlink()

tars_cli/client.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+import typer
+
+from httpx import HTTPTransport
+
+from tars_cli.auth import Credentials, load_credentials, save_credentials
+
+
+class AuthExpiredError(Exception):
+    pass
+
+
+class TarsAPIClient:
+    def __init__(self, server_url: str, credentials: Credentials, verbose: bool = False) -> None:
+        self._server_url = server_url.rstrip("/")
+        self._credentials = credentials
+        self._verbose = verbose
+        self._client = httpx.Client(base_url=f"{self._server_url}/api/v1", timeout=30.0, transport=HTTPTransport(proxy=None))
+
+    @classmethod
+    def from_context(cls, cli_server: str | None = None, verbose: bool = False) -> TarsAPIClient:
+        creds = load_credentials(cli_server)
+        if not creds:
+            typer.echo("未登录，请先执行 tars auth login", err=True)
+            raise typer.Exit(code=2)
+        server_url = creds.server_url
+        return cls(server_url=server_url, credentials=creds, verbose=verbose)
+
+    @property
+    def server_url(self) -> str:
+        return self._server_url
+
+    def _headers(self) -> dict[str, str]:
+        return {"Authorization": f"Bearer {self._credentials.access_token}"}
+
+    def _log_request(self, method: str, url: str, **kwargs: Any) -> None:
+        if self._verbose:
+            typer.echo(f"  → {method} {url}", err=True)
+            if "json" in kwargs:
+                typer.echo(f"    Body: {kwargs['json']}", err=True)
+
+    def _log_response(self, resp: httpx.Response) -> None:
+        if self._verbose:
+            typer.echo(f"  ← {resp.status_code} ({len(resp.content)} bytes)", err=True)
+
+    def _refresh_token(self) -> bool:
+        if not self._credentials.refresh_token:
+            return False
+        try:
+            resp = self._client.post("/auth/refresh", json={"refresh_token": self._credentials.refresh_token})
+            if resp.status_code == 200:
+                data = resp.json()
+                self._credentials.access_token = data["access_token"]
+                self._credentials.refresh_token = data.get("refresh_token", self._credentials.refresh_token)
+                self._credentials.expires_at = data.get("expires_at", "")
+                save_credentials(self._credentials)
+                return True
+        except httpx.HTTPError:
+            pass
+        return False
+
+    def _request(self, method: str, path: str, **kwargs: Any) -> httpx.Response:
+        url = path
+        headers = kwargs.pop("headers", None) or {}
+        headers.update(self._headers())
+        kwargs["headers"] = headers
+        self._log_request(method, url, **kwargs)
+
+        try:
+            resp = self._client.request(method, url, **kwargs)
+        except httpx.ConnectError:
+            typer.echo(f"无法连接到服务端: {self._server_url}", err=True)
+            raise typer.Exit(code=2)
+        except httpx.TimeoutException:
+            typer.echo(f"请求超时: {method} {url}", err=True)
+            raise typer.Exit(code=2)
+
+        self._log_response(resp)
+
+        if resp.status_code == 401:
+            if self._refresh_token():
+                kwargs["headers"].update(self._headers())
+                self._log_request(method, url, **kwargs)
+                resp = self._client.request(method, url, **kwargs)
+                self._log_response(resp)
+            else:
+                raise AuthExpiredError("认证已过期，请重新执行 tars auth login")
+
+        return resp
+
+    def get(self, path: str, **kwargs: Any) -> httpx.Response:
+        try:
+            return self._request("GET", path, **kwargs)
+        except AuthExpiredError as e:
+            typer.echo(str(e), err=True)
+            raise typer.Exit(code=2)
+
+    def post(self, path: str, **kwargs: Any) -> httpx.Response:
+        try:
+            return self._request("POST", path, **kwargs)
+        except AuthExpiredError as e:
+            typer.echo(str(e), err=True)
+            raise typer.Exit(code=2)
+
+    def put(self, path: str, **kwargs: Any) -> httpx.Response:
+        try:
+            return self._request("PUT", path, **kwargs)
+        except AuthExpiredError as e:
+            typer.echo(str(e), err=True)
+            raise typer.Exit(code=2)
+
+    def close(self) -> None:
+        self._client.close()

tars_cli/commands/auth_cmd.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import httpx
+import typer
+
+from httpx import HTTPTransport
+
+from tars_cli.app import auth_app, get_global_options
+from tars_cli.auth import Credentials, clear_credentials, load_credentials, save_credentials
+from tars_cli.client import TarsAPIClient
+from tars_cli.config import resolve_server_url
+from tars_cli.hints import print_hints
+from tars_cli.output import render
+
+
+@auth_app.command()
+def login(
+    server: str = typer.Option("", "--server", "-s", help="服务端地址"),
+) -> None:
+    """登录 tars 平台"""
+    output_fmt, quiet, verbose, global_server = get_global_options()
+    server_url = resolve_server_url(server or global_server)
+
+    username = typer.prompt("用户名")
+    password = typer.prompt("密码", hide_input=True)
+
+    client = httpx.Client(base_url=f"{server_url}/api/v1", timeout=30.0, transport=HTTPTransport(proxy=None))
+    try:
+        resp = client.post("/auth/login", json={"username": username, "password": password})
+        if resp.status_code != 200:
+            typer.echo(f"登录失败: {resp.json().get('detail', resp.text)}", err=True)
+            raise typer.Exit(code=2)
+
+        data = resp.json()
+        creds = Credentials(
+            server_url=server_url,
+            access_token=data["access_token"],
+            refresh_token=data.get("refresh_token", ""),
+            expires_at=data.get("expires_at", ""),
+        )
+        save_credentials(creds)
+
+        me_resp = client.get("/auth/me", headers={"Authorization": f"Bearer {creds.access_token}"})
+        user_info = me_resp.json() if me_resp.status_code == 200 else {}
+
+        result = {
+            "message": "登录成功",
+            "username": user_info.get("username", username),
+            "server": server_url,
+        }
+        web_url, next_step = print_hints(server_url, "auth_login", quiet=quiet)
+        render(result, output_format=output_fmt, quiet=quiet, web_url=web_url, next_step=next_step)
+    finally:
+        client.close()
+
+
+@auth_app.command()
+def logout() -> None:
+    """登出并清除本地凭证"""
+    output_fmt, quiet, verbose, global_server = get_global_options()
+    creds = load_credentials(global_server)
+    if creds and creds.refresh_token:
+        try:
+            client = TarsAPIClient(server_url=creds.server_url, credentials=creds, verbose=verbose)
+            client.post("/auth/logout", json={"refresh_token": creds.refresh_token})
+            client.close()
+        except Exception:
+            pass
+
+    clear_credentials()
+    typer.echo("已登出")

tars_cli/commands/dataset_cmd.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from tars_cli.app import dataset_app, get_global_options
+from tars_cli.auth import load_credentials
+from tars_cli.client import TarsAPIClient
+from tars_cli.hints import print_hints
+from tars_cli.output import render, render_table
+from tars_cli.utils.polling import poll_task
+
+
+@dataset_app.command()
+def generate(
+    plugin_id: str = typer.Argument(help="Plugin ID"),
+    agent_name: Optional[str] = typer.Option(None, "--agent-name", help="Agent 名称"),
+    skill_name: Optional[str] = typer.Option(None, "--skill-name", help="Skill 名称"),
+    conversation_type: str = typer.Option("single_turn", "--conversation-type", "-t", help="会话类型: single_turn, multi_turn"),
+    publish: bool = typer.Option(False, "--publish", help="生成后自动发布"),
+) -> None:
+    """智能生成数据集（路线 A）"""
+    if agent_name and skill_name:
+        typer.echo("--agent-name 和 --skill-name 不能同时使用", err=True)
+        raise typer.Exit(code=2)
+    if not agent_name and not skill_name:
+        typer.echo("请指定 --agent-name 或 --skill-name", err=True)
+        raise typer.Exit(code=2)
+
+    output_fmt, quiet, verbose, server = get_global_options()
+    creds = load_credentials(server)
+    if not creds:
+        typer.echo("未登录，请先执行 tars auth login", err=True)
+        raise typer.Exit(code=2)
+
+    client = TarsAPIClient(server_url=creds.server_url, credentials=creds, verbose=verbose)
+    try:
+        target_name = agent_name or skill_name
+        body: dict = {"plugin_id": plugin_id, "conversation_type": conversation_type, "agent_name": target_name}
+        if skill_name:
+            body["evaluation_target_type"] = "skill"
+            body["skill_name"] = skill_name
+
+        resp = client.post("/data-set-versions", json=body)
+        if not resp.is_success:
+            typer.echo(f"创建版本失败: {resp.text}", err=True)
+            raise typer.Exit(code=2)
+        version_data = resp.json()
+        version_id = version_data["id"]
+
+        plan_body: dict = {"version_id": version_id, "plugin_id": plugin_id, "agent_name": target_name}
+        resp = client.post("/datasets/generate/generate-plan", json=plan_body)
+        if not resp.is_success:
+            typer.echo(f"生成计划失败: {resp.text}", err=True)
+            raise typer.Exit(code=2)
+
+        plan_data = poll_task(
+            request_fn=lambda: client.get("/datasets/generate/generate-plan/status", params={"version_id": version_id}),
+            label="生成评估计划",
+        )
+
+        strategy = plan_data.get("test_strategy")
+        strategy_readable = plan_data.get("test_strategy_readable", "")
+        if strategy:
+            save_resp = client.put(
+                f"/data-set-versions/{version_id}/test-strategy",
+                json={"test_strategy": strategy, "test_strategy_readable": strategy_readable},
+            )
+            if not save_resp.is_success:
+                typer.echo(f"保存评估计划失败: {save_resp.text}", err=True)
+                raise typer.Exit(code=2)
+
+        resp = client.post(f"/data-set-versions/{version_id}/generate-cases")
+        if not resp.is_success:
+            typer.echo(f"生成用例失败: {resp.text}", err=True)
+            raise typer.Exit(code=2)
+
+        result_data = poll_task(
+            request_fn=lambda: client.get(f"/data-set-versions/{version_id}/generate-cases/status"),
+            label="生成评估用例",
+        )
+
+        if publish:
+            resp = client.post(f"/data-set-versions/{version_id}/publish")
+            if not resp.is_success:
+                typer.echo(f"发布失败: {resp.text}", err=True)
+                raise typer.Exit(code=2)
+
+        result = {
+            "version_id": version_id,
+            "status": "published" if publish else "draft",
+            "case_count": result_data.get("case_count", ""),
+            "message": "数据集生成完成",
+        }
+        web_url, next_step = print_hints(
+            creds.server_url, "dataset_generate", quiet=quiet,
+            plugin_id=plugin_id, version_id=str(version_id),
+        )
+        render(result, output_format=output_fmt, quiet=quiet, web_url=web_url, next_step=next_step)
+    finally:
+        client.close()
+
+
+@dataset_app.command()
+def upload(
+    plugin_id: str = typer.Argument(help="Plugin ID"),
+    agent_name: Optional[str] = typer.Option(None, "--agent-name", help="Agent 名称"),
+    skill_name: Optional[str] = typer.Option(None, "--skill-name", help="Skill 名称"),
+    plan: str = typer.Option(..., "--plan", help="评估计划文件路径"),
+    cases: str = typer.Option(..., "--cases", help="用例文件路径"),
+    conversation_type: str = typer.Option("single_turn", "--conversation-type", "-t", help="会话类型"),
+) -> None:
+    """手动上传数据集（路线 B）"""
+    if agent_name and skill_name:
+        typer.echo("--agent-name 和 --skill-name 不能同时使用", err=True)
+        raise typer.Exit(code=2)
+    if not agent_name and not skill_name:
+        typer.echo("请指定 --agent-name 或 --skill-name", err=True)
+        raise typer.Exit(code=2)
+
+    for f in [plan, cases]:
+        if not Path(f).exists():
+            typer.echo(f"文件不存在: {f}", err=True)
+            raise typer.Exit(code=2)
+
+    output_fmt, quiet, verbose, server = get_global_options()
+    creds = load_credentials(server)
+    if not creds:
+        typer.echo("未登录，请先执行 tars auth login", err=True)
+        raise typer.Exit(code=2)
+
+    client = TarsAPIClient(server_url=creds.server_url, credentials=creds, verbose=verbose)
+    try:
+        target_name = agent_name or skill_name
+        body: dict = {"plugin_id": plugin_id, "conversation_type": conversation_type, "agent_name": target_name}
+        if skill_name:
+            body["evaluation_target_type"] = "skill"
+            body["skill_name"] = skill_name
+
+        resp = client.post("/data-set-versions", json=body)
+        if not resp.is_success:
+            typer.echo(f"创建版本失败: {resp.text}", err=True)
+            raise typer.Exit(code=2)
+        version_id = resp.json()["id"]
+
+        with open(plan, "rb") as plan_f:
+            plan_resp = client.post(f"/data-set-versions/{version_id}/evaluation-plan/upload", files={"file": (Path(plan).name, plan_f)})
+        if not plan_resp.is_success:
+            typer.echo(f"上传计划失败: {plan_resp.text}", err=True)
+            raise typer.Exit(code=2)
+
+        with open(cases, "rb") as cases_f:
+            cases_resp = client.post(
+                f"/data-set-versions/{version_id}/import-cases",
+                files={"file": (Path(cases).name, cases_f)},
+            )
+        if not cases_resp.is_success:
+            typer.echo(f"上传用例失败: {cases_resp.text}", err=True)
+            raise typer.Exit(code=2)
+        cases_data = cases_resp.json()
+        imported_count = cases_data.get("imported_count", 0)
+        typer.echo(f"成功导入 {imported_count} 条用例", err=True)
+
+        resp = client.post(f"/data-set-versions/{version_id}/publish")
+        if not resp.is_success:
+            typer.echo(f"发布失败: {resp.text}", err=True)
+            raise typer.Exit(code=2)
+
+        result = {
+            "version_id": version_id,
+            "status": "published",
+            "message": "数据集上传并发布成功",
+        }
+        web_url, next_step = print_hints(
+            creds.server_url, "dataset_upload", quiet=quiet,
+            plugin_id=plugin_id, version_id=str(version_id),
+        )
+        render(result, output_format=output_fmt, quiet=quiet, web_url=web_url, next_step=next_step)
+    finally:
+        client.close()
+
+
+@dataset_app.command("list")
+def list_versions(
+    plugin_id: str = typer.Argument(help="Plugin ID"),
+    agent_name: Optional[str] = typer.Option(None, "--agent-name", help="Agent 名称"),
+    skill_name: Optional[str] = typer.Option(None, "--skill-name", help="Skill 名称"),
+    conversation_type: str = typer.Option("single_turn", "--conversation-type", "-t", help="会话类型"),
+    status: Optional[str] = typer.Option(None, "--status", help="筛选状态: draft, published"),
+) -> None:
+    """列出数据集版本"""
+    output_fmt, quiet, verbose, server = get_global_options()
+    creds = load_credentials(server)
+    if not creds:
+        typer.echo("未登录，请先执行 tars auth login", err=True)
+        raise typer.Exit(code=2)
+
+    client = TarsAPIClient(server_url=creds.server_url, credentials=creds, verbose=verbose)
+    try:
+        target_name = agent_name or skill_name
+        if not target_name:
+            typer.echo("请指定 --agent-name 或 --skill-name", err=True)
+            raise typer.Exit(code=2)
+
+        params: dict = {"plugin_id": plugin_id, "conversation_type": conversation_type, "agent_name": target_name}
+        if skill_name:
+            params["evaluation_target_type"] = "skill"
+        if status:
+            params["status"] = status
+
+        resp = client.get("/data-set-versions", params=params)
+        if not resp.is_success:
+            typer.echo(f"查询失败: {resp.text}", err=True)
+            raise typer.Exit(code=2)
+
+        data = resp.json()
+        items = data.get("items", data) if isinstance(data, dict) else data
+
+        if output_fmt == "table":
+            columns = ["版本 ID", "状态", "用例数", "创建时间"]
+            rows = [
+                [str(item.get("id", "")), item.get("status", ""), str(item.get("test_case_count", "")), str(item.get("created_at", ""))]
+                for item in items
+            ]
+            render_table("数据集版本列表", columns, rows)
+        else:
+            render({"items": items, "total": len(items)}, output_format=output_fmt, quiet=quiet)
+    finally:
+        client.close()
+
+
+@dataset_app.command()
+def publish(
+    version_id: str = typer.Argument(help="数据集版本 ID"),
+) -> None:
+    """发布草稿数据集版本"""
+    output_fmt, quiet, verbose, server = get_global_options()
+    creds = load_credentials(server)
+    if not creds:
+        typer.echo("未登录，请先执行 tars auth login", err=True)
+        raise typer.Exit(code=2)
+
+    client = TarsAPIClient(server_url=creds.server_url, credentials=creds, verbose=verbose)
+    try:
+        resp = client.post(f"/data-set-versions/{version_id}/publish")
+        if not resp.is_success:
+            typer.echo(f"发布失败: {resp.text}", err=True)
+            raise typer.Exit(code=2)
+
+        result = {"version_id": version_id, "status": "published", "message": "发布成功"}
+        web_url, next_step = print_hints(
+            creds.server_url, "dataset_publish", quiet=quiet, version_id=version_id,
+        )
+        render(result, output_format=output_fmt, quiet=quiet, web_url=web_url, next_step=next_step)
+    finally:
+        client.close()

tars_cli/commands/eval_cmd.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from tars_cli.app import eval_app, get_global_options
+from tars_cli.auth import load_credentials
+from tars_cli.client import TarsAPIClient
+from tars_cli.hints import print_hints
+from tars_cli.output import render
+from tars_cli.utils.polling import poll_task
+
+
+@eval_app.command()
+def run(
+    plugin_id: str = typer.Argument(help="Plugin ID"),
+    agent_name: Optional[str] = typer.Option(None, "--agent-name", help="Agent 名称"),
+    skill_name: Optional[str] = typer.Option(None, "--skill-name", help="Skill 名称"),
+    dataset_version: str = typer.Option(..., "--dataset-version", help="数据集版本 ID"),
+    threshold: Optional[float] = typer.Option(None, "--threshold", help="CI/CD 卡点阈值 (0-1)"),
+    timeout: int = typer.Option(1800, "--timeout", help="轮询超时时间（秒），默认 1800"),
+) -> None:
+    """运行评估任务"""
+    if agent_name and skill_name:
+        typer.echo("--agent-name 和 --skill-name 不能同时使用", err=True)
+        raise typer.Exit(code=2)
+
+    if threshold is not None and (threshold < 0 or threshold > 1):
+        typer.echo("--threshold 必须在 0-1 范围内", err=True)
+        raise typer.Exit(code=2)
+
+    output_fmt, quiet, verbose, server = get_global_options()
+    creds = load_credentials(server)
+    if not creds:
+        typer.echo("未登录，请先执行 tars auth login", err=True)
+        raise typer.Exit(code=2)
+
+    client = TarsAPIClient(server_url=creds.server_url, credentials=creds, verbose=verbose)
+    try:
+        body: dict = {"dataset_version_id": dataset_version}
+        target_name = agent_name or skill_name
+        if target_name:
+            body["agent_name"] = target_name
+        if skill_name and not agent_name:
+            body["evaluation_target_type"] = "skill"
+            body["skill_name"] = skill_name
+
+        resp = client.post(f"/plugins/{plugin_id}/evaluations", json=body)
+        if not resp.is_success:
+            typer.echo(f"创建评估任务失败: {resp.text}", err=True)
+            raise typer.Exit(code=2)
+
+        task_data = resp.json()
+        task_id = task_data["id"]
+        typer.echo(f"任务已创建: {task_id}", err=True)
+
+        try:
+            final_data = poll_task(
+                request_fn=lambda: client.get(f"/plugins/{plugin_id}/evaluations/{task_id}/progress"),
+                label="评估执行中",
+                timeout=timeout,
+            )
+        except typer.Exit:
+            typer.echo(f"\n轮询超时，任务仍在后台运行。可用以下命令查看结果：\n  tars eval status {task_id}", err=True)
+            raise
+
+        detail_resp = client.get(f"/plugins/{plugin_id}/evaluations/{task_id}")
+        if detail_resp.status_code == 200:
+            final_data.update(detail_resp.json())
+
+        score = final_data.get("score", 0)
+        pass_rate = final_data.get("pass_rate", 0)
+        status = final_data.get("status", "")
+
+        result = {
+            "task_id": task_id,
+            "status": status,
+            "score": score,
+            "pass_rate": pass_rate,
+            "message": "评估完成",
+        }
+        web_url, next_step = print_hints(
+            creds.server_url, "eval_run", quiet=quiet, plugin_id=plugin_id, task_id=str(task_id),
+        )
+        render(result, output_format=output_fmt, quiet=quiet, web_url=web_url, next_step=next_step)
+
+        if threshold is not None:
+            normalized_score = score / 100.0 if score > 1 else score
+            if normalized_score < threshold:
+                raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+
+@eval_app.command()
+def status(
+    task_id: str = typer.Argument(help="评估任务 ID"),
+) -> None:
+    """查看评估任务状态"""
+    output_fmt, quiet, verbose, server = get_global_options()
+    creds = load_credentials(server)
+    if not creds:
+        typer.echo("未登录，请先执行 tars auth login", err=True)
+        raise typer.Exit(code=2)
+
+    client = TarsAPIClient(server_url=creds.server_url, credentials=creds, verbose=verbose)
+    try:
+        resp = client.get(f"/evaluation-report/{task_id}")
+        if not resp.is_success:
+            typer.echo(f"查询失败: {resp.text}", err=True)
+            raise typer.Exit(code=2)
+
+        data = resp.json()
+        stats = data.get("test_case_stats", {})
+        result = {
+            "task_id": task_id,
+            "status": data.get("status", ""),
+            "overall_score": data.get("overall_score", 0),
+            "total_cases": stats.get("total_cases", 0),
+            "passed_cases": stats.get("passed_cases", 0),
+            "failed_cases": stats.get("failed_cases", 0),
+        }
+        render(result, output_format=output_fmt, quiet=quiet)
+    finally:
+        client.close()

tars_cli/commands/plugin_cmd.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+import typer
+
+from tars_cli.app import get_global_options, plugin_app
+from tars_cli.auth import load_credentials
+from tars_cli.client import TarsAPIClient
+from tars_cli.hints import print_hints
+from tars_cli.output import render
+
+
+def _is_git_url(source: str) -> bool:
+    return "://" in source or source.endswith(".git")
+
+
+@plugin_app.command("import")
+def import_plugin(
+    source: str = typer.Argument(help="Git URL 或本地文件路径"),
+) -> None:
+    """导入 Plugin（自动识别 Git URL 或文件）"""
+    output_fmt, quiet, verbose, server = get_global_options()
+    creds = load_credentials(server)
+    if not creds:
+        typer.echo("未登录，请先执行 tars auth login", err=True)
+        raise typer.Exit(code=2)
+
+    client = TarsAPIClient(server_url=creds.server_url, credentials=creds, verbose=verbose)
+    try:
+        if _is_git_url(source):
+            resp = client.post("/plugins/import-git/validate", json={"git_url": source})
+            if not resp.is_success:
+                typer.echo(f"Git URL 验证失败: {resp.text}", err=True)
+                raise typer.Exit(code=2)
+
+            resp = client.post("/plugins/import-git", json={"git_url": source})
+        else:
+            file_path = Path(source)
+            if not file_path.exists():
+                typer.echo(f"文件不存在: {source}", err=True)
+                raise typer.Exit(code=2)
+
+            with open(file_path, "rb") as f:
+                resp = client.post("/plugins/upload/validate", files={"file": (file_path.name, f)})
+            if not resp.is_success:
+                typer.echo(f"文件验证失败: {resp.text}", err=True)
+                raise typer.Exit(code=2)
+
+            with open(file_path, "rb") as f:
+                resp = client.post("/plugins/upload", files={"file": (file_path.name, f)})
+
+        if not resp.is_success:
+            typer.echo(f"导入失败: {resp.text}", err=True)
+            raise typer.Exit(code=2)
+
+        data = resp.json()
+        plugin_id = data.get("id", "")
+        result = {
+            "plugin_id": plugin_id,
+            "name": data.get("name", ""),
+            "message": "Plugin 导入成功",
+        }
+        web_url, next_step = print_hints(
+            creds.server_url, "plugin_import", quiet=quiet, plugin_id=str(plugin_id)
+        )
+        render(result, output_format=output_fmt, quiet=quiet, web_url=web_url, next_step=next_step)
+    finally:
+        client.close()
+
+
+@plugin_app.command("export-report")
+def export_report(
+    plugin_id: str = typer.Argument(help="Plugin ID"),
+    output_path: str | None = typer.Option(None, "-o", "--output-path", help="输出文件路径"),
+) -> None:
+    """导出 Plugin 评估报告（HTML）"""
+    if not output_path:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_path = f"report_{plugin_id[:8]}_{timestamp}.html"
+    output_fmt, quiet, verbose, server = get_global_options()
+    creds = load_credentials(server)
+    if not creds:
+        typer.echo("未登录，请先执行 tars auth login", err=True)
+        raise typer.Exit(code=2)
+
+    client = TarsAPIClient(server_url=creds.server_url, credentials=creds, verbose=verbose)
+    try:
+        resp = client.get(f"/plugins/{plugin_id}/export-report/html")
+        if not resp.is_success:
+            typer.echo(f"导出失败: {resp.text}", err=True)
+            raise typer.Exit(code=2)
+
+        Path(output_path).write_bytes(resp.content)
+        abs_path = str(Path(output_path).resolve())
+        result = {"message": "报告导出成功", "path": abs_path}
+        web_url, next_step = print_hints(
+            creds.server_url, "plugin_report", quiet=quiet, plugin_id=plugin_id
+        )
+        render(result, output_format=output_fmt, quiet=quiet, web_url=web_url, next_step=next_step)
+    finally:
+        client.close()

tars_cli/commands/template_cmd.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from tars_cli.app import get_global_options, template_app
+from tars_cli.auth import load_credentials
+from tars_cli.client import TarsAPIClient
+from tars_cli.hints import print_hints
+from tars_cli.output import render
+
+TEMPLATE_MAP = {
+    "plan": ("evaluation-plan", "yaml"),
+    "testcase-single": ("dataset", None),
+    "testcase-multi": ("dataset/multi-turn-dataset", None),
+}
+
+
+@template_app.command()
+def download(
+    template_type: str = typer.Argument(help="模板类型: plan, testcase-single, testcase-multi"),
+    format: str = typer.Option("yaml", "--format", "-f", help="文件格式: yaml, json"),
+) -> None:
+    """下载模板文件"""
+    if template_type not in TEMPLATE_MAP:
+        typer.echo(f"未知模板类型: {template_type}，可选: {', '.join(TEMPLATE_MAP.keys())}", err=True)
+        raise typer.Exit(code=2)
+
+    output_fmt, quiet, verbose, server = get_global_options()
+    creds = load_credentials(server)
+    if not creds:
+        typer.echo("未登录，请先执行 tars auth login", err=True)
+        raise typer.Exit(code=2)
+
+    client = TarsAPIClient(server_url=creds.server_url, credentials=creds, verbose=verbose)
+    try:
+        path_prefix, default_format = TEMPLATE_MAP[template_type]
+        if template_type == "plan":
+            url = f"/templates/{path_prefix}/{format}"
+        elif template_type == "testcase-single":
+            url = f"/templates/{path_prefix}/{format}"
+        else:
+            url = f"/templates/{path_prefix}?format={format}"
+
+        resp = client.get(url)
+        if not resp.is_success:
+            typer.echo(f"下载失败: {resp.text}", err=True)
+            raise typer.Exit(code=2)
+
+        filename = f"{template_type}-template.{format}"
+        Path(filename).write_bytes(resp.content)
+        abs_path = str(Path(filename).resolve())
+
+        result = {"message": "模板下载成功", "file": abs_path}
+        web_url, next_step = print_hints(creds.server_url, "template_download", quiet=quiet)
+        render(result, output_format=output_fmt, quiet=quiet, web_url=web_url, next_step=next_step)
+    finally:
+        client.close()

tars_cli/config.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from platformdirs import user_config_dir
+
+APP_NAME = "tars"
+DEFAULT_SERVER_URL = "http://localhost:8001"
+
+ENV_ACCESS_TOKEN = "TARS_ACCESS_TOKEN"
+ENV_SERVER_URL = "TARS_SERVER_URL"
+
+
+def get_config_dir() -> Path:
+    return Path(user_config_dir(APP_NAME))
+
+
+def get_credentials_path() -> Path:
+    return get_config_dir() / "credentials.json"
+
+
+def resolve_server_url(cli_server: str | None = None) -> str:
+    if cli_server:
+        return cli_server.rstrip("/")
+    env_url = os.environ.get(ENV_SERVER_URL)
+    if env_url:
+        return env_url.rstrip("/")
+    return DEFAULT_SERVER_URL
+
+
+def get_env_token() -> str | None:
+    return os.environ.get(ENV_ACCESS_TOKEN)

tars_cli/hints.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import typer
+
+ROUTE_MAP: dict[str, str] = {
+    "plugin_import": "/plugins/{plugin_id}",
+    "plugin_report": "/plugins/{plugin_id}/report",
+    "dataset_version": "/plugins/{plugin_id}/datasets/{version_id}",
+    "dataset_generate": "/plugins/{plugin_id}/datasets/{version_id}",
+    "dataset_upload": "/plugins/{plugin_id}/datasets/{version_id}",
+    "dataset_publish": "/plugins/{plugin_id}/datasets/{version_id}",
+    "eval_task": "/plugins/{plugin_id}/evaluations/{task_id}",
+    "eval_run": "/plugins/{plugin_id}/evaluations/{task_id}",
+}
+
+NEXT_STEP_MAP: dict[str, str] = {
+    "auth_login": "tars plugin import <git_url_or_file_path>",
+    "plugin_import": "tars dataset generate {plugin_id} --agent-name <name> --conversation-type single_turn",
+    "dataset_generate": "tars eval run {plugin_id} --agent-name <name> --dataset-version {version_id}",
+    "dataset_upload": "tars eval run {plugin_id} --agent-name <name> --dataset-version {version_id}",
+    "dataset_publish": "tars eval run {plugin_id} --agent-name <name> --dataset-version {version_id}",
+    "eval_run": "tars plugin export-report {plugin_id}",
+    "template_download": "tars dataset upload {plugin_id} --agent-name <name> --plan plan.yaml --cases cases.yaml",
+}
+
+
+def build_web_url(server_url: str, command: str, **kwargs: str) -> str:
+    route = ROUTE_MAP.get(command, "")
+    if not route:
+        return ""
+    try:
+        path = route.format(**kwargs)
+    except KeyError:
+        return ""
+    web_base = server_url.rstrip("/").rsplit(":", 1)[0] + ":8000"
+    return f"{web_base}{path}"
+
+
+def build_next_step(command: str, **kwargs: str) -> str:
+    template = NEXT_STEP_MAP.get(command, "")
+    if not template:
+        return ""
+    try:
+        return template.format(**kwargs)
+    except KeyError:
+        return template
+
+
+def print_hints(server_url: str, command: str, quiet: bool = False, **kwargs: str) -> tuple[str, str]:
+    web_url = build_web_url(server_url, command, **kwargs)
+    next_step = build_next_step(command, **kwargs)
+
+    if not quiet:
+        if web_url:
+            typer.echo(f"\n📎 在 Web 端查看: {web_url}")
+        if next_step:
+            typer.echo(f"👉 下一步: {next_step}")
+
+    return web_url, next_step

tars_cli/output.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import typer
+import yaml
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+OutputFormat = str  # "table" | "json" | "yaml"
+
+
+def render_table(title: str, columns: list[str], rows: list[list[str]]) -> None:
+    table = Table(title=title, show_lines=True)
+    for col in columns:
+        table.add_column(col)
+    for row in rows:
+        table.add_row(*row)
+    console.print(table)
+
+
+def render_json(data: dict[str, Any]) -> None:
+    typer.echo(json.dumps(data, indent=2, ensure_ascii=False, default=str))
+
+
+def render_yaml(data: dict[str, Any]) -> None:
+    typer.echo(yaml.dump(data, allow_unicode=True, default_flow_style=False, sort_keys=False).rstrip())
+
+
+def render(
+    data: dict[str, Any],
+    output_format: str = "table",
+    quiet: bool = False,
+    table_title: str = "",
+    table_columns: list[str] | None = None,
+    table_rows: list[list[str]] | None = None,
+    web_url: str = "",
+    next_step: str = "",
+) -> None:
+    if output_format == "json":
+        payload = dict(data)
+        if not quiet:
+            if web_url:
+                payload["web_url"] = web_url
+            if next_step:
+                payload["next_step"] = next_step
+        render_json(payload)
+    elif output_format == "yaml":
+        payload = dict(data)
+        if not quiet:
+            if web_url:
+                payload["web_url"] = web_url
+            if next_step:
+                payload["next_step"] = next_step
+        render_yaml(payload)
+    else:
+        if table_columns and table_rows:
+            render_table(table_title, table_columns, table_rows)
+        else:
+            for k, v in data.items():
+                typer.echo(f"{k}: {v}")

tars_cli/utils/polling.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import time
+from typing import Any, Callable
+
+import httpx
+import typer
+
+from tars_cli.utils.progress import ProgressDisplay
+
+TERMINAL_STATES = {"completed", "failed", "partial", "timeout", "cancelled"}
+
+
+def poll_task(
+    request_fn: Callable[[], httpx.Response],
+    status_extractor: Callable[[dict[str, Any]], str] | None = None,
+    progress_extractor: Callable[[dict[str, Any]], int] | None = None,
+    stage_extractor: Callable[[dict[str, Any]], str] | None = None,
+    terminal_states: set[str] | None = None,
+    timeout: int = 0,
+    label: str = "处理中",
+) -> dict[str, Any]:
+    terminal = terminal_states or TERMINAL_STATES
+    _status_fn = status_extractor or (lambda d: d.get("status", ""))
+    _stage_fn = stage_extractor or (lambda d: d.get("current_stage", ""))
+
+    def _extract_progress(data: dict[str, Any]) -> int:
+        if progress_extractor:
+            return progress_extractor(data)
+        pct = data.get("overall_progress")
+        if pct is not None:
+            return int(pct)
+        progress_obj = data.get("progress")
+        if isinstance(progress_obj, dict):
+            pct = progress_obj.get("percentage")
+            if pct is not None:
+                return int(pct)
+        status = _status_fn(data)
+        stage_map = {"idle": 0, "pending": 5, "generating": 30, "processing": 50, "publishing": 80, "completed": 100, "failed": 100, "partial": 100}
+        return stage_map.get(status, 10)
+
+    start = time.monotonic()
+
+    with ProgressDisplay(label) as progress:
+        while True:
+            elapsed = time.monotonic() - start
+            if timeout > 0 and elapsed >= timeout:
+                typer.echo(f"任务超时（{timeout}秒）", err=True)
+                raise typer.Exit(code=2)
+
+            resp = request_fn()
+            if not resp.is_success:
+                typer.echo(f"轮询失败: HTTP {resp.status_code}", err=True)
+                raise typer.Exit(code=2)
+
+            data = resp.json()
+            status = _status_fn(data)
+            pct = _extract_progress(data)
+            stage = _stage_fn(data)
+
+            progress.update(pct, stage or status)
+
+            if status in terminal:
+                return data
+
+            interval = 2.0 if elapsed < 30 else 5.0
+            time.sleep(interval)

tars_cli/utils/progress.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from types import TracebackType
+from typing import Any
+
+from rich.console import Console
+from rich.progress import BarColumn, Progress, SpinnerColumn, TaskID, TextColumn, TimeElapsedColumn
+
+console = Console()
+
+
+class ProgressDisplay:
+    def __init__(self, label: str = "处理中") -> None:
+        self._label = label
+        self._progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[bold blue]{task.description}"),
+            BarColumn(),
+            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+            TimeElapsedColumn(),
+            console=console,
+        )
+        self._task_id: TaskID | None = None
+
+    def __enter__(self) -> ProgressDisplay:
+        self._progress.__enter__()
+        self._task_id = self._progress.add_task(self._label, total=100)
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self._progress.__exit__(exc_type, exc_val, exc_tb)
+
+    def update(self, percentage: int, description: str = "") -> None:
+        if self._task_id is not None:
+            self._progress.update(
+                self._task_id,
+                completed=percentage,
+                description=description or self._label,
+            )

tars_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: tars-cli
+Version: 0.1.0
+Summary: tars 平台命令行工具
+Requires-Python: >=3.11
+Requires-Dist: typer>=0.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: platformdirs>=4.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.12; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: respx>=0.21; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Requires-Dist: ruff>=0.3; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"

tars_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+tars_cli/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+tars_cli/__main__.py,sha256=Rsczv9C7Joo10Rh7j2bbHOlT32N3eh6vDZTvJv0rk2I,67
+tars_cli/app.py,sha256=NU5f5I1suovHydso62FlwzILMP4BNLhyDFkJroc5-Jk,5289
+tars_cli/auth.py,sha256=hfrTps-ESdR4y4FO_oQ1h-tBFgZuHKbV-goO3_CH6wg,1609
+tars_cli/client.py,sha256=8FV7TAy2ShEXe12Tb8afVbJL43kqpHvStiqI8tUY4B8,4294
+tars_cli/config.py,sha256=y7mtl9J5A2LiSMGep6Txsd00ZQiXPKkyJz4xMMs3rGY,742
+tars_cli/hints.py,sha256=1o1Sf0f12Lcj5dywxPLYmy0enUiqx2g6SPZcJDVao0E,2268
+tars_cli/output.py,sha256=5-xP0APs9bePTNfKvYB0Qp4ButKfhlzg1f_Q4HRxegk,1764
+tars_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tars_cli/commands/auth_cmd.py,sha256=stncfZVKl0qxRDMuVwuso65-D2cSXolfqVGKW3i8nTc,2557
+tars_cli/commands/dataset_cmd.py,sha256=-jyDbiNvBc8C04NK-1RDYvxyesrkSjOrju9YBGPisYk,10939
+tars_cli/commands/eval_cmd.py,sha256=51vI3TC1ZMXuGvSEJmA7xUvwWCVwwghQkFUu5s02GNA,4828
+tars_cli/commands/plugin_cmd.py,sha256=uJ9jDjB64hZktsgZW_WlrgeRAcJBVywcI4OQ2PXN0d4,3935
+tars_cli/commands/template_cmd.py,sha256=sye4f5xRS3x2ahGFOTeIgwTg-tFVY5H7gj4_5JBxKYU,2196
+tars_cli/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tars_cli/utils/polling.py,sha256=L0X56mWJa5BbWvcMb0TLbi-gtW7upVPfnLUcRvdgX18,2321
+tars_cli/utils/progress.py,sha256=8p1gZ0K_dNQpYz87Lo3l7n1Q69w7hbqBhIZNajBe2VI,1377
+tars_cli-0.1.0.dist-info/METADATA,sha256=W_rqC0qPSQNX03xUIw1nL8vqpgvFYZ-ZzrmG1aRq1sY,578
+tars_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+tars_cli-0.1.0.dist-info/entry_points.txt,sha256=tuhRjiF7IqnCY1nCxapF0i6_ZjQIIOzE6qX1V4_N8O8,42
+tars_cli-0.1.0.dist-info/top_level.txt,sha256=adbikxYObQ-84gvQ5Fe_XM01Q5Oufhy5NPrZD1nbCVQ,9
+tars_cli-0.1.0.dist-info/RECORD,,

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

tars_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tars = tars_cli.app:app

tars_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+tars_cli