@tikomni/skills 0.1.2 → 0.1.4

package/skills/creator-analysis/scripts/core/analysis_pipeline.py

@@ -1,133 +0,0 @@
-#!/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/creator-analysis/scripts/core/config_loader.py

@@ -1,418 +0,0 @@
-#!/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

package/skills/creator-analysis/scripts/core/progress_report.py

@@ -1,111 +0,0 @@
-#!/usr/bin/env python3
-"""Structured stderr progress reporting for long-running TikOmni workflows.
-
-Design goals:
-- emit machine-readable progress events to stderr only
-- keep final JSON stdout contract untouched
-- offer a tiny shared helper so handlers do not duplicate logging logic
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-from datetime import datetime, timezone
-from typing import Any, Dict, Optional
-
-
-VALID_EVENTS = {"started", "progress", "done", "failed"}
-
-
-class ProgressReporter:
-    def __init__(
-        self,
-        *,
-        workflow: str,
-        platform: str,
-        content_kind: str,
-        run_id: Optional[str] = None,
-        scope: str = "workflow",
-        enabled: bool = True,
-        defaults: Optional[Dict[str, Any]] = None,
-    ) -> None:
-        self.workflow = str(workflow or "unknown")
-        self.platform = str(platform or "unknown")
-        self.content_kind = str(content_kind or "unknown")
-        self.run_id = str(run_id or f"{self.platform}.{self.content_kind}")
-        self.scope = str(scope or "workflow")
-        self.enabled = bool(enabled)
-        self.defaults = dict(defaults or {})
-
-    def child(self, *, scope: str, defaults: Optional[Dict[str, Any]] = None) -> "ProgressReporter":
-        merged = dict(self.defaults)
-        if defaults:
-            merged.update(defaults)
-        return ProgressReporter(
-            workflow=self.workflow,
-            platform=self.platform,
-            content_kind=self.content_kind,
-            run_id=self.run_id,
-            scope=scope,
-            enabled=self.enabled,
-            defaults=merged,
-        )
-
-    def emit(self, event: str, *, stage: str, message: str = "", data: Optional[Dict[str, Any]] = None) -> None:
-        if not self.enabled:
-            return
-        normalized_event = str(event or "progress").strip().lower()
-        if normalized_event not in VALID_EVENTS:
-            normalized_event = "progress"
-        payload: Dict[str, Any] = {
-            "channel": "tikomni_progress",
-            "ts": datetime.now(timezone.utc).isoformat(timespec="seconds"),
-            "workflow": self.workflow,
-            "platform": self.platform,
-            "content_kind": self.content_kind,
-            "run_id": self.run_id,
-            "scope": self.scope,
-            "event": normalized_event,
-            "stage": str(stage or "unknown"),
-        }
-        if message:
-            payload["message"] = str(message)
-        if self.defaults:
-            payload["data"] = dict(self.defaults)
-        if isinstance(data, dict) and data:
-            merged = dict(payload.get("data") or {})
-            merged.update(data)
-            payload["data"] = merged
-        sys.stderr.write(json.dumps(payload, ensure_ascii=False) + "\n")
-        sys.stderr.flush()
-
-    def started(self, *, stage: str, message: str = "", data: Optional[Dict[str, Any]] = None) -> None:
-        self.emit("started", stage=stage, message=message, data=data)
-
-    def progress(self, *, stage: str, message: str = "", data: Optional[Dict[str, Any]] = None) -> None:
-        self.emit("progress", stage=stage, message=message, data=data)
-
-    def done(self, *, stage: str, message: str = "", data: Optional[Dict[str, Any]] = None) -> None:
-        self.emit("done", stage=stage, message=message, data=data)
-
-    def failed(self, *, stage: str, message: str = "", data: Optional[Dict[str, Any]] = None) -> None:
-        self.emit("failed", stage=stage, message=message, data=data)
-
-
-def build_progress_reporter(
-    *,
-    workflow: str,
-    platform: str,
-    content_kind: str,
-    input_value: Optional[str] = None,
-    enabled: bool = True,
-) -> ProgressReporter:
-    return ProgressReporter(
-        workflow=workflow,
-        platform=platform,
-        content_kind=content_kind,
-        run_id=f"{platform}.{content_kind}",
-        enabled=enabled,
-        defaults={"input_value": str(input_value or "")[:240]},
-    )