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

package/skills/trtc-ai-service/scripts/lib/openapi_parser.py

@@ -0,0 +1,289 @@
+"""OpenAPI (Swagger 2 / OpenAPI 3) → ``ParsedApi`` parser.
+
+Only implements the minimal subset needed for capability contract adaptation:
+- ``info.servers[0].url`` → ``base_url``
+- ``paths.<path>.<method>`` → a set of ``ParsedApi``
+- ``$ref`` references resolved via ``components.schemas`` / ``definitions`` into type maps
+- No OpenAPI validation (no heavy dependencies like jsonschema)
+
+Supported file formats: ``.yaml`` / ``.yml`` / ``.json``.
+"""
+from __future__ import annotations
+
+import copy
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .curl_parser import AuthSpec, ParsedApi, _normalize_schema
+
+
+class OpenApiParseError(ValueError):
+    """OpenAPI 文件解析失败。"""
+
+
+# ---------------------------------------------------------------------------
+# 装载
+# ---------------------------------------------------------------------------
+def _load_file(path: Path) -> Dict[str, Any]:
+    if not path.exists():
+        raise OpenApiParseError(f"file not found: {path}")
+    text = path.read_text(encoding="utf-8")
+    if path.suffix.lower() in (".yaml", ".yml"):
+        try:
+            import yaml  # type: ignore
+        except ImportError as exc:
+            raise OpenApiParseError("PyYAML required for .yaml input") from exc
+        try:
+            data = yaml.safe_load(text)
+        except yaml.YAMLError as exc:
+            raise OpenApiParseError(f"yaml parse failed: {exc}") from exc
+    else:
+        try:
+            data = json.loads(text)
+        except json.JSONDecodeError as exc:
+            raise OpenApiParseError(f"json parse failed: {exc}") from exc
+    if not isinstance(data, dict):
+        raise OpenApiParseError("OpenAPI root must be a mapping")
+    return data
+
+
+# ---------------------------------------------------------------------------
+# $ref 解析
+# ---------------------------------------------------------------------------
+class _RefResolver:
+    def __init__(self, doc: Dict[str, Any]) -> None:
+        self.doc = doc
+        self._cache: Dict[str, Any] = {}
+        # OpenAPI 3 用 components.schemas；Swagger 2 用 definitions
+        self.components = (
+            doc.get("components", {}).get("schemas", {})
+            if isinstance(doc.get("components"), dict)
+            else {}
+        )
+        self.definitions = (
+            doc.get("definitions", {}) if isinstance(doc.get("definitions"), dict) else {}
+        )
+
+    def resolve(self, node: Any, _depth: int = 0) -> Any:
+        if _depth > 10:  # 防递归爆栈
+            return {"$ref_too_deep": True}
+        if isinstance(node, dict):
+            if "$ref" in node:
+                target = self._lookup(node["$ref"])
+                return self.resolve(target, _depth + 1)
+            return {k: self.resolve(v, _depth + 1) for k, v in node.items()}
+        if isinstance(node, list):
+            return [self.resolve(item, _depth + 1) for item in node]
+        return node
+
+    def _lookup(self, ref: str) -> Any:
+        if ref in self._cache:
+            return self._cache[ref]
+        # 仅支持本文档引用 #/...
+        if not ref.startswith("#/"):
+            return {"$ref_external": ref}
+        cur: Any = self.doc
+        for seg in ref[2:].split("/"):
+            if isinstance(cur, dict) and seg in cur:
+                cur = cur[seg]
+            else:
+                return {"$ref_unresolved": ref}
+        self._cache[ref] = cur
+        return cur
+
+
+# ---------------------------------------------------------------------------
+# Schema → 简化类型字典
+# ---------------------------------------------------------------------------
+_PRIMITIVES = {
+    "string": "string",
+    "integer": "int",
+    "number": "float",
+    "boolean": "bool",
+}
+
+
+def _schema_to_type(schema: Dict[str, Any], depth: int = 0) -> Any:
+    """把 OpenAPI schema 转成内部类型表达。"""
+    if depth > 10 or not isinstance(schema, dict):
+        return "any"
+    t = schema.get("type")
+    if t in _PRIMITIVES:
+        if "enum" in schema and isinstance(schema["enum"], list):
+            vals = ", ".join(str(v) for v in schema["enum"])
+            return f"enum[{vals}]"
+        return _PRIMITIVES[t]
+    if t == "array":
+        item_t = _schema_to_type(schema.get("items", {}) or {}, depth + 1)
+        return f"{item_t}[]" if isinstance(item_t, str) else [item_t]
+    if t == "object" or "properties" in schema:
+        out: Dict[str, Any] = {}
+        for k, v in (schema.get("properties") or {}).items():
+            out[k] = _schema_to_type(v or {}, depth + 1)
+        return out
+    # oneOf / anyOf / allOf 简化为 any
+    if any(k in schema for k in ("oneOf", "anyOf", "allOf")):
+        return "any"
+    return "any"
+
+
+# ---------------------------------------------------------------------------
+# 单 operation → ParsedApi
+# ---------------------------------------------------------------------------
+def _extract_request_schema(op: Dict[str, Any], resolver: _RefResolver) -> Dict[str, Any]:
+    schema: Dict[str, Any] = {}
+    # OpenAPI 3: requestBody.content["application/json"].schema
+    rb = op.get("requestBody")
+    if isinstance(rb, dict):
+        rb = resolver.resolve(rb)
+        content = rb.get("content", {}) if isinstance(rb, dict) else {}
+        for mime, mb in content.items():
+            if "json" in mime.lower():
+                s = mb.get("schema") if isinstance(mb, dict) else None
+                if s is not None:
+                    schema = _schema_to_type(resolver.resolve(s)) or {}
+                    if isinstance(schema, dict):
+                        return schema
+                    break
+    # Swagger 2: parameters[in=body].schema
+    for p in op.get("parameters", []) or []:
+        p = resolver.resolve(p) if isinstance(p, dict) else p
+        if isinstance(p, dict) and p.get("in") == "body":
+            s = p.get("schema")
+            if s is not None:
+                conv = _schema_to_type(resolver.resolve(s))
+                if isinstance(conv, dict):
+                    return conv
+    # 兜底：把 query/path/header 参数也合并到 request_schema
+    out: Dict[str, Any] = {}
+    for p in op.get("parameters", []) or []:
+        p = resolver.resolve(p) if isinstance(p, dict) else p
+        if not isinstance(p, dict):
+            continue
+        if p.get("in") in ("query", "path", "header"):
+            name = p.get("name")
+            if name:
+                out[name] = _schema_to_type(p.get("schema") or {"type": p.get("type", "string")})
+    return out
+
+
+def _extract_response_schema(op: Dict[str, Any], resolver: _RefResolver) -> Dict[str, Any]:
+    responses = op.get("responses") or {}
+    # 优先 200 / 201 / 2xx
+    for code in ("200", "201", "default"):
+        if code in responses:
+            r = resolver.resolve(responses[code])
+            if isinstance(r, dict):
+                # OpenAPI 3
+                content = r.get("content", {}) if isinstance(r.get("content"), dict) else {}
+                for mime, mb in content.items():
+                    if "json" in mime.lower() and isinstance(mb, dict):
+                        s = resolver.resolve(mb.get("schema") or {})
+                        conv = _schema_to_type(s)
+                        if isinstance(conv, dict):
+                            return conv
+                # Swagger 2
+                if "schema" in r:
+                    s = resolver.resolve(r["schema"])
+                    conv = _schema_to_type(s)
+                    if isinstance(conv, dict):
+                        return conv
+            break
+    return {}
+
+
+def _detect_auth_from_security(op: Dict[str, Any], doc: Dict[str, Any]) -> AuthSpec:
+    sec_defs = (
+        doc.get("components", {}).get("securitySchemes", {})
+        if isinstance(doc.get("components"), dict)
+        else doc.get("securityDefinitions", {})
+    ) or {}
+    sec = op.get("security") or doc.get("security") or []
+    for entry in sec:
+        if not isinstance(entry, dict):
+            continue
+        for name in entry.keys():
+            scheme = sec_defs.get(name) or {}
+            t = scheme.get("type", "").lower()
+            if t == "http" and scheme.get("scheme", "").lower() == "bearer":
+                return AuthSpec(type="bearer", location="header", name="Authorization")
+            if t == "apikey":
+                return AuthSpec(
+                    type="api_key",
+                    location=scheme.get("in", "header"),
+                    name=scheme.get("name", "X-API-Key"),
+                )
+            if t == "http" and scheme.get("scheme", "").lower() == "basic":
+                return AuthSpec(type="basic", location="header", name="Authorization")
+    return AuthSpec()
+
+
+def _base_url(doc: Dict[str, Any]) -> str:
+    servers = doc.get("servers") or []
+    if servers and isinstance(servers, list) and isinstance(servers[0], dict):
+        return str(servers[0].get("url", "")).rstrip("/")
+    # Swagger 2
+    host = doc.get("host", "")
+    schemes = doc.get("schemes") or ["https"]
+    base_path = doc.get("basePath", "")
+    if host:
+        return f"{schemes[0]}://{host}{base_path}".rstrip("/")
+    return ""
+
+
+# ---------------------------------------------------------------------------
+# 公共入口
+# ---------------------------------------------------------------------------
+_HTTP_METHODS = {"get", "post", "put", "delete", "patch", "head", "options"}
+
+
+def parse_openapi(
+    file_path: Path,
+    *,
+    select_path: Optional[str] = None,
+    select_method: Optional[str] = None,
+) -> List[ParsedApi]:
+    """解析 OpenAPI 文件返回所有 operation 的 ParsedApi 列表。
+
+    可用 ``select_path`` / ``select_method`` 过滤；为空时返回全部 operation。
+    """
+    doc = _load_file(Path(file_path))
+    resolver = _RefResolver(doc)
+    base = _base_url(doc)
+    paths = doc.get("paths") or {}
+    if not isinstance(paths, dict):
+        raise OpenApiParseError("OpenAPI 'paths' must be a mapping")
+
+    out: List[ParsedApi] = []
+    for path, item in paths.items():
+        if not isinstance(item, dict):
+            continue
+        if select_path and select_path != path:
+            continue
+        for method, op in item.items():
+            if method.lower() not in _HTTP_METHODS:
+                continue
+            if select_method and method.upper() != select_method.upper():
+                continue
+            if not isinstance(op, dict):
+                continue
+            api = ParsedApi(
+                method=method.upper(),
+                base_url=base,
+                path=path,
+                request_schema=_extract_request_schema(op, resolver),
+                response_schema=_extract_response_schema(op, resolver),
+                auth=_detect_auth_from_security(op, doc),
+                source="openapi",
+                body_format="json" if op.get("requestBody") or any(
+                    p.get("in") == "body" for p in (op.get("parameters") or []) if isinstance(p, dict)
+                ) else "none",
+                raw=f"openapi://{path}#{method.upper()}",
+            )
+            out.append(api)
+    if select_path and not out:
+        raise OpenApiParseError(
+            f"no operation matched: path={select_path!r}, method={select_method!r}"
+        )
+    return out

package/skills/trtc-ai-service/scripts/lib/stack_detector.py

@@ -0,0 +1,159 @@
+"""Tech stack detection.
+
+Reads signal files from the target project root and outputs standardized tech_stack labels:
+    react / vue / angular / next /
+    express / koa / fastify /
+    spring-boot / quarkus /
+    flask / fastapi / django
+
+On detection failure, primary is None; degrader decides fallback to L2 or L3.
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable, List, Optional
+
+
+_PRIORITY = [
+    "next",
+    "react",
+    "vue",
+    "angular",
+    "express",
+    "koa",
+    "fastify",
+    "spring-boot",
+    "quarkus",
+    "fastapi",
+    "flask",
+    "django",
+]
+
+
+@dataclass
+class DetectResult:
+    primary: Optional[str]
+    candidates: List[str]
+    signals: List[str]
+
+    def to_dict(self) -> dict:
+        return {
+            "primary": self.primary,
+            "candidates": self.candidates,
+            "signals": self.signals,
+        }
+
+
+def _safe_text(p: Path) -> str:
+    try:
+        return p.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return ""
+
+
+def _detect_node(project: Path, signals: List[str]) -> List[str]:
+    pkg = project / "package.json"
+    if not pkg.exists():
+        return []
+    try:
+        data = json.loads(_safe_text(pkg))
+    except json.JSONDecodeError:
+        return []
+    deps = {}
+    for k in ("dependencies", "devDependencies", "peerDependencies"):
+        deps.update(data.get(k) or {})
+    out: List[str] = []
+    mapping = {
+        "next": "next",
+        "react": "react",
+        "vue": "vue",
+        "@angular/core": "angular",
+        "express": "express",
+        "koa": "koa",
+        "fastify": "fastify",
+    }
+    for dep_key, label in mapping.items():
+        if dep_key in deps:
+            out.append(label)
+            signals.append(f"package.json:{dep_key}")
+    return out
+
+
+def _detect_java(project: Path, signals: List[str]) -> List[str]:
+    out: List[str] = []
+    pom = project / "pom.xml"
+    gradle = project / "build.gradle"
+    gradle_kts = project / "build.gradle.kts"
+    text = ""
+    for p in (pom, gradle, gradle_kts):
+        if p.exists():
+            text += _safe_text(p)
+            signals.append(p.name)
+    if "spring-boot-starter" in text or "org.springframework.boot" in text:
+        out.append("spring-boot")
+    if "quarkus-core" in text or "io.quarkus" in text:
+        out.append("quarkus")
+    return out
+
+
+def _detect_python(project: Path, signals: List[str]) -> List[str]:
+    out: List[str] = []
+    chunks: List[str] = []
+    for fname in ("requirements.txt", "pyproject.toml", "Pipfile", "setup.py"):
+        p = project / fname
+        if p.exists():
+            chunks.append(_safe_text(p).lower())
+            signals.append(fname)
+    blob = "\n".join(chunks)
+    if not blob:
+        return out
+    # Order: fastapi has higher priority than flask (some projects declare both)
+    if "fastapi" in blob:
+        out.append("fastapi")
+    if "django" in blob:
+        out.append("django")
+    if "flask" in blob:
+        out.append("flask")
+    return out
+
+
+def _ordered_unique(items: Iterable[str]) -> List[str]:
+    seen, out = set(), []
+    for x in items:
+        if x not in seen:
+            seen.add(x)
+            out.append(x)
+    return out
+
+
+def detect(project_root: Path) -> DetectResult:
+    """Run tech stack detection on the target project."""
+    project_root = Path(project_root).resolve()
+    signals: List[str] = []
+    cands: List[str] = []
+    cands += _detect_node(project_root, signals)
+    cands += _detect_java(project_root, signals)
+    cands += _detect_python(project_root, signals)
+    cands = _ordered_unique(cands)
+
+    # Select primary by _PRIORITY
+    primary: Optional[str] = None
+    for label in _PRIORITY:
+        if label in cands:
+            primary = label
+            break
+    return DetectResult(primary=primary, candidates=cands, signals=signals)
+
+
+def match_adapter(tech_stack: str, auto_adapters: list) -> Optional[str]:
+    """Find the matching adapter name in manifest.integration.auto_adapters."""
+    if not tech_stack or not auto_adapters:
+        return None
+    for entry in auto_adapters:
+        if not isinstance(entry, dict):
+            continue
+        if tech_stack in (entry.get("tech_stack") or []):
+            return entry.get("adapter")
+    return None

package/skills/trtc-ai-service/scripts/lib/tokens_compile.py

@@ -0,0 +1,204 @@
+"""tokens_compile —— compile design_tokens.json into CSS variable files.
+
+Design goals:
+- Single source of truth: design_tokens.json
+- Compiled output: scenarios/**/ui/**/tokens.css (DESIGN_GUIDELINES §9 declares these must not be hand-edited)
+- Naming aligns with DESIGN_GUIDELINES.md §2.1 CSS variable names (compact, not full flatten)
+- No third-party dependencies (no style-dictionary, etc.)
+
+Invocation:
+    python3 -m scripts.lib.tokens_compile \\
+        --src design_tokens.json \\
+        --dest scenarios/customer-service/ui/widget-floating/tokens.css \\
+        --dest scenarios/customer-service/ui/admin-board/tokens.css
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+
+_HEADER = (
+    "/*\n"
+    " * Auto-generated from design_tokens.json —— **DO NOT EDIT**\n"
+    " * Build command: python3 -m scripts.lib.tokens_compile\n"
+    " * Naming convention: see scenarios/customer-service/ui/design-system/DESIGN_GUIDELINES.md §2.1\n"
+    " */\n"
+)
+
+
+# ---------------------------------------------------------------------------
+# 命名映射：(json 路径) → (CSS 变量名)
+# 注：与 DESIGN_GUIDELINES.md §2.1 完全对齐
+# ---------------------------------------------------------------------------
+_MAP: List[Tuple[str, str]] = [
+    # color.background.*  → --color-bg-*
+    ("color.background.gradient-start", "--color-bg-gradient-start"),
+    ("color.background.gradient-end", "--color-bg-gradient-end"),
+    ("color.background.gradient", "--color-bg-gradient"),
+    ("color.background.surface", "--color-bg-surface"),
+    ("color.background.surface-strong", "--color-bg-surface-strong"),
+    ("color.background.border", "--color-bg-border"),
+    # color.brand.*       → --color-brand-*
+    ("color.brand.accent", "--color-brand-accent"),
+    # color.text.*        → --color-text-*
+    ("color.text.primary", "--color-text-primary"),
+    ("color.text.secondary", "--color-text-secondary"),
+    ("color.text.tertiary", "--color-text-tertiary"),
+    ("color.text.disabled", "--color-text-disabled"),
+    ("color.text.placeholder", "--color-text-placeholder"),
+    # color.status.*      → --color-status-*
+    ("color.status.success", "--color-status-success"),
+    ("color.status.info", "--color-status-info"),
+    ("color.status.warning", "--color-status-warning"),
+    ("color.status.error", "--color-status-error"),
+    # color.input.*       → --color-input-*
+    ("color.input.background", "--color-input-bg"),
+    ("color.input.icon-send", "--color-input-icon-send"),
+    # typography.*        → --font-family-* / --font-size-* / --font-weight-* / --line-height-*
+    ("typography.fontFamily.base", "--font-family-base"),
+    ("typography.title.fontSize", "--font-size-title"),
+    ("typography.title.fontWeight", "--font-weight-title"),
+    ("typography.title.lineHeight", "--line-height-title"),
+    ("typography.brandName.fontSize", "--font-size-brand"),
+    ("typography.brandName.fontWeight", "--font-weight-brand"),
+    ("typography.placeholder.fontSize", "--font-size-placeholder"),
+    ("typography.placeholder.fontWeight", "--font-weight-placeholder"),
+    # spacing.*           → --space-*
+    ("spacing.card-padding", "--space-card-padding"),
+    ("spacing.input-padding-x", "--space-input-padding-x"),
+    ("spacing.input-padding-y", "--space-input-padding-y"),
+    ("spacing.gap-brand-title", "--space-gap-brand-title"),
+    # radius.*            → --radius-*
+    ("radius.card", "--radius-card"),
+    ("radius.input", "--radius-input"),
+    ("radius.logo", "--radius-logo"),
+]
+
+
+# ---------------------------------------------------------------------------
+# 视觉分组（输出顺序 + 注释分隔）
+# ---------------------------------------------------------------------------
+_GROUPS: List[Tuple[str, List[str]]] = [
+    ("Background / surfaces", [
+        "--color-bg-gradient-start", "--color-bg-gradient-end", "--color-bg-gradient",
+        "--color-bg-surface", "--color-bg-surface-strong", "--color-bg-border",
+    ]),
+    ("Brand / accent", ["--color-brand-accent"]),
+    ("Text", [
+        "--color-text-primary", "--color-text-secondary", "--color-text-tertiary",
+        "--color-text-disabled", "--color-text-placeholder",
+    ]),
+    ("Status (success / info / warning / error)", [
+        "--color-status-success", "--color-status-info",
+        "--color-status-warning", "--color-status-error",
+    ]),
+    ("Input", ["--color-input-bg", "--color-input-icon-send"]),
+    ("Typography", [
+        "--font-family-base",
+        "--font-size-title", "--font-weight-title", "--line-height-title",
+        "--font-size-brand", "--font-weight-brand",
+        "--font-size-placeholder", "--font-weight-placeholder",
+    ]),
+    ("Spacing", [
+        "--space-card-padding", "--space-input-padding-x",
+        "--space-input-padding-y", "--space-gap-brand-title",
+    ]),
+    ("Radius", ["--radius-card", "--radius-input", "--radius-logo"]),
+    ("Effects", ["--effect-input-blur"]),
+]
+
+
+def _walk_json(tokens: Dict[str, Any], path: str) -> Any:
+    """按 'a.b.c' 路径取出 token 节点；返回 None 表示找不到。"""
+    cur: Any = tokens
+    for seg in path.split("."):
+        if not isinstance(cur, dict) or seg not in cur:
+            return None
+        cur = cur[seg]
+    return cur
+
+
+def _format_value(node: Dict[str, Any]) -> str:
+    """把 token 叶子节点转成 CSS 值字面量。"""
+    val = node.get("value")
+    typ = node.get("type")
+    if typ == "blur" and isinstance(val, dict) and "radius" in val:
+        return f"blur({val['radius']})"
+    return str(val)
+
+
+def compile_tokens(src: Path) -> str:
+    raw = json.loads(src.read_text(encoding="utf-8"))
+
+    # 第一遍：把 _MAP 中每个 token 的最终 CSS 值算出来
+    resolved: Dict[str, str] = {}
+    missing: List[str] = []
+    for json_path, css_name in _MAP:
+        node = _walk_json(raw, json_path)
+        if not isinstance(node, dict) or "value" not in node:
+            missing.append(json_path)
+            continue
+        resolved[css_name] = _format_value(node)
+
+    # 单独补 effect.input-blur（_format_value 已能处理 dict→blur(...) ）
+    eff_node = _walk_json(raw, "effect.input-blur")
+    if isinstance(eff_node, dict):
+        resolved["--effect-input-blur"] = _format_value(eff_node)
+
+    if missing:
+        raise SystemExit(
+            "design_tokens.json is missing the following tokens. Please add them and re-run:\n  - "
+            + "\n  - ".join(missing)
+        )
+
+    # 第二遍：按 _GROUPS 顺序输出
+    lines = [_HEADER, ":root {"]
+    first = True
+    for group_label, names in _GROUPS:
+        if not first:
+            lines.append("")
+        first = False
+        lines.append(f"  /* {group_label} */")
+        for n in names:
+            v = resolved.get(n)
+            if v is None:
+                continue
+            lines.append(f"  {n}: {v};")
+    lines.append("}")
+    lines.append("")  # 末尾换行
+    return "\n".join(lines)
+
+
+def _argparser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(description="design_tokens.json → CSS 变量")
+    p.add_argument("--src", default="design_tokens.json")
+    p.add_argument(
+        "--dest",
+        action="append",
+        required=True,
+        help="可重复，每次写一份产物",
+    )
+    return p
+
+
+def main() -> int:
+    args = _argparser().parse_args()
+    src = Path(args.src)
+    if not src.exists():
+        print(f"src not found: {src}", file=sys.stderr)
+        return 2
+    css = compile_tokens(src)
+    for dest_str in args.dest:
+        dest = Path(dest_str)
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_text(css, encoding="utf-8")
+        print(f"wrote {dest} ({len(css)} bytes)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())