@baimingtao/lbs-agent 1.0.0

package/interfaces/cli/_impl/commands/run_agent.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from application.container import AgentSystemContainer
+from config.config import AppConfig
+from interfaces.cli._impl.commands.common import bar, project_root
+
+
+def _container(config: AppConfig) -> AgentSystemContainer:
+    return AgentSystemContainer(config=config, project_root=project_root)
+
+
+def cmd_compress(config: AppConfig, target: str = "current") -> None:
+    payload = _container(config).session_service().compress_session(target)
+    result = payload["result"]
+    print()
+    print(f"  上下文压缩: {target}")
+    bar()
+    print(f"  compressed: {result.compressed}")
+    print(f"  chars:      {result.before_chars} -> {result.after_chars}")
+    print(f"  messages:   dropped={result.dropped_messages}, preserved={result.preserved_messages}")
+    if result.summary:
+        print("\n  摘要预览:")
+        print("  " + result.summary[:500].replace("\n", "\n  "))
+    print()
+
+
+def cmd_run(config: AppConfig, task: str, agent_name: str = "") -> None:
+    if not agent_name:
+        names = _container(config).agent_service().names()
+        if not names:
+            print("\n  [ERROR] 没有配置任何 agent。请先配置 core/sub_agents/agents.yaml。")
+            return
+        # 默认 agent 优先级：main > chat（通用对话）> 字母序第一个
+        # 不用 names[0]，因为字母序可能选到 audit/security 等专用 agent
+        for candidate in ("main", "chat"):
+            if candidate in names:
+                agent_name = candidate
+                break
+        if not agent_name:
+            agent_name = names[0]
+    cmd_run_agent(config, agent_name, task)
+
+
+def cmd_run_agent(config: AppConfig, agent_name: str, task: str) -> None:
+    """启动一个子 agent 的完整自循环。"""
+    container = _container(config)
+    agent_entry = container.agent_service().show_agent(agent_name)
+
+    if not agent_entry:
+        print(f"\n  [ERROR] Agent '{agent_name}' not found.")
+        print(f"  可用 agent: {', '.join(container.agent_service().names())}")
+        return
+
+    config_agent = config.agents.agents[agent_name]
+    if not config_agent.api_key:
+        provider = config.models.providers.get(config_agent.provider)
+        if provider and provider.api_key:
+            config_agent.api_key = provider.api_key
+            config_agent.base_url = config_agent.base_url or provider.base_url
+            config_agent.api_mode = config_agent.api_mode or provider.api_mode
+
+    if not config_agent.api_key:
+        print(f"\n  [ERROR] Agent '{agent_name}' 没有配置 API key")
+        print(f"  请在 core/sub_agents/agents.yaml 或 core/llm/registry/models.yaml 中为 provider '{config_agent.provider}' 配置 api_key")
+        return
+
+    try:
+        result = container.orchestration_service().run_agent(agent_name, task)
+        try:
+            container.session_service().store.save_run(
+                agent_name=agent_name,
+                task=task,
+                result=result,
+                messages=[],
+                status='done' if result.success else 'error',
+                config={'provider': config_agent.provider, 'model': config_agent.model},
+            )
+        except Exception as e:
+            print(f"  [WARN] session save failed: {e}")
+
+        print(f"\n{'='*60}")
+        print("最终结果")
+        print(f"{'='*60}")
+        print(f"Agent:    {result.agent_name}")
+        print(f"成功:     {'✓' if result.success else '✗'}")
+        print(f"迭代:     {result.iterations}")
+        print(f"工具调用: {result.total_tool_calls}")
+        print(f"耗时:     {result.duration_seconds:.1f}s")
+        if result.error:
+            print(f"错误:     {result.error}")
+        print("\n--- 输出 ---")
+        print(result.content if result.content else "(无输出)")
+        print()
+
+        if result.steps:
+            print(f"--- 执行轨迹 ({len(result.steps)} 步) ---")
+            for step in result.steps:
+                tools = ", ".join(t.name for t in step.tool_execs) if step.tool_execs else "-"
+                print(f"  [{step.iteration:02d}] tools=[{tools}]  {step.summary[:100]}")
+            print()
+    finally:
+        container.shutdown()

package/interfaces/cli/_impl/commands/sessions.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from application.container import AgentSystemContainer
+from config.config import AppConfig
+from interfaces.cli._impl.commands.common import bar as _bar, project_root
+
+
+def _container(config: AppConfig) -> AgentSystemContainer:
+    return AgentSystemContainer(config=config, project_root=project_root)
+
+
+def cmd_sessions_list(config: AppConfig) -> None:
+    print()
+    print("  会话列表")
+    _bar()
+    service = _container(config).session_service()
+    sessions = service.list_sessions(limit=100)
+    if not sessions:
+        print(f"  (暂无会话目录: {service.store.session_dir})")
+        print()
+        return
+    for s in sessions:
+        print(f"  {s.session_id}")
+        print(f"    agent: {s.agent_name} | status: {s.status} | success: {s.success}")
+        print(f"    task:  {s.task[:80]}")
+        print(f"    steps: {s.iterations} | tool_calls: {s.total_tool_calls} | seconds: {s.duration_seconds:.1f}")
+        if s.summary:
+            print(f"    summary: {s.summary}")
+    print()
+
+
+def _print_session_payload(payload: dict) -> None:
+    print()
+    print(f"  会话详情: {payload.get('session_id', '')}")
+    _bar()
+    print(f"  agent:   {payload.get('agent_name', '')}")
+    print(f"  status:  {payload.get('status', '')} | success: {payload.get('success', '')}")
+    print(f"  task:    {payload.get('task', '')}")
+    print(f"  steps:   {payload.get('iterations', 0)} | tool_calls: {payload.get('total_tool_calls', 0)} | seconds: {float(payload.get('duration_seconds') or 0):.1f}")
+    if payload.get('summary'):
+        print(f"  summary: {payload.get('summary')}")
+    if payload.get('content'):
+        content_preview = str(payload.get('content'))[:240].replace("\n", "\n    ")
+        print(f"  content: {content_preview}")
+    if payload.get('error'):
+        print(f"  error:   {payload.get('error')}")
+    # P2-1: 向后兼容 — 从 sidecar 读取 run_trace/messages 如果主 JSON 没有
+    run_trace = payload.get('run_trace', []) or []
+    messages = payload.get('messages', []) or []
+    if not run_trace and not messages and payload.get('_storage'):
+        # 尝试从 sidecar 读取
+        try:
+            from pathlib import Path as _Path
+            session_dir = _Path(payload.get('_session_dir', ''))
+            if not session_dir.exists():
+                session_dir = _Path('.') / 'sessions'
+            sid = payload.get('session_id', '')
+            json_path = session_dir / f'{sid}.json'
+            if json_path.exists():
+                trace_path = json_path.with_suffix('.trace.jsonl')
+                msgs_path = json_path.with_suffix('.messages.jsonl')
+                if trace_path.exists():
+                    import json as _json
+                    trace_lines = [l for l in trace_path.read_text(encoding='utf-8').splitlines() if l.strip()]
+                    run_trace = [_json.loads(l) for l in trace_lines if not _json.loads(l).get('_kind') == 'runtime_event'] if trace_lines else []
+                if msgs_path.exists():
+                    import json as _json
+                    msg_lines = [l for l in msgs_path.read_text(encoding='utf-8').splitlines() if l.strip()]
+                    messages = [_json.loads(l) for l in msg_lines] if msg_lines else []
+        except Exception:
+            pass
+    print(f"  run_trace: {len(run_trace)} events")
+    if run_trace:
+        first = run_trace[0] if isinstance(run_trace[0], dict) else {}
+        last = run_trace[-1] if isinstance(run_trace[-1], dict) else {}
+        def _event_label(event: dict) -> str:
+            phase = event.get('phase', '')
+            transition = event.get('transition', '')
+            return f"{phase}/{transition}" if phase or transition else "unknown"
+        print(f"    first: {_event_label(first)}")
+        print(f"    last:  {_event_label(last)}")
+    messages = payload.get('messages', []) or []
+    print(f"  messages: {len(messages)}")
+    if messages:
+        print("\n  最近消息:")
+        for m in messages[-5:]:
+            role = m.get('role', '')
+            content = str(m.get('content', ''))[:160].replace("\n", "\n    ")
+            print(f"    [{role}] {content}")
+    print()
+
+
+def cmd_sessions_show(config: AppConfig, session_id: str) -> None:
+    payload = _container(config).session_service().show_session(session_id)
+    if not payload:
+        print(f"  未找到会话: {session_id}")
+        return
+    _print_session_payload(payload)
+
+
+def cmd_sessions_report(config: AppConfig, session_id: str = "") -> None:
+    report = _container(config).session_service().report_session(session_id)
+    print(json.dumps(report, ensure_ascii=False, indent=2))
+
+
+def cmd_sessions_export(config: AppConfig, session_id: str, output_path: str) -> None:
+    result = _container(config).session_service().export_session(session_id, output_path)
+    if not result.get("success"):
+        print(f"  {result.get('error')}")
+        return
+    print(f"  已导出会话: {session_id} -> {result['output_path']}")
+
+
+def cmd_workers_show(config: AppConfig, session_id: str) -> None:
+    payload = _container(config).session_service().show_session(session_id)
+    if not payload:
+        print(f"  未找到 worker 记录: {session_id}")
+        return
+    _print_session_payload(payload)
+
+
+def cmd_workers_list(config: AppConfig) -> None:
+    print()
+    print("  Worker 状态")
+    _bar()
+    records = _container(config).session_service().list_workers(limit=100)
+    if not records:
+        print("  (暂无 worker 运行记录)")
+        print("  同步任务请用: lbs run-agent <agent> \"<task>\"")
+        print("  实际 worker 记录会在子 agent 完成后写入 sessions/.")
+        print()
+        return
+    for r in records:
+        print(f"  {r['session_id']}")
+        print(f"    agent: {r['agent_name']} | status: {r['status']} | success: {r['success']}")
+        print(f"    task:  {r['task'][:80]}")
+        print(f"    runs:  {r['iterations']} | tool_calls: {r['tool_calls']} | seconds: {r['duration_seconds']:.1f}")
+        if r.get('summary'):
+            print(f"    summary: {r['summary']}")
+    print()
+
+
+def cmd_sessions_delete(config: AppConfig, session_id: str) -> None:
+    """删除指定会话。"""
+    import os as _os
+    service = _container(config).session_service()
+    store = service.store
+    # Try exact session_id match
+    path = store.session_dir / f"{session_id}.json"
+    if not path.exists():
+        # Try partial match
+        # partial match 只在主会话 JSON 中查找，sidecar 不是独立会话。
+        matches = list(store.session_dir.glob(f"*{session_id}*.json"))
+        if len(matches) == 1:
+            path = matches[0]
+        elif len(matches) > 1:
+            print(f"  匹配到 {len(matches)} 个会话，请用更精确的 ID:")
+            for m in matches[:10]:
+                print(f"    {m.stem}")
+            return
+        else:
+            print(f"  未找到会话: {session_id}")
+            return
+    try:
+        store.delete_session_files(path)
+        print(f"  已删除: {path.stem}")
+    except Exception as e:
+        print(f"  删除失败: {e}")
+
+
+def cmd_sessions_prune(config: AppConfig, older_than_days: int = 30) -> None:
+    """批量清理旧会话。"""
+    service = _container(config).session_service()
+    deleted = service.store.cleanup_old_sessions(retention_days=older_than_days)
+    print(f"  已清理 {deleted} 个超过 {older_than_days} 天的会话")
+
+
+def cmd_sessions_stats(config: AppConfig) -> None:
+    """会话统计。"""
+    service = _container(config).session_service()
+    stats = service.store.session_stats()
+    print()
+    print("  会话统计")
+    _bar()
+    print(f"  总会话数:     {stats.get('total', 0)}")
+    print(f"  总迭代次数:   {stats.get('total_iterations', 0)}")
+    print(f"  总工具调用:   {stats.get('total_tool_calls', 0)}")
+    print(f"  总耗时:       {stats.get('total_duration_seconds', 0):.1f}s")
+    print(f"  总压缩次数:   {stats.get('total_compressions', 0)}")
+    by_agent = stats.get("by_agent", {})
+    if by_agent:
+        print(f"  按 Agent:")
+        for agent, count in sorted(by_agent.items(), key=lambda x: -x[1]):
+            print(f"    {agent:20s} {count}")
+    by_status = stats.get("by_status", {})
+    if by_status:
+        print(f"  按状态:")
+        for status, count in sorted(by_status.items(), key=lambda x: -x[1]):
+            print(f"    {status:20s} {count}")
+    # Usage summary from session-level aggregation
+    total_cost = stats.get("total_cost_usd", "0")
+    total_tokens = stats.get("total_tokens", 0)
+    if total_tokens:
+        print(f"  总 token:     {total_tokens:,}")
+        print(f"  总成本:       ${total_cost}")
+
+def cmd_session_rename(config, session_id: str = "", new_name: str = "") -> None:
+    """lbs session rename <id> <new_name>"""
+    if not session_id or not new_name:
+        print("  ❌ 用法: lbs sessions rename <session_id> <new_name>")
+        return
+    result = _container(config).session_service().rename_session(session_id, new_name)
+    if result:
+        print(f"  ✅ 会话 {session_id} 已重命名为: {new_name}")
+    else:
+        print(f"  ❌ 未找到会话: {session_id}")
+
+
+
+def cmd_session_import(config, file_path: str = "") -> None:
+    """lbs session import <file.json>"""
+    if not file_path:
+        print("  ❌ 用法: lbs sessions import <file.json>")
+        return
+    try:
+        import json
+        data = json.loads(Path(file_path).read_text(encoding="utf-8"))
+        result = _container(config).session_service().import_session(data)
+        if result["success"]:
+            print(f"  ✅ 已导入会话 {result['session_id']}: {result['title']}")
+        else:
+            print(f"  ❌ {result['error']}")
+    except Exception as e:
+        print(f"  ❌ 导入失败: {e}")

package/interfaces/cli/_impl/commands/skill.py

@@ -0,0 +1,121 @@
+"""lbs skill 命令 — 列出/搜索/激活/取消激活/同步 skill。"""
+from __future__ import annotations
+
+from config.config import AppConfig
+from interfaces.cli._impl.commands.common import project_root
+
+
+def _get_service(config: AppConfig):
+    from application.container import AgentSystemContainer
+    container = AgentSystemContainer(config=config, project_root=project_root)
+    return container.skill_service()
+
+
+def cmd_skill(
+    config: AppConfig,
+    sub: str = "list",
+    query: str = "",
+    category: str = "",
+    name: str = "",
+    source: str = "local",
+    repo_url: str = "",
+    alias: str = "",
+    sync_mode: str = "clone",
+) -> int:
+    """skill 主命令。
+
+    用法:
+      lbs skill                                  列出所有激活 skill
+      lbs skill list                             同上（按 category 分组）
+      lbs skill search <query>                   搜索 skill
+      lbs skill sources                          列出已配置 source（含 repo_url）
+      lbs skill activate <cat> <name> [source]   激活 skill
+      lbs skill deactivate <cat> <name>          取消激活
+      lbs skill sync <repo_url> [alias]          clone 新 source 并自动激活
+      lbs skill sync --pull <alias>              git pull 现有 source
+      lbs skill sync --remove <alias>            移除一个 source
+    """
+    svc = _get_service(config)
+
+    if sub in ("list", "status"):
+        skills = svc.list_skills()
+        print(f"\n=== Skills ({len(skills)}) ===")
+        by_cat = svc.list_by_category()
+        for cat in sorted(by_cat):
+            names = by_cat[cat]
+            print(f"  [{cat}] ({len(names)})")
+            for n in names:
+                meta = next((s for s in skills if s["name"] == n and s["category"] == cat), {})
+                src = meta.get("source", "?")
+                print(f"    - {n}  [source={src}]")
+        print()
+        return 0
+
+    if sub == "search":
+        if not query:
+            print("  用法: lbs skill search <query>")
+            return 1
+        results = svc.search(query)
+        print(f"\n=== Search '{query}' ({len(results)} 命中) ===")
+        for e in results:
+            print(f"  [{e['category']}/{e['name']}] [{e['source']}] {e['description']}")
+        print()
+        return 0
+
+    if sub == "sources":
+        entries = svc.list_source_entries()
+        print(f"\n=== Skill Sources ({len(entries)}) ===")
+        for e in entries:
+            repo = e.get("repo_url") or "(no repo_url)"
+            kind = e.get("kind", "?")
+            print(f"  {e['alias']}  [{kind}]  {repo}")
+        print()
+        return 0
+
+    if sub == "activate":
+        if not (category and name):
+            print("  用法: lbs skill activate <category> <name> [source]")
+            return 1
+        ok = svc.activate(category, name, source)
+        print(f"  activate [{category}/{name}] from={source} {'OK' if ok else 'FAIL'}")
+        return 0 if ok else 1
+
+    if sub == "deactivate":
+        if not (category and name):
+            print("  用法: lbs skill deactivate <category> <name>")
+            return 1
+        ok = svc.deactivate(category, name)
+        print(f"  deactivate [{category}/{name}] {'OK' if ok else 'FAIL'}")
+        return 0 if ok else 1
+
+    if sub == "sync":
+        if sync_mode == "pull":
+            if not alias:
+                print("  用法: lbs skill sync --pull <alias>")
+                return 1
+            result = svc.pull_source(alias)
+        elif sync_mode == "remove":
+            if not alias:
+                print("  用法: lbs skill sync --remove <alias>")
+                return 1
+            result = svc.remove_source(alias)
+        else:
+            if not repo_url:
+                print("  用法: lbs skill sync <repo_url> [alias]")
+                return 1
+            result = svc.sync_source(repo_url, alias=alias)
+
+        if result.get("ok"):
+            print(f"  skill sync {result.get('action', sync_mode)} OK: alias={result.get('alias')} linked={result.get('linked', 0)} skipped={result.get('skipped', 0)}")
+            if result.get("repo_url"):
+                print(f"    repo: {result['repo_url']}")
+            return 0
+        print(f"  skill sync {sync_mode} FAIL: alias={result.get('alias', alias)} reason={result.get('reason', 'unknown')}")
+        if result.get("stderr"):
+            print(f"    stderr: {result['stderr']}")
+        if result.get("error"):
+            print(f"    error: {result['error']}")
+        return 1
+
+    print(f"  未知子命令: skill {sub}")
+    return 1

package/interfaces/cli/_impl/commands/smoke_test.py

@@ -0,0 +1,193 @@
+"""LBS Smoke Test — 真实用户场景的最小验证集。
+
+用法：
+    python -m cli.main smoke-test           # 跑全部
+    python -m cli.main smoke-test config    # 只跑配置层
+    python -m cli.main smoke-test runtime   # 跑装配层 + 编排（不需要 LLM）
+    python -m cli.main smoke-test live      # 跑需要真实 LLM 的（需要 api_key）
+
+每个测试报告 PASS / FAIL / SKIP。
+"""
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+from typing import Any
+
+
+def _ok(msg: str) -> None:
+    print(f"  ✅ {msg}")
+
+
+def _fail(msg: str) -> None:
+    print(f"  ❌ {msg}")
+
+
+def _skip(msg: str) -> None:
+    print(f"  ⏭  {msg}")
+
+
+def check_config() -> bool:
+    print("[1] 配置层")
+    from config.config import AppConfig
+    try:
+        cfg = AppConfig()
+        _ok("AppConfig 加载成功")
+    except Exception as e:
+        _fail(f"AppConfig 加载失败：{e}")
+        return False
+
+    # 检查 models.yaml（用当前项目真实注册表路径）
+    models_path = Path("runtime/core/llm/registry/models.yaml")
+    if not models_path.exists():
+        _skip(f"models.yaml 不存在（{models_path.resolve()}）")
+    else:
+        _ok(f"models.yaml: {models_path.resolve()}")
+
+    # 直接读 models.yaml 检查 api_key
+    import yaml as _yaml
+    has_key = False
+    try:
+        with open(models_path, "r", encoding="utf-8") as f:
+            spec = _yaml.safe_load(f) or {}
+        custom = spec.get("custom", {}) if isinstance(spec, dict) else {}
+        for name, p in custom.items():
+            if (p or {}).get("api_key"):
+                has_key = True
+                _ok(f"provider '{name}' 有 api_key")
+                break
+    except Exception as e:
+        _skip(f"读 models.yaml 失败：{e}")
+    if not has_key:
+        _skip("没有 provider 配置 api_key（live 测试会失败）")
+
+    return True
+
+
+def check_runtime() -> bool:
+    print("[2] 运行时装配")
+    try:
+        from application.container import AgentSystemContainer
+        from config.config import AppConfig
+        container = AgentSystemContainer(config=AppConfig())
+        _ok("Container 装配成功")
+    except Exception as e:
+        _fail(f"Container 装配失败：{e}")
+        return False
+
+    # 当前 service 列表（随架构演进增长）
+    services = [
+        "mcp_service", "model_service", "agent_service",
+        "orchestration_service", "session_service", "cron_service",
+        "tool_service", "interactive_service", "gateway_service", "skill_service",
+    ]
+    missing = []
+    for name in services:
+        if not hasattr(container, name):
+            missing.append(name)
+    if missing:
+        _fail(f"缺失 services：{missing}")
+        return False
+    _ok(f"{len(services)} 个 service 全部存在")
+
+    # Orchestrator
+    try:
+        orch = container.build_orchestrator()
+        _ok(f"Orchestrator: {type(orch).__name__}")
+    except Exception as e:
+        _fail(f"Orchestrator 装配失败：{e}")
+        return False
+
+    # RuntimeFactory
+    try:
+        factory = container.build_runtime_factory()
+        _ok(f"RuntimeFactory: {type(factory).__name__}")
+    except Exception as e:
+        _fail(f"RuntimeFactory 装配失败：{e}")
+        return False
+
+    return True
+
+
+def check_live(provider_name: str = "") -> bool:
+    print("[3] Live LLM 调用（需要 api_key）")
+    try:
+        from application.container import AgentSystemContainer
+        from config.config import AppConfig
+        # 不传 config，让 Container 自己 load_config()
+        container = AgentSystemContainer()
+        # 走 Container 的 ModelRouter 工厂，避免在 smoke_test 里直接 new ModelRouter
+        if not hasattr(container, "build_model_router"):
+            _skip("Container 没有 build_model_router（无 LLM client）")
+            return True
+        router = container.build_model_router(provider_name=provider_name) if provider_name else container.build_model_router()
+    except Exception as e:
+        _fail(f"ModelRouter 装配失败：{e}")
+        return False
+
+    client, model = router.acquire()
+    if client is None:
+        _skip("ModelRouter.acquire() 返回 None（无 key 或全熔断）")
+        return True
+    _ok(f"ModelRouter.acquire() 拿到 client, model={model}")
+
+    print("  → 发起一次最小 LLM 调用...")
+    t0 = time.time()
+    try:
+        resp = client.chat(
+            messages=[{"role": "user", "content": "say 'ok' only"}],
+            model=model,
+            max_tokens=10,
+        )
+        elapsed = time.time() - t0
+        if resp and getattr(resp, "content", ""):
+            _ok(f"LLM 调用成功 ({elapsed:.1f}s)：{resp.content[:50]}")
+            return True
+        else:
+            error = "LLM returned empty response"
+            router.report_failure(model, error)
+            _fail(f"LLM 返回空响应（{elapsed:.1f}s）")
+            return False
+    except Exception as e:
+        router.report_failure(model, str(e))
+        _fail(f"LLM 调用异常：{type(e).__name__}: {e}")
+        return False
+
+
+def main() -> int:
+    import argparse
+    import sys as _sys
+    # 把主命令（"smoke-test"）从 argv 中去掉，避免 argparse 报错
+    if len(_sys.argv) > 1 and _sys.argv[1] in ("smoke-test", "smoke"):
+        _sys.argv = [_sys.argv[0]] + _sys.argv[2:]
+    p = argparse.ArgumentParser()
+    p.add_argument("scope", nargs="?", default="offline",
+                   choices=["offline", "all", "config", "runtime", "live"])
+    p.add_argument("--provider", default="", help="测试哪个 provider（live 阶段）")
+    args = p.parse_args()
+
+    print("=" * 60)
+    print("LBS Smoke Test")
+    print("=" * 60)
+
+    results = {}
+
+    if args.scope in ("offline", "all", "config"):
+        results["config"] = check_config()
+    if args.scope in ("offline", "all", "runtime"):
+        results["runtime"] = check_runtime()
+    if args.scope in ("all", "live"):
+        results["live"] = check_live(provider_name=args.provider)
+
+    print()
+    print("=" * 60)
+    passed = sum(1 for v in results.values() if v)
+    print(f"  PASS: {passed} / {len(results)}")
+    if passed < len(results):
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())