@tikomni/skills 0.1.0

package/skills/meta-capability/scripts/core/config_loader.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""Minimal config loader for meta-capability runtime."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple
+
+from scripts.core.tikomni_common import bootstrap_runtime_env
+
+try:
+    import yaml
+except Exception:  # pragma: no cover
+    yaml = None
+
+SKILL_ROOT = Path(__file__).resolve().parents[2]
+REPO_ROOT = SKILL_ROOT.parents[1]
+DEFAULT_CONFIG_PATH = SKILL_ROOT / "references" / "config-templates" / "defaults.yaml"
+
+BUILTIN_DEFAULT_CONFIG: Dict[str, Any] = {
+    "schema_version": "v1",
+    "profile": "default",
+    "runtime": {
+        "base_url": "https://api.tikomni.com",
+        "auth_env_key": "TIKOMNI_API_KEY",
+        "timeout_ms": 60000,
+    },
+}
+
+
+def _deep_clone(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {k: _deep_clone(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_deep_clone(item) for item in value]
+    return value
+
+
+def _deep_merge(defaults: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
+    merged = _deep_clone(defaults)
+    for key, value in override.items():
+        if isinstance(merged.get(key), dict) and isinstance(value, dict):
+            merged[key] = _deep_merge(merged[key], value)
+        else:
+            merged[key] = _deep_clone(value)
+    return merged
+
+
+def _resolve_repo_anchored_path(path_value: str) -> str:
+    candidate = Path(path_value).expanduser()
+    if not candidate.is_absolute():
+        candidate = REPO_ROOT / candidate
+    return str(candidate.resolve())
+
+
+def resolve_config_path(cli_config_path: Optional[str] = None, env_values: Optional[Dict[str, str]] = None) -> str:
+    if cli_config_path and str(cli_config_path).strip():
+        return _resolve_repo_anchored_path(str(cli_config_path).strip())
+
+    raw_env_path = ""
+    if isinstance(env_values, dict):
+        raw_env_path = str(env_values.get("TIKOMNI_CONFIG_FILE", "")).strip()
+    if not raw_env_path:
+        raw_env_path = os.getenv("TIKOMNI_CONFIG_FILE", "").strip()
+
+    if raw_env_path:
+        return _resolve_repo_anchored_path(raw_env_path)
+
+    return str(DEFAULT_CONFIG_PATH)
+
+
+def _load_yaml(path: str) -> Dict[str, Any]:
+    if yaml is None:
+        raise RuntimeError("PyYAML unavailable")
+
+    with open(path, "r", encoding="utf-8") as handle:
+        payload = yaml.safe_load(handle) or {}
+    if not isinstance(payload, dict):
+        raise ValueError(f"config_root_must_be_mapping:{path}")
+    return payload
+
+
+def _builtin_defaults() -> Dict[str, Any]:
+    return _deep_clone(BUILTIN_DEFAULT_CONFIG)
+
+
+def _read_env(name: str, env_values: Optional[Dict[str, str]] = None) -> str:
+    if isinstance(env_values, dict) and name in env_values:
+        return str(env_values.get(name, "") or "").strip()
+    return os.getenv(name, "").strip()
+
+
+def _env_int(name: str, env_values: Optional[Dict[str, str]] = None) -> Optional[int]:
+    raw = _read_env(name, env_values=env_values)
+    if not raw:
+        return None
+    try:
+        value = int(raw)
+    except Exception:
+        return None
+    return value if value > 0 else None
+
+
+def _env_text(name: str, env_values: Optional[Dict[str, str]] = None) -> Optional[str]:
+    value = _read_env(name, env_values=env_values)
+    return value or None
+
+
+def apply_env_overrides(config: Dict[str, Any], env_values: Optional[Dict[str, str]] = None) -> Dict[str, Any]:
+    runtime = config.setdefault("runtime", {}) if isinstance(config.get("runtime"), dict) else {}
+    config["runtime"] = runtime
+
+    base_url = _env_text("TIKOMNI_BASE_URL", env_values=env_values)
+    if base_url is not None:
+        runtime["base_url"] = base_url.rstrip("/")
+
+    timeout_ms = _env_int("TIKOMNI_TIMEOUT_MS", env_values=env_values)
+    if timeout_ms is not None:
+        runtime["timeout_ms"] = timeout_ms
+
+    auth_env_key = _env_text("TIKOMNI_AUTH_ENV_KEY", env_values=env_values)
+    if auth_env_key is not None:
+        runtime["auth_env_key"] = auth_env_key
+
+    return config
+
+
+def load_tikomni_config(
+    cli_config_path: Optional[str] = None,
+    env_file: Optional[str] = None,
+    allow_process_env: bool = False,
+) -> Tuple[Dict[str, Any], str]:
+    bootstrap = bootstrap_runtime_env(
+        primary_env_file=env_file,
+        allow_process_env=allow_process_env,
+    )
+    env_values = bootstrap.get("effective_env", {}) if isinstance(bootstrap, dict) else {}
+
+    explicit_config_requested = bool(
+        (cli_config_path and str(cli_config_path).strip())
+        or (isinstance(env_values, dict) and str(env_values.get("TIKOMNI_CONFIG_FILE", "")).strip())
+    )
+    path = resolve_config_path(cli_config_path, env_values=env_values if isinstance(env_values, dict) else None)
+
+    if yaml is None:
+        if explicit_config_requested:
+            raise RuntimeError(f"config_yaml_unavailable:{path}")
+        return apply_env_overrides(_builtin_defaults(), env_values=env_values), "builtin-defaults"
+
+    try:
+        loaded = _load_yaml(path)
+    except Exception:
+        if explicit_config_requested:
+            raise
+        return apply_env_overrides(_builtin_defaults(), env_values=env_values), "builtin-defaults"
+
+    merged = _deep_merge(_builtin_defaults(), loaded)
+    return apply_env_overrides(merged, env_values=env_values), path
+
+
+def config_get(config: Dict[str, Any], dotted_key: str, default: Any = None) -> Any:
+    current: Any = config
+    for key in dotted_key.split("."):
+        if not isinstance(current, dict) or key not in current:
+            return default
+        current = current[key]
+    return current
+
+
+def resolve_runtime_settings(
+    config: Dict[str, Any],
+    cli_base_url: Optional[str] = None,
+    cli_timeout_ms: Optional[int] = None,
+    cli_api_key_env: Optional[str] = None,
+) -> Dict[str, Any]:
+    runtime_config = config_get(config, "runtime", {})
+    runtime_config = runtime_config if isinstance(runtime_config, dict) else {}
+
+    base_url = str(
+        cli_base_url or runtime_config.get("base_url") or BUILTIN_DEFAULT_CONFIG["runtime"]["base_url"]
+    ).strip().rstrip("/")
+
+    raw_timeout = (
+        cli_timeout_ms
+        if cli_timeout_ms is not None
+        else runtime_config.get("timeout_ms", BUILTIN_DEFAULT_CONFIG["runtime"]["timeout_ms"])
+    )
+    try:
+        timeout_ms = int(raw_timeout)
+    except Exception:
+        timeout_ms = int(BUILTIN_DEFAULT_CONFIG["runtime"]["timeout_ms"])
+
+    api_key_env = str(
+        cli_api_key_env or runtime_config.get("auth_env_key") or BUILTIN_DEFAULT_CONFIG["runtime"]["auth_env_key"]
+    ).strip()
+    if not api_key_env:
+        api_key_env = str(BUILTIN_DEFAULT_CONFIG["runtime"]["auth_env_key"])
+
+    return {
+        "base_url": base_url,
+        "timeout_ms": timeout_ms,
+        "api_key_env": api_key_env,
+    }

package/skills/meta-capability/scripts/core/tikomni_common.py

@@ -0,0 +1,443 @@
+#!/usr/bin/env python3
+"""Minimal TikOmni auth and HTTP helpers for meta-capability."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import socket
+import threading
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+DEFAULT_BASE_URL = "https://api.tikomni.com"
+DEFAULT_TIMEOUT_MS = 60000
+DEFAULT_USER_AGENT = (
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
+    "(KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36"
+)
+DEFAULT_GLOBAL_QPS = 5.0
+DEFAULT_TIMEOUT_RETRY_MAX = 3
+DEFAULT_TIMEOUT_RETRY_BACKOFF_MS = 300
+
+_RATE_LIMIT_LOCK = threading.Lock()
+_NEXT_ALLOWED_TS = 0.0
+
+
+def _parse_env_file(env_file: Optional[str]) -> Dict[str, str]:
+    if not env_file:
+        return {}
+
+    path = Path(env_file)
+    if not path.exists() or not path.is_file():
+        return {}
+
+    parsed: Dict[str, str] = {}
+    with path.open("r", encoding="utf-8") as handle:
+        for raw_line in handle:
+            line = raw_line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            key, value = line.split("=", 1)
+            key = key.strip()
+            value = value.strip().strip('"').strip("'")
+            if key:
+                parsed[key] = value
+    return parsed
+
+
+def get_skills_root() -> Path:
+    script_path = Path(__file__).resolve()
+    return script_path.parents[3]
+
+
+def get_repo_root() -> Path:
+    return get_skills_root().parent
+
+
+def _resolve_env_file_path(env_file: Optional[str]) -> Path:
+    skills_root = get_skills_root()
+    if not env_file:
+        return (skills_root / ".env").resolve()
+
+    candidate = Path(env_file).expanduser()
+    if not candidate.is_absolute():
+        candidate = skills_root / candidate
+    return candidate.resolve()
+
+
+def _infer_default_env_paths(primary_env_file: Optional[str]) -> Tuple[Path, Path]:
+    script_path = Path(__file__).resolve()
+    skill_root = script_path.parents[2]
+
+    workspace_env = _resolve_env_file_path(primary_env_file)
+    local_env = (skill_root / ".env.local").resolve()
+    return workspace_env, local_env
+
+
+def bootstrap_runtime_env(
+    primary_env_file: Optional[str] = None,
+    allow_process_env: bool = False,
+) -> Dict[str, Any]:
+    """Load env values from skills/.env and skill/.env.local."""
+
+    process_env = dict(os.environ)
+    workspace_env_path, local_env_path = _infer_default_env_paths(primary_env_file)
+
+    base_values = _parse_env_file(str(workspace_env_path))
+    local_values = _parse_env_file(str(local_env_path))
+
+    merged: Dict[str, str] = {}
+    merged.update(base_values)
+    merged.update(local_values)
+    if allow_process_env:
+        merged.update(process_env)
+
+    os.environ.update(merged)
+
+    loaded_files: List[str] = []
+    if workspace_env_path.exists():
+        loaded_files.append(str(workspace_env_path))
+    if local_env_path.exists():
+        loaded_files.append(str(local_env_path))
+
+    key_source: Dict[str, str] = {}
+    priority = [".env.local", ".env"]
+    if allow_process_env:
+        priority.insert(0, "process_env")
+
+    all_keys = set(base_values.keys()) | set(local_values.keys())
+    if allow_process_env:
+        all_keys |= set(process_env.keys())
+
+    for key in all_keys:
+        if allow_process_env and key in process_env:
+            key_source[key] = "process_env"
+        elif key in local_values:
+            key_source[key] = ".env.local"
+        elif key in base_values:
+            key_source[key] = ".env"
+
+    return {
+        "skills_root": str(get_skills_root()),
+        "repo_root": str(get_repo_root()),
+        "workspace_env": str(workspace_env_path),
+        "local_env": str(local_env_path),
+        "loaded_files": loaded_files,
+        "key_source": key_source,
+        "priority": priority,
+        "allow_process_env": bool(allow_process_env),
+        "effective_env": merged,
+    }
+
+
+def resolve_runtime(
+    env_file: Optional[str],
+    api_key_env: str,
+    base_url: Optional[str],
+    timeout_ms: Optional[int],
+    allow_process_env: bool = False,
+) -> Dict[str, Any]:
+    bootstrap_info = bootstrap_runtime_env(
+        primary_env_file=env_file,
+        allow_process_env=allow_process_env,
+    )
+    effective_env = bootstrap_info.get("effective_env", {}) if isinstance(bootstrap_info, dict) else {}
+
+    token = str(effective_env.get(api_key_env, "") or "").strip()
+    if not token and allow_process_env:
+        token = os.getenv(api_key_env, "").strip()
+    if not token:
+        raise ValueError(
+            f"missing_api_key:{api_key_env} (set in skills/.env or meta-capability/.env.local)"
+        )
+
+    resolved_base_url = str(base_url or effective_env.get("TIKOMNI_BASE_URL") or DEFAULT_BASE_URL).strip().rstrip("/")
+    timeout_raw = timeout_ms if timeout_ms is not None else effective_env.get("TIKOMNI_TIMEOUT_MS")
+    try:
+        resolved_timeout_ms = int(timeout_raw or DEFAULT_TIMEOUT_MS)
+    except Exception:
+        resolved_timeout_ms = DEFAULT_TIMEOUT_MS
+
+    return {
+        "token": token,
+        "base_url": resolved_base_url,
+        "timeout_ms": resolved_timeout_ms,
+        "env_bootstrap": {
+            "loaded_files": bootstrap_info.get("loaded_files", []),
+            "api_key_source": bootstrap_info.get("key_source", {}).get(api_key_env, "unknown"),
+            "priority": bootstrap_info.get("priority", [".env.local", ".env"]),
+            "allow_process_env": bool(allow_process_env),
+        },
+    }
+
+
+def safe_json_loads(text: str) -> Any:
+    try:
+        return json.loads(text)
+    except Exception:
+        return {"_raw": text}
+
+
+def normalize_text(value: Any) -> str:
+    if value is None:
+        return ""
+    text = str(value)
+    text = re.sub(r"\s+", " ", text)
+    return text.strip()
+
+
+def deep_find_first(payload: Any, keys: Iterable[str]) -> Optional[Any]:
+    key_set = {str(key) for key in keys}
+
+    def _walk(node: Any) -> Optional[Any]:
+        if isinstance(node, dict):
+            for key, value in node.items():
+                if key in key_set and value not in (None, "", [], {}):
+                    return value
+            for value in node.values():
+                hit = _walk(value)
+                if hit not in (None, "", [], {}):
+                    return hit
+        elif isinstance(node, list):
+            for item in node:
+                hit = _walk(item)
+                if hit not in (None, "", [], {}):
+                    return hit
+        return None
+
+    return _walk(payload)
+
+
+def extract_request_id(payload: Any) -> Optional[str]:
+    value = deep_find_first(payload, ["request_id"])
+    if value is None:
+        return None
+    return str(value)
+
+
+def extract_error_reason(payload: Any, status_code: Optional[int] = None) -> str:
+    if isinstance(payload, dict):
+        error = payload.get("error")
+        if isinstance(error, dict):
+            code = error.get("code")
+            message = error.get("message")
+            if code:
+                return str(code)
+            if message:
+                return normalize_text(str(message)) or "unknown_error"
+
+        code = payload.get("code")
+        if code not in (None, 0, 200, "0", "200", "SUCCESS", "success"):
+            return str(code)
+
+        message = payload.get("message")
+        if isinstance(message, str) and message.strip() and message.strip().lower() not in {"ok", "success"}:
+            return normalize_text(message)
+
+    if status_code is not None:
+        return f"http_{status_code}"
+    return "unknown_error"
+
+
+def _build_url(base_url: str, path: str, params: Optional[Dict[str, Any]]) -> str:
+    normalized_path = str(path or "").strip()
+    if not normalized_path.startswith("/"):
+        normalized_path = f"/{normalized_path}"
+
+    url = f"{base_url}{normalized_path}"
+    if params:
+        normalized: Dict[str, Any] = {}
+        for key, value in params.items():
+            if value is None:
+                continue
+            normalized[key] = value
+        if normalized:
+            url = f"{url}?{urllib.parse.urlencode(normalized, doseq=True)}"
+    return url
+
+
+def _resolve_global_qps() -> float:
+    raw = str(os.getenv("TIKOMNI_GLOBAL_QPS", DEFAULT_GLOBAL_QPS)).strip()
+    try:
+        qps = float(raw)
+    except Exception:
+        qps = DEFAULT_GLOBAL_QPS
+    return max(0.1, qps)
+
+
+def _resolve_timeout_retry_max() -> int:
+    raw = str(os.getenv("TIKOMNI_TIMEOUT_RETRY_MAX", DEFAULT_TIMEOUT_RETRY_MAX)).strip()
+    try:
+        retries = int(raw)
+    except Exception:
+        retries = DEFAULT_TIMEOUT_RETRY_MAX
+    return max(0, min(retries, 8))
+
+
+def _resolve_timeout_retry_backoff_ms() -> int:
+    raw = str(os.getenv("TIKOMNI_TIMEOUT_RETRY_BACKOFF_MS", DEFAULT_TIMEOUT_RETRY_BACKOFF_MS)).strip()
+    try:
+        backoff = int(raw)
+    except Exception:
+        backoff = DEFAULT_TIMEOUT_RETRY_BACKOFF_MS
+    return max(0, min(backoff, 5000))
+
+
+def _wait_rate_limit_slot(qps: float) -> int:
+    global _NEXT_ALLOWED_TS
+    interval_sec = 1.0 / max(qps, 0.1)
+    now = time.monotonic()
+    with _RATE_LIMIT_LOCK:
+        scheduled = max(now, _NEXT_ALLOWED_TS)
+        wait_sec = max(0.0, scheduled - now)
+        _NEXT_ALLOWED_TS = scheduled + interval_sec
+
+    if wait_sec > 0:
+        time.sleep(wait_sec)
+    return int(wait_sec * 1000)
+
+
+def _is_timeout_like_failure(status_code: Optional[int], error_reason: Optional[str]) -> bool:
+    if isinstance(status_code, (int, float)) and int(status_code) in {408, 429, 502, 503, 504}:
+        return True
+
+    reason = str(error_reason or "").strip().upper()
+    if not reason:
+        return False
+    timeout_tokens = ["TIMEOUT", "TIMED_OUT", "UPSTREAM_TIMEOUT", "DEADLINE_EXCEEDED"]
+    return any(token in reason for token in timeout_tokens)
+
+
+def _execute_json_request(request: urllib.request.Request, timeout_ms: int, url: str) -> Tuple[Dict[str, Any], bool]:
+    status_code: Optional[int] = None
+    raw_text = ""
+    payload: Any = {}
+
+    try:
+        with urllib.request.urlopen(request, timeout=max(timeout_ms / 1000.0, 1.0)) as response:
+            status_code = response.getcode()
+            raw_text = response.read().decode("utf-8", errors="replace")
+            payload = safe_json_loads(raw_text)
+    except urllib.error.HTTPError as error:
+        status_code = error.code
+        raw_text = error.read().decode("utf-8", errors="replace")
+        payload = safe_json_loads(raw_text)
+    except urllib.error.URLError as error:
+        reason_obj = getattr(error, "reason", error)
+        reason_text = normalize_text(reason_obj)
+        timeout_like = isinstance(reason_obj, socket.timeout) or "timeout" in reason_text.lower()
+        error_reason = "network_error:timeout" if timeout_like else f"network_error:{reason_text or 'unknown'}"
+        return {
+            "ok": False,
+            "status_code": None,
+            "data": {},
+            "request_id": None,
+            "error_reason": error_reason,
+            "raw_text": str(error),
+            "url": url,
+        }, timeout_like
+    except (TimeoutError, socket.timeout) as error:
+        return {
+            "ok": False,
+            "status_code": None,
+            "data": {},
+            "request_id": None,
+            "error_reason": "network_error:timeout",
+            "raw_text": str(error),
+            "url": url,
+        }, True
+
+    request_id = extract_request_id(payload)
+    ok = bool(status_code is not None and 200 <= status_code < 300)
+    error_reason = None if ok else extract_error_reason(payload, status_code)
+    timeout_like = _is_timeout_like_failure(status_code, error_reason)
+
+    return {
+        "ok": ok,
+        "status_code": status_code,
+        "data": payload,
+        "request_id": request_id,
+        "error_reason": error_reason,
+        "raw_text": raw_text,
+        "url": url,
+    }, timeout_like
+
+
+def call_json_api(
+    *,
+    base_url: str,
+    path: str,
+    token: str,
+    method: str,
+    timeout_ms: int,
+    params: Optional[Dict[str, Any]] = None,
+    body: Optional[Any] = None,
+    extra_headers: Optional[Dict[str, str]] = None,
+) -> Dict[str, Any]:
+    url = _build_url(base_url, path, params)
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "User-Agent": os.getenv("TIKOMNI_HTTP_USER_AGENT", DEFAULT_USER_AGENT),
+        "Accept-Language": os.getenv("TIKOMNI_HTTP_ACCEPT_LANGUAGE", "zh-CN,zh;q=0.9,en;q=0.8"),
+    }
+    if extra_headers:
+        headers.update(extra_headers)
+
+    data: Optional[bytes] = None
+    if body is not None:
+        data = json.dumps(body, ensure_ascii=False).encode("utf-8")
+
+    request = urllib.request.Request(url=url, data=data, headers=headers, method=method.upper())
+
+    qps = _resolve_global_qps()
+    timeout_retry_max = _resolve_timeout_retry_max()
+    retry_backoff_ms = _resolve_timeout_retry_backoff_ms()
+
+    cumulative_wait_ms = 0
+    last_result: Dict[str, Any] = {
+        "ok": False,
+        "status_code": None,
+        "data": {},
+        "request_id": None,
+        "error_reason": "unknown_error",
+        "raw_text": "",
+        "url": url,
+    }
+
+    max_attempts = 1 + timeout_retry_max
+    for attempt in range(1, max_attempts + 1):
+        if attempt > 1 and retry_backoff_ms > 0:
+            sleep_ms = retry_backoff_ms * (2 ** (attempt - 2))
+            time.sleep(sleep_ms / 1000.0)
+
+        cumulative_wait_ms += _wait_rate_limit_slot(qps)
+        response, timeout_like = _execute_json_request(request=request, timeout_ms=timeout_ms, url=url)
+        response["rate_limit_wait_ms"] = cumulative_wait_ms
+        response["retry_attempt"] = max(0, attempt - 1)
+        response["timeout_retry_max"] = timeout_retry_max
+
+        if response.get("ok"):
+            response["timeout_retry_exhausted"] = False
+            return response
+
+        last_result = response
+        if timeout_like and attempt < max_attempts:
+            continue
+
+        response["timeout_retry_exhausted"] = bool(timeout_like and attempt >= max_attempts)
+        return response
+
+    last_result["timeout_retry_exhausted"] = True
+    return last_result
+
+
+def write_json_stdout(payload: Dict[str, Any]) -> None:
+    print(json.dumps(payload, ensure_ascii=False, indent=2))