@tencent-rtc/trtc-agent-skills 0.1.3 → 0.1.4

package/skills/trtc-ai-service/scripts/add-capability.py

@@ -0,0 +1,364 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Capability overlay CLI.
+
+Usage
+-----
+    # List discovered capability packages and their topological order
+    python scripts/add-capability.py --list
+
+    # Add capability packages to the current project (injects extensions into conversation-core by default)
+    python scripts/add-capability.py knowledge-base
+    python scripts/add-capability.py knowledge-base tool-calling --dry-run
+
+    # Render frontend / backend adapters in an external user project
+    python scripts/add-capability.py knowledge-base \
+        --target-project /path/to/user/repo \
+        --tech-stack react
+
+    # Output capability dependency graph (DOT format)
+    python scripts/add-capability.py --graph
+
+Behavior
+--------
+1. Scan all manifests under capabilities/, validate topological order, circular dependencies, version compatibility
+2. Execute manifest.extensions injection into skeleton for capability packages to be installed (dry-run by default)
+3. If --target-project is provided, invoke auto_adapters three-level degradation rendering based on tech_stack detection
+4. Output diagnostic JSON for easy Agent parsing
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+_HERE = Path(__file__).resolve().parent
+_ROOT = _HERE.parent
+sys.path.insert(0, str(_ROOT))
+
+from scripts.lib import manifest_resolver as mr
+from scripts.lib import stack_detector as sd
+from scripts.lib import degrader as dg
+from scripts.lib import injector as ij
+
+
+CAPS_ROOT = _ROOT / "capabilities"
+ADAPTERS_ROOT = _ROOT / "auto_adapters"
+SKELETON_NAME = "conversation-core"
+
+
+# ---------------------------------------------------------------------------
+# Template rendering
+# ---------------------------------------------------------------------------
+_VAR_RE = re.compile(r"\$\{([A-Z_][A-Z0-9_]*)\}")
+
+
+def render_template(text: str, variables: Dict[str, str]) -> str:
+    def _sub(m: re.Match) -> str:
+        return variables.get(m.group(1), m.group(0))
+
+    return _VAR_RE.sub(_sub, text)
+
+
+def load_yaml(path: Path) -> Dict[str, Any]:
+    import yaml
+
+    return yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+
+
+# ---------------------------------------------------------------------------
+# Install / Inject
+# ---------------------------------------------------------------------------
+@dataclass
+class InstallReport:
+    capability: str
+    skeleton_injection: List[Dict[str, Any]]
+    adapter: Optional[Dict[str, Any]] = None
+    degrade: Optional[Dict[str, Any]] = None
+    errors: List[str] = None         # type: ignore[assignment]
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "capability": self.capability,
+            "skeleton_injection": self.skeleton_injection,
+            "adapter": self.adapter,
+            "degrade": self.degrade,
+            "errors": self.errors or [],
+        }
+
+
+def inject_into_skeleton(
+    skeleton: mr.Manifest,
+    cap: mr.Manifest,
+    *,
+    dry_run: bool,
+) -> List[Dict[str, Any]]:
+    """Inject cap.extensions into corresponding skeleton files."""
+    skeleton_root = skeleton.path.parent if skeleton.path else CAPS_ROOT / SKELETON_NAME
+    cap_root = cap.path.parent if cap.path else CAPS_ROOT / cap.name
+    plans = ij.plan(
+        skeleton_root,
+        skeleton.injection_points,
+        [(cap_root, cap.extensions)],
+    )
+    results = ij.apply_plans(plans, dry_run=dry_run)
+    out = []
+    for r in results:
+        out.append(
+            {
+                "capability": cap.name,
+                "inject_at": r.plan.extension.inject_at,
+                "target": str(r.plan.target_abs_path.relative_to(_ROOT))
+                if r.plan.target_abs_path.is_relative_to(_ROOT)
+                else str(r.plan.target_abs_path),
+                "op": r.plan.op,
+                "anchor": r.plan.anchor,
+                "applied": r.applied,
+                "dry_run": r.dry_run,
+                "error": r.error,
+                "diff_preview": r.diff_preview[:200] if r.diff_preview else "",
+            }
+        )
+    return out
+
+
+def render_adapter(
+    cap: mr.Manifest,
+    target_project: Path,
+    tech_stack: Optional[str],
+    *,
+    dry_run: bool,
+) -> Dict[str, Any]:
+    """Execute auto_adapters three-level degradation rendering for an external user project."""
+    integration = cap.integration or {}
+    auto_adapters = integration.get("auto_adapters") or []
+    fallback = integration.get("fallback") or {}
+
+    # Detect tech stack (auto-detect if not provided)
+    detected = sd.detect(target_project) if not tech_stack else None
+    primary = tech_stack or (detected.primary if detected else None)
+    adapter_name = sd.match_adapter(primary or "", auto_adapters) if primary else None
+
+    artifacts: List[Dict[str, Any]] = []
+    code_gen_ok = False
+    code_gen_error = ""
+
+    if adapter_name:
+        adapter_dir = ADAPTERS_ROOT / adapter_name
+        if adapter_dir.exists():
+            try:
+                adapter_mf = load_yaml(adapter_dir / "manifest.yaml")
+                tpl_def = (adapter_mf.get("templates") or {}).get(primary)
+                if not tpl_def:
+                    code_gen_error = f"adapter '{adapter_name}' has no template for '{primary}'"
+                else:
+                    variables = _merge_variables(adapter_mf, primary)
+                    src_tpl = adapter_dir / tpl_def["file"]
+                    target_path = Path(
+                        render_template(tpl_def["target_path"], variables)
+                    )
+                    abs_target = target_project / target_path
+                    rendered = render_template(
+                        src_tpl.read_text(encoding="utf-8"), variables
+                    )
+                    if abs_target.exists() and not dry_run:
+                        # Path conflict → treated as code generation failure → degrade to L2
+                        code_gen_error = (
+                            f"target file already exists: {abs_target}, refuse to overwrite"
+                        )
+                    else:
+                        if not dry_run:
+                            abs_target.parent.mkdir(parents=True, exist_ok=True)
+                            abs_target.write_text(rendered, encoding="utf-8")
+                        artifacts.append(
+                            {
+                                "type": "rendered_file",
+                                "path": str(abs_target),
+                                "size": len(rendered),
+                                "dry_run": dry_run,
+                            }
+                        )
+                        code_gen_ok = True
+                        # Output install_hint
+                        artifacts.append(
+                            {
+                                "type": "install_hint",
+                                "content": tpl_def.get("install_hint", "").strip(),
+                                "package_dependencies": tpl_def.get("package_dependencies") or [],
+                            }
+                        )
+            except Exception as exc:  # noqa: BLE001
+                code_gen_error = f"{type(exc).__name__}: {exc}"
+
+    decision = dg.decide(
+        primary, adapter_name, code_gen_ok,
+        fallback=fallback,
+        code_gen_error=code_gen_error,
+    )
+
+    return {
+        "tech_stack_detected": detected.to_dict() if detected else None,
+        "tech_stack_used": primary,
+        "adapter": adapter_name,
+        "artifacts": artifacts,
+        "degrade": decision.to_dict(),
+    }
+
+
+def _merge_variables(adapter_mf: Dict[str, Any], tech_stack: str) -> Dict[str, str]:
+    # Priority: env > adapters/manifest.yaml.default_variables > adapter.defaults
+    top = load_yaml(ADAPTERS_ROOT / "manifest.yaml")
+    out = {}
+    out.update(top.get("default_variables") or {})
+    out.update(adapter_mf.get("defaults") or {})
+    for k in list(out.keys()):
+        if os.getenv(k):
+            out[k] = os.getenv(k, "")
+    # Force all values to str
+    return {k: str(v) for k, v in out.items()}
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+def cmd_list() -> Dict[str, Any]:
+    mfs = mr.discover_manifests(CAPS_ROOT)
+    graph = mr.resolve(mfs)
+    return {
+        "skeleton": graph.skeleton.name,
+        "topo_order": graph.order,
+        "capabilities": [
+            {
+                "name": m.name,
+                "version": m.version,
+                "type": m.type,
+                "dependencies": [{"name": d.name, "version": d.version} for d in m.dependencies],
+                "extensions_count": len(m.extensions),
+            }
+            for m in mfs
+        ],
+    }
+
+
+def cmd_graph() -> str:
+    mfs = mr.discover_manifests(CAPS_ROOT)
+    graph = mr.resolve(mfs)
+    return mr.to_dot(graph)
+
+
+def cmd_install(
+    cap_names: List[str],
+    *,
+    target_project: Optional[Path],
+    tech_stack: Optional[str],
+    dry_run: bool,
+) -> Dict[str, Any]:
+    mfs = mr.discover_manifests(CAPS_ROOT)
+    graph = mr.resolve(mfs)
+    name_set = set(cap_names)
+    unknown = [n for n in name_set if n not in graph.manifests]
+    if unknown:
+        raise SystemExit(f"unknown capabilities: {unknown}")
+    install_order = [n for n in graph.order if n in name_set]
+    reports: List[Dict[str, Any]] = []
+    for n in install_order:
+        cap = graph.manifests[n]
+        sk_inj = inject_into_skeleton(graph.skeleton, cap, dry_run=dry_run)
+        adapter_info = None
+        if target_project is not None:
+            adapter_info = render_adapter(
+                cap, target_project, tech_stack, dry_run=dry_run
+            )
+        reports.append(
+            InstallReport(
+                capability=n,
+                skeleton_injection=sk_inj,
+                adapter=adapter_info,
+                degrade=adapter_info["degrade"] if adapter_info else None,
+            ).to_dict()
+        )
+    return {
+        "skeleton": graph.skeleton.name,
+        "install_order": install_order,
+        "dry_run": dry_run,
+        "reports": reports,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Capability overlay CLI")
+    parser.add_argument("capabilities", nargs="*", help="Capability package names to install")
+    parser.add_argument("--list", action="store_true", help="List discovered capability packages")
+    parser.add_argument("--graph", action="store_true", help="Output dependency graph in DOT format")
+    parser.add_argument(
+        "--target-project", type=Path, default=None,
+        help="External user project root directory (enables auto_adapters rendering)",
+    )
+    parser.add_argument("--tech-stack", default=None, help="Override auto-detected tech stack")
+    parser.add_argument("--apply", action="store_true", help="Actually write changes (default is dry-run)")
+    parser.add_argument("--json", action="store_true", help="Output JSON for easy Agent parsing")
+    args = parser.parse_args()
+
+    if args.list:
+        out = cmd_list()
+        print(json.dumps(out, ensure_ascii=False, indent=2) if args.json else _pretty_list(out))
+        return
+    if args.graph:
+        print(cmd_graph())
+        return
+    if not args.capabilities:
+        parser.print_help()
+        return
+
+    out = cmd_install(
+        args.capabilities,
+        target_project=args.target_project,
+        tech_stack=args.tech_stack,
+        dry_run=not args.apply,
+    )
+    if args.json:
+        print(json.dumps(out, ensure_ascii=False, indent=2))
+    else:
+        print(_pretty_install(out))
+
+
+def _pretty_list(out: Dict[str, Any]) -> str:
+    lines = [f"skeleton: {out['skeleton']}", f"topo_order: {' -> '.join(out['topo_order'])}", ""]
+    for c in out["capabilities"]:
+        deps = ", ".join(f"{d['name']}@{d['version']}" for d in c["dependencies"]) or "-"
+        lines.append(f"  · {c['name']} {c['version']} [{c['type']}]  deps={deps}  extensions={c['extensions_count']}")
+    return "\n".join(lines)
+
+
+def _pretty_install(out: Dict[str, Any]) -> str:
+    lines = [
+        f"skeleton: {out['skeleton']}",
+        f"install_order: {' -> '.join(out['install_order'])}",
+        f"dry_run: {out['dry_run']}",
+        "",
+    ]
+    for r in out["reports"]:
+        lines.append(f"[{r['capability']}]")
+        for inj in r["skeleton_injection"]:
+            mark = "✓" if inj["applied"] else ("·" if not inj["error"] else "✗")
+            lines.append(
+                f"  {mark} {inj['inject_at']} -> {inj['target']} ({inj['op']}:{inj['anchor']})"
+                + (f"  err={inj['error']}" if inj["error"] else "")
+            )
+        if r.get("adapter"):
+            lines.append(
+                f"  adapter={r['adapter']['adapter']} stack={r['adapter']['tech_stack_used']} "
+                f"degrade={r['adapter']['degrade']['level']}"
+            )
+        lines.append("")
+    return "\n".join(lines)
+
+
+if __name__ == "__main__":
+    main()

package/skills/trtc-ai-service/scripts/contract-adapt.py

@@ -0,0 +1,334 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Capability contract adapter (Phase 3 Stage 4).
+
+Adapts the user's existing system interfaces (curl or OpenAPI) to the capability's default contract,
+generates ``capabilities/<name>/src/adapters/user_custom.py``, with L1/L2/L3 three-tier fallback.
+
+Usage
+-----
+    # 1) Show the current default contract for a capability
+    python3 scripts/contract-adapt.py human-handoff --show-default --json
+
+    # 2) Align a single API using a curl file
+    python3 scripts/contract-adapt.py human-handoff \
+        --api-name ticket.create \
+        --curl-file /tmp/user_create.curl \
+        --base-url https://crm.example.com \
+        --apply --json
+
+    # 3) Align an entire capability using an OpenAPI file (all outbound APIs at once)
+    python3 scripts/contract-adapt.py knowledge-base \
+        --openapi-file /tmp/user-faq.yaml \
+        --apply --json
+
+    # 4) dry-run (no files written)
+    python3 scripts/contract-adapt.py human-handoff \
+        --curl-file /tmp/x.curl --json   # omit --apply for dry-run
+
+Security Constraints
+--------------------
+- User API descriptions only accept **file paths**; inline input is not allowed (avoids shell history logging tokens)
+- Generated code is automatically backed up as ``user_custom.py.bak``
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+_HERE = Path(__file__).resolve().parent
+_ROOT = _HERE.parent
+if str(_ROOT) not in sys.path:
+    sys.path.insert(0, str(_ROOT))
+
+from scripts.lib import adapter_codegen as cg  # noqa: E402
+from scripts.lib import contract_resolver as cr  # noqa: E402
+from scripts.lib import curl_parser as cp  # noqa: E402
+from scripts.lib import openapi_parser as op  # noqa: E402
+
+
+# ---------------------------------------------------------------------------
+# Output utilities
+# ---------------------------------------------------------------------------
+def _emit(payload: Dict, json_mode: bool) -> None:
+    if json_mode:
+        sys.stdout.write(json.dumps(payload, ensure_ascii=False, indent=2))
+        sys.stdout.write("\n")
+        sys.stdout.flush()
+    else:
+        sys.stdout.write(json.dumps(payload, ensure_ascii=False, indent=2))
+        sys.stdout.write("\n")
+
+
+def _emit_error(message: str, json_mode: bool, *, code: str = "GENERAL") -> int:
+    _emit({"ok": False, "error": code, "message": message}, json_mode)
+    return 1
+
+
+# ---------------------------------------------------------------------------
+# Default contract display
+# ---------------------------------------------------------------------------
+def _show_default(contract: cr.BusinessContract, json_mode: bool) -> int:
+    payload = {
+        "ok": True,
+        "capability": contract.capability,
+        "port_class": contract.port_class,
+        "default_adapter": contract.default_adapter,
+        "mock_adapter": contract.mock_adapter,
+        "customization_sop": contract.customization_sop,
+        "outbound_apis": [
+            {
+                "name": a.name,
+                "method": a.method,
+                "path": a.path,
+                "description": a.description,
+                "request_schema": a.request_schema,
+                "response_schema": a.response_schema,
+                "adapter_slots": a.adapter_slots,
+                "auth": a.auth.to_dict(),
+                "timeout_ms": a.timeout_ms,
+            }
+            for a in contract.outbound_apis()
+        ],
+    }
+    _emit(payload, json_mode)
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# User API loading
+# ---------------------------------------------------------------------------
+def _load_user_apis(
+    *,
+    curl_file: Optional[Path],
+    openapi_file: Optional[Path],
+    api_name: Optional[str],
+) -> Tuple[List[cp.ParsedApi], List[str]]:
+    """Return (user ParsedApi list, warnings); the caller decides how to pair them with the default contract."""
+    warnings: List[str] = []
+    apis: List[cp.ParsedApi] = []
+
+    if curl_file:
+        if not curl_file.exists():
+            raise FileNotFoundError(f"curl file not found: {curl_file}")
+        text = curl_file.read_text(encoding="utf-8")
+        try:
+            apis.append(cp.parse_curl_with_response(text))
+        except cp.CurlParseError as exc:
+            raise RuntimeError(f"curl parse failed: {exc}") from exc
+
+    if openapi_file:
+        if not openapi_file.exists():
+            raise FileNotFoundError(f"openapi file not found: {openapi_file}")
+        try:
+            ops = op.parse_openapi(openapi_file)
+        except op.OpenApiParseError as exc:
+            raise RuntimeError(f"openapi parse failed: {exc}") from exc
+        if not ops:
+            warnings.append("openapi file contains no operations")
+        apis.extend(ops)
+
+    return apis, warnings
+
+
+# ---------------------------------------------------------------------------
+# pairing: match user APIs with the default contract's outbound apis
+# ---------------------------------------------------------------------------
+def _pair_apis(
+    contract: cr.BusinessContract,
+    user_apis: List[cp.ParsedApi],
+    explicit_name: Optional[str],
+) -> List[cg.ApiAdaptation]:
+    outbound = contract.outbound_apis()
+    out: List[cg.ApiAdaptation] = []
+
+    if explicit_name:
+        target = contract.get_api(explicit_name)
+        if target is None:
+            raise ValueError(f"no api named {explicit_name!r} in contract {contract.capability}")
+        # explicit name → pair with the first user api
+        if not user_apis:
+            return [cg.ApiAdaptation(default=target, user=None, diff=None)]
+        diff = cr.diff_contracts(target, user_apis[0])
+        return [cg.ApiAdaptation(default=target, user=user_apis[0], diff=diff)]
+
+    # auto pairing: match by method + path suffix similarity
+    paired: Dict[str, cp.ParsedApi] = {}
+    used: set = set()
+    for default_api in outbound:
+        match = _best_match(default_api, user_apis, used)
+        if match is not None:
+            paired[default_api.name] = match
+            used.add(id(match))
+
+    for default_api in outbound:
+        user_api = paired.get(default_api.name)
+        if user_api is None:
+            out.append(cg.ApiAdaptation(default=default_api, user=None, diff=None))
+        else:
+            diff = cr.diff_contracts(default_api, user_api)
+            out.append(cg.ApiAdaptation(default=default_api, user=user_api, diff=diff))
+    return out
+
+
+def _best_match(
+    default_api: cr.ExternalApi,
+    user_apis: List[cp.ParsedApi],
+    used: set,
+) -> Optional[cp.ParsedApi]:
+    """Simple match: method must match; best path tail similarity wins."""
+    candidates = [u for u in user_apis if id(u) not in used and u.method.upper() == default_api.method.upper()]
+    if not candidates:
+        return None
+    if len(candidates) == 1:
+        return candidates[0]
+    # best path tail semantic similarity
+    default_tail = default_api.path.rstrip("/").rsplit("/", 1)[-1] or default_api.path
+    best = candidates[0]
+    best_score = -1
+    for c in candidates:
+        c_tail = c.path.rstrip("/").rsplit("/", 1)[-1] or c.path
+        score = _similarity(default_tail, c_tail)
+        if score > best_score:
+            best_score = score
+            best = c
+    return best
+
+
+def _similarity(a: str, b: str) -> int:
+    a_low = a.lower()
+    b_low = b.lower()
+    if a_low == b_low:
+        return 100
+    if a_low in b_low or b_low in a_low:
+        return 60
+    common = set(a_low) & set(b_low)
+    return len(common)
+
+
+# ---------------------------------------------------------------------------
+# Main entry
+# ---------------------------------------------------------------------------
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="contract-adapt",
+        description="Capability contract adaptation (curl / OpenAPI → user_custom.py)",
+    )
+    parser.add_argument("capability", help="Capability name (subdirectory under capabilities/)")
+    parser.add_argument("--curl-file", type=Path, default=None, help="User API curl file path")
+    parser.add_argument(
+        "--openapi-file",
+        type=Path,
+        default=None,
+        help="User API OpenAPI YAML / JSON file path",
+    )
+    parser.add_argument(
+        "--api-name",
+        default="",
+        help="Align only the specified contract name (e.g., ticket.create); default attempts to auto-pair all outbound APIs",
+    )
+    parser.add_argument(
+        "--base-url",
+        default="",
+        help="Default base_url hint written into user_custom.py (not hardcoded)",
+    )
+    parser.add_argument(
+        "--auth-header",
+        default="",
+        help="Override auth header name (e.g., X-Auth-Token); defaults to Authorization if empty",
+    )
+    parser.add_argument(
+        "--show-default",
+        action="store_true",
+        help="Print the current default contract list without adapting",
+    )
+    parser.add_argument("--apply", action="store_true", help="Write generated code to file (default is dry-run)")
+    parser.add_argument("--json", action="store_true", help="Output JSON")
+    args = parser.parse_args(argv)
+
+    json_mode = args.json
+    cap_dir = _ROOT / "capabilities" / args.capability
+    if not cap_dir.exists():
+        return _emit_error(
+            f"capability not found: {cap_dir}", json_mode, code="CAP_NOT_FOUND"
+        )
+
+    # 1) Load default contract
+    try:
+        contract = cr.load_business_contract(cap_dir)
+    except cr.ContractError as exc:
+        return _emit_error(str(exc), json_mode, code=exc.code)
+
+    if args.show_default:
+        return _show_default(contract, json_mode)
+
+    if not args.curl_file and not args.openapi_file:
+        return _emit_error(
+            "must provide --curl-file or --openapi-file (or use --show-default)",
+            json_mode,
+            code="MISSING_INPUT",
+        )
+
+    # 2) Load user API
+    try:
+        user_apis, warnings = _load_user_apis(
+            curl_file=args.curl_file,
+            openapi_file=args.openapi_file,
+            api_name=args.api_name or None,
+        )
+    except (FileNotFoundError, RuntimeError, ValueError) as exc:
+        return _emit_error(str(exc), json_mode, code="PARSE_FAILED")
+
+    if not user_apis:
+        return _emit_error("no user API parsed", json_mode, code="EMPTY_INPUT")
+
+    # 3) Pairing & diff
+    try:
+        adaptations = _pair_apis(contract, user_apis, args.api_name or None)
+    except ValueError as exc:
+        return _emit_error(str(exc), json_mode, code="PAIRING_FAILED")
+
+    # 4) Static manifest validation (warnings only in payload)
+    manifest_warnings = cr.validate_manifest(cap_dir)
+
+    # 5) Code generation
+    result = cg.generate_user_custom(
+        contract,
+        adaptations,
+        cap_dir,
+        base_url=args.base_url,
+        auth_header=args.auth_header,
+        dry_run=not args.apply,
+    )
+
+    payload: Dict = {
+        "ok": True,
+        "capability": contract.capability,
+        "level": result.level.value,
+        "artifact": result.artifact,
+        "todos": result.todos,
+        "notes": result.notes,
+        "enable_env": result.enable_env,
+        "warnings": warnings + manifest_warnings,
+        "applied": args.apply,
+        "adaptations": [
+            {
+                "api_name": a.default.name,
+                "level": a.level.value,
+                "method_match": (a.diff.method_match if a.diff else True),
+                "path_match": (a.diff.path_match if a.diff else True),
+                "diff": a.diff.to_dict() if a.diff else None,
+                "user_api": a.user.to_dict() if a.user else None,
+            }
+            for a in adaptations
+        ],
+    }
+    _emit(payload, json_mode)
+    return 0 if result.level != cr.DegradeLevel.L3 else 0  # L3 also exits normally; AI decides next step
+
+
+if __name__ == "__main__":
+    sys.exit(main())