@tikomni/skills 0.1.0

package/skills/single-work-analysis/scripts/core/analysis_pipeline.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Shared analysis pipeline helpers for benchmark card generation."""
+
+import json
+import os
+import re
+import subprocess
+from typing import Any, Dict, List, Optional
+
+PROMPT_CONTRACT_FILES: Dict[str, str] = {
+    "选题": "topic.md",
+    "文风": "style.md",
+    "Hook": "hook.md",
+    "结构": "structure.md",
+    "洞察分析": "insight.md",
+    "CTA": "cta.md",
+    "总结": "summary.md",
+}
+
+DEFAULT_MODULE_SECTIONS: List[str] = ["选题", "文风", "Hook", "结构"]
+DEFAULT_INSIGHT_SECTION = "洞察分析"
+
+
+def contracts_dir() -> str:
+    here = os.path.dirname(os.path.abspath(__file__))
+    return os.path.normpath(os.path.join(here, "..", "..", "references", "prompt-contracts"))
+
+
+def load_contract_prompt(filename: str) -> str:
+    path = os.path.join(contracts_dir(), filename)
+    try:
+        with open(path, "r", encoding="utf-8") as handle:
+            content = handle.read()
+    except Exception:
+        return ""
+
+    match = re.search(r"##\s*User Prompt \(Verbatim\).*?```text\n(.*?)\n```", content, flags=re.S)
+    if match:
+        return match.group(1).strip()
+    return content.strip()
+
+
+def _analysis_payload(fields: Dict[str, Any]) -> Dict[str, Any]:
+    asr_raw = fields.get("raw_content")
+    return {
+        "title": fields.get("title"),
+        "asr_raw": asr_raw,
+        "asr_clean": fields.get("asr_clean") or asr_raw,
+        "metrics": {
+            "digg_count": fields.get("digg_count"),
+            "comment_count": fields.get("comment_count"),
+            "collect_count": fields.get("collect_count"),
+            "share_count": fields.get("share_count"),
+            "play_count": fields.get("play_count"),
+        },
+    }
+
+
+def call_prompt_llm(section: str, prompt_text: str, fields: Dict[str, Any], timeout_sec: int = 240) -> str:
+    if not prompt_text:
+        return "数据不足"
+
+    message = (
+        f"请严格根据下面提示词原文完成【{section}】段落输出。\n"
+        "要求：\n"
+        "1) 不要解释提示词，不要输出思考过程。\n"
+        "2) 不要套额外模板，不要输出打分。\n"
+        "3) 仅输出该段正文内容。\n\n"
+        "=== 提示词原文开始 ===\n"
+        f"{prompt_text}\n"
+        "=== 提示词原文结束 ===\n\n"
+        "=== 输入数据(JSON) ===\n"
+        f"{json.dumps(_analysis_payload(fields), ensure_ascii=False)}"
+    )
+
+    try:
+        run = subprocess.run(
+            ["openclaw", "agent", "--agent", "main", "--message", message, "--json"],
+            capture_output=True,
+            text=True,
+            timeout=timeout_sec,
+            check=False,
+        )
+        data = json.loads(run.stdout or "{}")
+        texts: List[str] = []
+        for payload in data.get("result", {}).get("payloads", []):
+            text = payload.get("text") if isinstance(payload, dict) else None
+            if isinstance(text, str) and text.strip():
+                texts.append(text.strip())
+        if texts:
+            return "\n".join(texts).strip()
+    except Exception:
+        pass
+
+    return "数据不足"
+
+
+def build_module_lines(
+    fields: Dict[str, Any],
+    sections: Optional[List[str]] = None,
+    contract_files: Optional[Dict[str, str]] = None,
+) -> Dict[str, List[str]]:
+    picked_sections = sections or DEFAULT_MODULE_SECTIONS
+    mapping = contract_files or PROMPT_CONTRACT_FILES
+    outputs: Dict[str, List[str]] = {}
+
+    for section in picked_sections:
+        prompt_text = load_contract_prompt(mapping.get(section, ""))
+        content = call_prompt_llm(section, prompt_text, fields)
+        outputs[section] = [content if content else "数据不足"]
+
+    return outputs
+
+
+def build_single_section_lines(
+    fields: Dict[str, Any],
+    section: str = DEFAULT_INSIGHT_SECTION,
+    contract_files: Optional[Dict[str, str]] = None,
+) -> List[str]:
+    mapping = contract_files or PROMPT_CONTRACT_FILES
+    prompt_text = load_contract_prompt(mapping.get(section, ""))
+    content = call_prompt_llm(section, prompt_text, fields)
+    return [content if content else "数据不足"]
+
+
+def build_analysis_sections(fields: Dict[str, Any]) -> Dict[str, Any]:
+    """Build prompt-contract-driven analysis sections for benchmark cards."""
+    modules = build_module_lines(fields)
+    insight = build_single_section_lines(fields, section=DEFAULT_INSIGHT_SECTION)
+    return {
+        "modules": modules,
+        "insight": insight,
+    }

package/skills/single-work-analysis/scripts/core/bootstrap_env.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""Shared bootstrap utilities for direct script execution."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+
+def _locate_repo_root(file_path: str) -> Optional[Path]:
+    current = Path(file_path).resolve()
+    for parent in current.parents:
+        if (parent / "scripts").is_dir():
+            return parent
+    return None
+
+
+def bootstrap_for_direct_run(file_path: str, package: Optional[str] = None) -> Optional[str]:
+    """Inject repo root into sys.path when executed as a direct script path.
+
+    Returns the injected repo-root string on success, otherwise ``None``.
+    """
+
+    if package not in {None, ""}:
+        return None
+
+    repo_root = _locate_repo_root(file_path)
+    if repo_root is None:
+        return None
+
+    repo_root_str = str(repo_root)
+    if repo_root_str not in sys.path:
+        sys.path.insert(0, repo_root_str)
+    return repo_root_str

package/skills/single-work-analysis/scripts/core/config_loader.py

@@ -0,0 +1,418 @@
+#!/usr/bin/env python3
+"""Lightweight config loader for Tikomni scripts (Phase 1 skeleton)."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from scripts.core.tikomni_common import bootstrap_runtime_env
+
+try:
+    import yaml
+except Exception:  # pragma: no cover - defensive fallback
+    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,
+    },
+    "storage_routes": {
+        "default": {
+            "root_dir": "",
+            "runs_dir": "_runs",
+            "results_dir": "results",
+            "errors_dir": "_errors",
+        },
+        "content_kind_card_type": {
+            "single_video": "work",
+            "work": "work",
+            "author_home": "author_sample_work",
+            "author_sample_work": "author_sample_work",
+            "author_analysis": "author",
+        },
+        "card_type_routes": {
+            "work": {
+                "prefix": "CBV",
+                "parts": ["内容系统", "对标研究", "作品卡"],
+            },
+            "author": {
+                "prefix": "CBA",
+                "parts": ["内容系统", "对标研究", "作者卡"],
+            },
+            "author_sample_work": {
+                "prefix": "CBV",
+                "parts": ["内容系统", "对标研究", "作者样本卡", "{platform}-{author_slug}"],
+            },
+        },
+    },
+    "naming_rules": {
+        "card_filename_pattern": "{prefix}-{author_slug}-{title_slug}{ext}",
+        "json_filename_pattern": "{timestamp}-{platform}-{identifier}{ext}",
+    },
+    "asr_strategy": {
+        "poll_interval_sec": 3.0,
+        "max_polls": 30,
+        "submit_retry": {
+            "douyin_video": {"max_retries": 2, "backoff_ms": 1500},
+            "xiaohongshu_note": {"max_retries": 0, "backoff_ms": 0},
+        },
+        "u2_timeout_retry": {
+            "enabled": True,
+            "max_retries": 3,
+        },
+        "author_home": {
+            "batch_submit_size": 50,
+        },
+    },
+}
+
+LOCALE_ROUTE_PRESETS: Dict[str, Dict[str, Dict[str, Any]]] = {
+    "zh": {
+        "work": {
+            "prefix": "CBV",
+            "parts": ["内容系统", "对标研究", "作品卡"],
+        },
+        "author": {
+            "prefix": "CBA",
+            "parts": ["内容系统", "对标研究", "作者卡"],
+        },
+        "author_sample_work": {
+            "prefix": "CBV",
+            "parts": ["内容系统", "对标研究", "作者样本卡", "{platform}-{author_slug}"],
+        },
+    },
+    "en": {
+        "work": {
+            "prefix": "CBV",
+            "parts": ["content-system", "benchmark-research", "work-cards"],
+        },
+        "author": {
+            "prefix": "CBA",
+            "parts": ["content-system", "benchmark-research", "author-cards"],
+        },
+        "author_sample_work": {
+            "prefix": "CBV",
+            "parts": [
+                "content-system",
+                "benchmark-research",
+                "author-sample-cards",
+                "{platform}-{author_slug}",
+            ],
+        },
+    },
+}
+
+CARD_ROUTE_ENV_KEYS: Dict[str, str] = {
+    "work": "TIKOMNI_CARD_ROUTE_WORK",
+    "author": "TIKOMNI_CARD_ROUTE_AUTHOR",
+    "author_sample_work": "TIKOMNI_CARD_ROUTE_AUTHOR_SAMPLE_WORK",
+}
+
+CARD_PREFIX_ENV_KEYS: Dict[str, str] = {
+    "work": "TIKOMNI_CARD_PREFIX_WORK",
+    "author": "TIKOMNI_CARD_PREFIX_AUTHOR",
+    "author_sample_work": "TIKOMNI_CARD_PREFIX_AUTHOR_SAMPLE_WORK",
+}
+
+
+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:
+    """Resolve config file path with priority:
+    1) --config
+    2) TIKOMNI_CONFIG_FILE
+    3) references/config-templates/defaults.yaml
+
+    Relative paths are always anchored at repository root (not current CWD).
+    """
+
+    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 _require_absolute_env(name: str, env_values: Optional[Dict[str, str]] = None) -> str:
+    value = _env_text(name, env_values=env_values)
+    if value is None:
+        raise ValueError(f"{name} is required and must be an absolute path")
+    return _require_absolute_path(value, name)
+
+
+def _route_from_env(value: str) -> Optional[List[str]]:
+    parts = [item.strip() for item in value.split("|")]
+    normalized = [item for item in parts if item]
+    return normalized if normalized else None
+
+
+def _normalize_path_locale(raw_value: Optional[str]) -> str:
+    value = (raw_value or "").strip().lower()
+    if value in LOCALE_ROUTE_PRESETS:
+        return value
+    return "zh"
+
+
+def _require_absolute_path(path_value: str, env_key: str) -> str:
+    candidate = Path(path_value).expanduser()
+    if not candidate.is_absolute():
+        raise ValueError(f"{env_key} must be an absolute path")
+    return str(candidate.resolve())
+
+
+def resolve_storage_paths(config: Dict[str, Any]) -> Dict[str, str]:
+    """Resolve storage directories from an explicit absolute root (never CWD)."""
+
+    default_route = config_get(config, "storage_routes.default", {})
+    default_route = default_route if isinstance(default_route, dict) else {}
+
+    root_dir = Path(
+        _require_absolute_path(str(default_route.get("root_dir") or ""), "TIKOMNI_OUTPUT_ROOT")
+    )
+
+    resolved: Dict[str, str] = {
+        "root_dir": str(root_dir),
+    }
+    for key in ("runs_dir", "results_dir", "errors_dir"):
+        raw_value = str(default_route.get(key) or "").strip()
+        if not raw_value:
+            raw_value = {
+                "runs_dir": "_runs",
+                "results_dir": "results",
+                "errors_dir": "_errors",
+            }[key]
+
+        part = Path(raw_value).expanduser()
+        if part.is_absolute():
+            resolved[key] = str(part.resolve())
+        else:
+            resolved[key] = str((root_dir / part).resolve())
+
+    resolved["runs_root"] = resolved.get("runs_dir", str((root_dir / "_runs").resolve()))
+    resolved["results_root"] = resolved.get("results_dir", str((root_dir / "results").resolve()))
+    resolved["errors_root"] = resolved.get("errors_dir", str((root_dir / "_errors").resolve()))
+    return resolved
+
+
+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
+
+    storage_routes = config.setdefault("storage_routes", {}) if isinstance(config.get("storage_routes"), dict) else {}
+    config["storage_routes"] = storage_routes
+
+    default_route = storage_routes.setdefault("default", {}) if isinstance(storage_routes.get("default"), dict) else {}
+    storage_routes["default"] = default_route
+
+    card_type_routes = (
+        storage_routes.setdefault("card_type_routes", {}) if isinstance(storage_routes.get("card_type_routes"), dict) else {}
+    )
+    storage_routes["card_type_routes"] = card_type_routes
+
+    naming_rules = config.setdefault("naming_rules", {}) if isinstance(config.get("naming_rules"), dict) else {}
+    config["naming_rules"] = naming_rules
+
+    timeout_ms = _env_int("TIKOMNI_TIMEOUT_MS", env_values=env_values)
+    if timeout_ms is not None:
+        runtime["timeout_ms"] = timeout_ms
+
+    default_route["root_dir"] = _require_absolute_env("TIKOMNI_OUTPUT_ROOT", env_values=env_values)
+
+    for env_key, config_key in {
+        "TIKOMNI_OUTPUT_RUNS_DIR": "runs_dir",
+        "TIKOMNI_OUTPUT_RESULTS_DIR": "results_dir",
+        "TIKOMNI_OUTPUT_ERRORS_DIR": "errors_dir",
+    }.items():
+        value = _env_text(env_key, env_values=env_values)
+        if value is not None:
+            default_route[config_key] = value
+
+    card_filename_pattern = _env_text("TIKOMNI_FILENAME_PATTERN_CARD", env_values=env_values)
+    json_filename_pattern = _env_text("TIKOMNI_FILENAME_PATTERN_JSON", env_values=env_values)
+    legacy_filename_pattern = _env_text("TIKOMNI_FILENAME_PATTERN", env_values=env_values)
+    if card_filename_pattern is not None:
+        naming_rules["card_filename_pattern"] = card_filename_pattern
+    elif legacy_filename_pattern is not None:
+        naming_rules["card_filename_pattern"] = legacy_filename_pattern
+    if json_filename_pattern is not None:
+        naming_rules["json_filename_pattern"] = json_filename_pattern
+
+    path_locale = _normalize_path_locale(_read_env("TIKOMNI_PATH_LOCALE", env_values=env_values) or "zh")
+    locale_routes = LOCALE_ROUTE_PRESETS.get(path_locale, LOCALE_ROUTE_PRESETS["zh"])
+
+    for route_key, route_value in locale_routes.items():
+        existing = card_type_routes.get(route_key)
+        existing_prefix = ""
+        existing_parts: List[str] = []
+        if isinstance(existing, dict):
+            if isinstance(existing.get("prefix"), str):
+                existing_prefix = existing.get("prefix", "").strip()
+            if isinstance(existing.get("parts"), list) and existing.get("parts"):
+                existing_parts = [str(item) for item in existing.get("parts", []) if str(item).strip()]
+
+        card_type_routes[route_key] = {
+            "prefix": existing_prefix or str(route_value.get("prefix") or ""),
+            "parts": existing_parts or _deep_clone(route_value.get("parts", [])),
+        }
+
+    for route_key, env_name in CARD_ROUTE_ENV_KEYS.items():
+        raw_value = _env_text(env_name, env_values=env_values)
+        if raw_value is None:
+            continue
+
+        env_parts = _route_from_env(raw_value)
+        if not env_parts:
+            continue
+
+        current = card_type_routes.get(route_key)
+        prefix = ""
+        if isinstance(current, dict) and isinstance(current.get("prefix"), str):
+            prefix = current.get("prefix") or ""
+        if not prefix:
+            prefix = LOCALE_ROUTE_PRESETS["zh"].get(route_key, {}).get("prefix", "")
+
+        card_type_routes[route_key] = {
+            "prefix": prefix,
+            "parts": env_parts,
+        }
+
+    for route_key, env_name in CARD_PREFIX_ENV_KEYS.items():
+        prefix_value = _env_text(env_name, env_values=env_values)
+        if prefix_value is None:
+            continue
+        current = card_type_routes.get(route_key)
+        current_parts: List[str] = []
+        if isinstance(current, dict) and isinstance(current.get("parts"), list):
+            current_parts = [str(item) for item in current.get("parts", []) if str(item).strip()]
+        if not current_parts:
+            current_parts = list(LOCALE_ROUTE_PRESETS["zh"].get(route_key, {}).get("parts", []))
+        card_type_routes[route_key] = {
+            "prefix": prefix_value,
+            "parts": current_parts,
+        }
+
+    resolved_storage = resolve_storage_paths(config)
+    for key, value in resolved_storage.items():
+        default_route[key] = value
+
+    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