@tikomni/skills 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tikomni/skills",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "TikOmni skill installer CLI for Codex, Claude Code, and OpenClaw",
   "license": "MIT",
   "homepage": "https://github.com/mark-ly-wang/TikOmni-Skills#readme",
@@ -13,7 +13,9 @@
   "files": [
     "bin/",
     "lib/",
-    "skills/",
+    "skills/creator-analysis/",
+    "skills/meta-capability/",
+    "skills/single-work-analysis/",
     ".skill-package-allowlist.txt",
     "env.example",
     "README.md",

package/skills/single-work-analysis/env.example

@@ -23,9 +23,9 @@ TIKOMNI_PATH_LOCALE="zh"
 # [EN] Work card filename prefix. Default: CBV
 TIKOMNI_CARD_PREFIX_WORK="CBV"
 
-# [ZH] 卡片文件名模板。默认值：{prefix}-{author_slug}-{title_slug}{ext}
-# [EN] Card filename pattern. Default: {prefix}-{author_slug}-{title_slug}{ext}
-TIKOMNI_FILENAME_PATTERN_CARD="{prefix}-{author_slug}-{title_slug}{ext}"
+# [ZH] 卡片文件名模板。默认值：{prefix}-{platform}-{author_slug}-{title_slug}{ext}
+# [EN] Card filename pattern. Default: {prefix}-{platform}-{author_slug}-{title_slug}{ext}
+TIKOMNI_FILENAME_PATTERN_CARD="{prefix}-{platform}-{author_slug}-{title_slug}{ext}"
 
 # [ZH] JSON 文件名模板。默认值：{timestamp}-{platform}-{identifier}{ext}
 # [EN] JSON filename pattern. Default: {timestamp}-{platform}-{identifier}{ext}

package/skills/single-work-analysis/references/config-templates/defaults.yaml

@@ -14,10 +14,8 @@ storage_routes:
     errors_dir: "_errors"
   content_kind_card_type:
     single_video: work
+    note: work
     work: work
-    author_home: author_sample_work
-    author_sample_work: author_sample_work
-    author_analysis: author
   card_type_routes:
     work:
       prefix: "CBV"
@@ -25,27 +23,18 @@ storage_routes:
         - "内容系统"
         - "对标研究"
         - "作品卡"
-    author:
-      prefix: "CBA"
-      parts:
-        - "内容系统"
-        - "对标研究"
-        - "作者卡"
-    author_sample_work:
-      prefix: "CBV"
-      parts:
-        - "内容系统"
-        - "对标研究"
-        - "作者样本卡"
-        - "{platform}-{author_slug}"
 
 naming_rules:
-  card_filename_pattern: "{prefix}-{author_slug}-{title_slug}{ext}"
+  card_filename_pattern: "{prefix}-{platform}-{author_slug}-{title_slug}{ext}"
   json_filename_pattern: "{timestamp}-{platform}-{identifier}{ext}"
 
+analysis:
+  provider: auto
+  timeout_sec: 90
+
 asr_strategy:
   poll_interval_sec: 3.0
-  max_polls: 30
+  max_polls: 10
   submit_retry:
     douyin_video:
       max_retries: 2
@@ -55,4 +44,4 @@ asr_strategy:
       backoff_ms: 0
   u2_timeout_retry:
     enabled: true
-    max_retries: 3
+    max_retries: 0

package/skills/single-work-analysis/references/prompt-contracts/{insight.md → analysis-bundle.md}

@@ -1,4 +1,4 @@
-# Prompt Contract · 洞察分析（insight）
+# Prompt Contract · 单次结构化作品分析（analysis-bundle）
 
 ## User Prompt (Verbatim)
 
@@ -32,16 +32,51 @@
 === 终极使命 ===
 帮助创作者建立"爆款直觉"——
 不是教他们追逐每一个热点，而是理解什么样的内容天生具有传播基因。
+
+任务：
+基于输入数据，一次性输出 5 个字段：
+- topic
+- style
+- hook
+- structure
+- insight
+
+输出要求：
+1. 只输出一个 JSON 对象，不要输出 markdown，不要输出解释。
+2. 每个字段的值必须是字符串数组。
+3. 中文输出。
+4. 缺少数据时直接写“数据不足”。
+5. 只能基于输入字段推断，不得臆造事实。
+
+JSON schema:
+{
+  "topic": ["..."],
+  "style": ["..."],
+  "hook": ["..."],
+  "structure": ["..."],
+  "insight": ["..."]
+}
+
+字段约束：
+- topic：聚焦选题类型、细分主题、受众痛点
+- style：聚焦句式、语气、人设表达
+- hook：聚焦开头、中段、结尾钩子
+- structure：聚焦结构标签、模板、缺失模块
+- insight：聚焦情绪共振点/认知势能差/社交货币值/行动驱动力
+必须保证表达方式和分析美学的要求，而不是因为格式约束为了精炼而精炼
 ```
 
 ## Inputs
+- `platform`
 - `title`
-- `asr_raw`（优先）
-- `raw_content`（`asr_raw` 缺失时回退）
-- `asr_clean`（遗留兼容字段）
-- 指标：`digg_count/comment_count/collect_count/share_count/play_count`
+- `caption_raw`
+- `asr_raw`
+- `asr_clean`
+- `work_modality`
+- `tags`
+- `metrics`
 
 ## Constraints
-- 仅基于输入字段推断，不得臆造事实。
-- 输出为中文，短句、可执行、可追溯。
-- 缺数据时明确标注“数据不足”。
+- 不得输出思维链。
+- 不得引用未提供的外部知识。
+- 若输入文本稀缺，允许多处返回“数据不足”。

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

@@ -0,0 +1,384 @@
+#!/usr/bin/env python3
+"""Host adapters for single-work structured analysis."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import signal
+import shutil
+import subprocess
+import tempfile
+import time
+from typing import Any, Dict, List, Optional, Tuple
+
+from scripts.core.progress_report import ProgressReporter
+
+
+SUPPORTED_PROVIDERS = {"auto", "openclaw", "claude_code", "codex", "local"}
+DEFAULT_PROVIDER_ORDER = ["openclaw", "claude_code", "codex"]
+
+
+def normalize_provider(value: Any) -> str:
+    text = str(value or "").strip().lower().replace("-", "_")
+    return text if text in SUPPORTED_PROVIDERS else "auto"
+
+
+def resolve_preferred_provider(config: Optional[Dict[str, Any]] = None) -> str:
+    env_value = os.getenv("TIKOMNI_ANALYSIS_PROVIDER", "").strip()
+    configured = ""
+    if isinstance(config, dict):
+        configured = str(config.get("provider") or "").strip()
+    return normalize_provider(configured or env_value or "auto")
+
+
+def resolve_analysis_timeout(config: Optional[Dict[str, Any]] = None, default: int = 30) -> int:
+    env_value = os.getenv("TIKOMNI_ANALYSIS_TIMEOUT_SEC", "").strip()
+    raw_value = env_value
+    if isinstance(config, dict) and str(config.get("timeout_sec") or "").strip():
+        raw_value = str(config.get("timeout_sec")).strip()
+    try:
+        parsed = int(raw_value or default)
+    except Exception:
+        parsed = default
+    return max(5, min(parsed, 90))
+
+
+def is_provider_available(provider: str) -> bool:
+    normalized = normalize_provider(provider)
+    if normalized == "openclaw":
+        return bool(shutil.which("openclaw"))
+    if normalized == "claude_code":
+        return bool(shutil.which("claude"))
+    if normalized == "codex":
+        return bool(shutil.which("codex"))
+    if normalized == "local":
+        return True
+    return False
+
+
+def choose_provider(preferred: str) -> Tuple[str, List[str]]:
+    normalized = normalize_provider(preferred)
+    if normalized == "local":
+        return "local", []
+    if normalized != "auto":
+        return normalized, [normalized]
+
+    available = [provider for provider in DEFAULT_PROVIDER_ORDER if is_provider_available(provider)]
+    if available:
+        return available[0], available
+    return "local", []
+
+
+def _extract_json_object(text: str) -> Dict[str, Any]:
+    candidate = str(text or "").strip()
+    if not candidate:
+        return {}
+
+    fenced = re.search(r"```(?:json)?\s*(\{.*\})\s*```", candidate, flags=re.S)
+    if fenced:
+        candidate = fenced.group(1).strip()
+
+    try:
+        parsed = json.loads(candidate)
+        return parsed if isinstance(parsed, dict) else {}
+    except Exception:
+        pass
+
+    start = candidate.find("{")
+    end = candidate.rfind("}")
+    if start >= 0 and end > start:
+        try:
+            parsed = json.loads(candidate[start : end + 1])
+            return parsed if isinstance(parsed, dict) else {}
+        except Exception:
+            return {}
+    return {}
+
+
+def _extract_openclaw_text(stdout: str) -> str:
+    payload = _extract_json_object(stdout)
+    texts: List[str] = []
+    result = payload.get("result")
+    payloads = result.get("payloads", []) if isinstance(result, dict) else []
+    for item in payloads:
+        if not isinstance(item, dict):
+            continue
+        text = str(item.get("text") or "").strip()
+        if text:
+            texts.append(text)
+    return "\n".join(texts).strip()
+
+
+def _run_command(
+    *,
+    cmd: List[str],
+    provider: str,
+    operation: str,
+    timeout_sec: int,
+    progress: Optional[ProgressReporter],
+    output_file: Optional[str] = None,
+) -> Dict[str, Any]:
+    started_at = time.perf_counter()
+    if progress is not None:
+        progress.subprocess_event(
+            stage="analysis.host",
+            provider=provider,
+            operation=operation,
+            event="started",
+        )
+
+    try:
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            start_new_session=True,
+        )
+    except Exception as error:
+        duration_ms = int((time.perf_counter() - started_at) * 1000)
+        if progress is not None:
+            progress.subprocess_event(
+                stage="analysis.host",
+                provider=provider,
+                operation=operation,
+                event="failed",
+                duration_ms=duration_ms,
+                summary={"error_reason": f"spawn_failed:{error}"},
+            )
+        return {
+            "ok": False,
+            "provider": provider,
+            "duration_ms": duration_ms,
+            "exit_code": None,
+            "stdout": "",
+            "stderr": "",
+            "error_reason": f"spawn_failed:{error}",
+        }
+
+    heartbeat_sec = 5.0
+    stdout = ""
+    stderr = ""
+    exit_code: Optional[int] = None
+    error_reason = ""
+
+    while True:
+        elapsed = time.perf_counter() - started_at
+        remaining = float(timeout_sec) - elapsed
+        if remaining <= 0:
+            try:
+                os.killpg(process.pid, signal.SIGKILL)
+            except Exception:
+                try:
+                    process.kill()
+                except Exception:
+                    pass
+            stdout, stderr = process.communicate()
+            exit_code = process.returncode
+            error_reason = "analysis_timeout"
+            break
+        try:
+            stdout, stderr = process.communicate(timeout=min(heartbeat_sec, remaining))
+            exit_code = process.returncode
+            break
+        except subprocess.TimeoutExpired:
+            if progress is not None:
+                progress.heartbeat(
+                    stage="analysis.host",
+                    message="analysis subprocess still running",
+                    data={
+                        "provider": provider,
+                        "operation": operation,
+                        "elapsed_ms": int((time.perf_counter() - started_at) * 1000),
+                    },
+                )
+
+    duration_ms = int((time.perf_counter() - started_at) * 1000)
+    if not error_reason and int(exit_code or 0) != 0:
+        error_reason = f"subprocess_exit_{exit_code}"
+
+    if output_file and os.path.isfile(output_file):
+        try:
+            stdout = open(output_file, "r", encoding="utf-8").read()
+        except Exception:
+            pass
+
+    if progress is not None:
+        progress.subprocess_event(
+            stage="analysis.host",
+            provider=provider,
+            operation=operation,
+            event="done" if not error_reason else "failed",
+            duration_ms=duration_ms,
+            exit_code=exit_code,
+            summary={
+                "error_reason": error_reason or None,
+                "stdout_len": len(stdout or ""),
+                "stderr_len": len(stderr or ""),
+            },
+        )
+
+    return {
+        "ok": not bool(error_reason),
+        "provider": provider,
+        "duration_ms": duration_ms,
+        "exit_code": exit_code,
+        "stdout": stdout,
+        "stderr": stderr,
+        "error_reason": error_reason or None,
+    }
+
+
+def _build_message(prompt_text: str, payload: Dict[str, Any]) -> str:
+    return (
+        "请严格执行下面的提示词契约，输出唯一 JSON 对象，不要输出 markdown 代码块，不要输出解释。\n\n"
+        "=== 提示词契约 ===\n"
+        f"{prompt_text}\n\n"
+        "=== 输入数据(JSON) ===\n"
+        f"{json.dumps(payload, ensure_ascii=False)}"
+    )
+
+
+def _run_openclaw(
+    *,
+    prompt_text: str,
+    payload: Dict[str, Any],
+    timeout_sec: int,
+    progress: Optional[ProgressReporter],
+) -> Dict[str, Any]:
+    result = _run_command(
+        cmd=[
+            "openclaw",
+            "agent",
+            "--agent",
+            "main",
+            "--message",
+            _build_message(prompt_text, payload),
+            "--json",
+        ],
+        provider="openclaw",
+        operation="structured_analysis",
+        timeout_sec=timeout_sec,
+        progress=progress,
+    )
+    result["raw_text"] = _extract_openclaw_text(result.get("stdout", ""))
+    return result
+
+
+def _run_codex(
+    *,
+    prompt_text: str,
+    payload: Dict[str, Any],
+    timeout_sec: int,
+    progress: Optional[ProgressReporter],
+) -> Dict[str, Any]:
+    output_file = tempfile.NamedTemporaryFile(prefix="single-work-analysis-", suffix=".txt", delete=False)
+    output_path = output_file.name
+    output_file.close()
+    try:
+        result = _run_command(
+            cmd=[
+                "codex",
+                "exec",
+                "--skip-git-repo-check",
+                "-o",
+                output_path,
+                _build_message(prompt_text, payload),
+            ],
+            provider="codex",
+            operation="structured_analysis",
+            timeout_sec=timeout_sec,
+            progress=progress,
+            output_file=output_path,
+        )
+        result["raw_text"] = str(result.get("stdout") or "").strip()
+        return result
+    finally:
+        try:
+            os.unlink(output_path)
+        except Exception:
+            pass
+
+
+def _run_claude_code(
+    *,
+    prompt_text: str,
+    payload: Dict[str, Any],
+    timeout_sec: int,
+    progress: Optional[ProgressReporter],
+) -> Dict[str, Any]:
+    result = _run_command(
+        cmd=["claude", "-p", _build_message(prompt_text, payload)],
+        provider="claude_code",
+        operation="structured_analysis",
+        timeout_sec=timeout_sec,
+        progress=progress,
+    )
+    result["raw_text"] = str(result.get("stdout") or "").strip()
+    return result
+
+
+def run_structured_analysis(
+    *,
+    prompt_text: str,
+    payload: Dict[str, Any],
+    provider: str,
+    timeout_sec: int,
+    progress: Optional[ProgressReporter] = None,
+) -> Dict[str, Any]:
+    preferred = normalize_provider(provider)
+    chosen_provider, attempted_providers = choose_provider(preferred)
+    if chosen_provider == "local":
+        return {
+            "ok": False,
+            "provider": "local",
+            "duration_ms": 0,
+            "attempted_providers": attempted_providers,
+            "error_reason": "analysis_provider_unavailable",
+            "structured": {},
+        }
+
+    if not is_provider_available(chosen_provider):
+        return {
+            "ok": False,
+            "provider": chosen_provider,
+            "duration_ms": 0,
+            "attempted_providers": attempted_providers or [chosen_provider],
+            "error_reason": "analysis_provider_unavailable",
+            "structured": {},
+        }
+
+    if chosen_provider == "openclaw":
+        result = _run_openclaw(
+            prompt_text=prompt_text,
+            payload=payload,
+            timeout_sec=timeout_sec,
+            progress=progress,
+        )
+    elif chosen_provider == "codex":
+        result = _run_codex(
+            prompt_text=prompt_text,
+            payload=payload,
+            timeout_sec=timeout_sec,
+            progress=progress,
+        )
+    else:
+        result = _run_claude_code(
+            prompt_text=prompt_text,
+            payload=payload,
+            timeout_sec=timeout_sec,
+            progress=progress,
+        )
+
+    raw_text = str(result.get("raw_text") or "")
+    structured = _extract_json_object(raw_text)
+    return {
+        "ok": bool(result.get("ok")) and bool(structured),
+        "provider": chosen_provider,
+        "duration_ms": int(result.get("duration_ms") or 0),
+        "attempted_providers": attempted_providers or [chosen_provider],
+        "error_reason": result.get("error_reason") or (None if structured else "analysis_parse_failed"),
+        "structured": structured if isinstance(structured, dict) else {},
+    }