@tikomni/skills 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tikomni/skills",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "TikOmni skill installer CLI for structured social media crawling in Codex, Claude Code, and OpenClaw",
   "license": "MIT",
   "homepage": "https://github.com/mark-ly-wang/TikOmni-Skills#readme",

package/skills/social-media-crawl/scripts/core/extract_pipeline.py

@@ -30,13 +30,105 @@ def build_api_trace(
     return payload
 
 
+def build_route_plan_entry(
+    *,
+    route_label: str,
+    endpoint: Optional[str],
+    method: str = "GET",
+    param_readiness: str = "ready",
+    param_reason: str = "",
+) -> Dict[str, Any]:
+    return {
+        "route_label": route_label,
+        "endpoint": endpoint,
+        "method": method.upper(),
+        "param_readiness": param_readiness,
+        "param_reason": param_reason,
+    }
+
+
+def build_attempted_route(
+    *,
+    route_label: str,
+    endpoint: Optional[str],
+    response: Optional[Dict[str, Any]] = None,
+    accepted: bool = False,
+    accept_reason: str = "",
+    fallback_reason: str = "",
+    param_readiness: str = "ready",
+    param_reason: str = "",
+    skipped: bool = False,
+    extra: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    attempt: Dict[str, Any] = {
+        "route_label": route_label,
+        "endpoint": endpoint,
+        "accepted": bool(accepted),
+        "accept_reason": accept_reason,
+        "fallback_reason": fallback_reason,
+        "param_readiness": param_readiness,
+        "param_reason": param_reason,
+        "skipped": bool(skipped),
+    }
+    if isinstance(response, dict):
+        attempt.update(
+            {
+                "ok": response.get("ok"),
+                "status_code": response.get("status_code"),
+                "request_id": response.get("request_id"),
+                "error_reason": response.get("error_reason"),
+                "retry_attempt": response.get("retry_attempt", 0),
+                "rate_limit_wait_ms": response.get("rate_limit_wait_ms", 0),
+            }
+        )
+    else:
+        attempt.update(
+            {
+                "ok": None,
+                "status_code": None,
+                "request_id": None,
+                "error_reason": None,
+                "retry_attempt": 0,
+                "rate_limit_wait_ms": 0,
+            }
+        )
+    if extra:
+        attempt.update(extra)
+    return attempt
+
+
+def build_stage_status(
+    *,
+    stage: str,
+    status: str,
+    route_plan: Optional[List[Dict[str, Any]]] = None,
+    attempted_routes: Optional[List[Dict[str, Any]]] = None,
+    chosen_route: Optional[str] = None,
+    accept_reason: str = "",
+    fallback_reason: str = "",
+    error_reason: Optional[str] = None,
+    all_routes_failed: bool = False,
+) -> Dict[str, Any]:
+    return {
+        "stage": stage,
+        "status": status,
+        "route_plan": list(route_plan or []),
+        "attempted_routes": list(attempted_routes or []),
+        "chosen_route": chosen_route or "",
+        "accept_reason": accept_reason,
+        "fallback_reason": fallback_reason,
+        "error_reason": error_reason,
+        "all_routes_failed": bool(all_routes_failed),
+    }
+
+
 def build_fallback_trace_from_extract_trace(extract_trace: Optional[List[Dict[str, Any]]]) -> List[Dict[str, Any]]:
     """Build a compact fallback trace from runner extract trace."""
     if not extract_trace:
         return []
 
     trace: List[Dict[str, Any]] = []
-    include_tokens = ("primary", "effective", "fallback", "gate", "retry")
+    include_tokens = ("primary", "effective", "fallback", "gate", "retry", "attempt", "route_decision")
 
     for step in extract_trace:
         if not isinstance(step, dict):

package/skills/social-media-crawl/scripts/core/storage_router.py

@@ -26,14 +26,15 @@ def slugify_token(value: Any, fallback: str = "unknown") -> str:
     return text or fallback
 
 
-def cardify_token(value: Any, fallback: str = "unknown") -> str:
+def cardify_token(value: Any, fallback: str = "unknown", keep_trailing_dash: bool = False) -> str:
     text = str(value or "").strip()
     if not text:
         text = fallback
     text = _INVALID_FILENAME_CHARS.sub("-", text)
     text = _SPACE_RUN.sub("", text)
     text = _CARD_TOKEN_INVALID_CHARS.sub("", text)
-    text = re.sub(r"-{2,}", "-", text).strip("-_.")
+    text = re.sub(r"-{2,}", "-", text)
+    text = text.strip("_.") if keep_trailing_dash else text.strip("-_.")
     return text or fallback
 
 
@@ -85,7 +86,10 @@ def render_card_filename(
     default_filename: str,
     default_ext: str,
 ) -> str:
-    safe_context = {key: cardify_token(value, fallback="") for key, value in context.items()}
+    safe_context = {
+        key: cardify_token(value, fallback="", keep_trailing_dash=(key == "identifier"))
+        for key, value in context.items()
+    }
     safe_context["ext"] = default_ext
     try:
         rendered = str(pattern).format(**safe_context).strip()
@@ -159,10 +163,15 @@ def build_card_identifier(
         return f"{published_token}-{title_token}"
     if title_token:
         return title_token
+    work_id_token = cardify_token(platform_work_id, fallback="")
+    if published_token and work_id_token:
+        return f"{published_token}-{work_id_token}"
+    if work_id_token:
+        return work_id_token
+    if published_token:
+        return f"{published_token}-"
     fallback_token = cardify_token(fallback_identifier, fallback="")
-    if published_token and fallback_token:
-        return f"{published_token}-{fallback_token}"
-    return fallback_token or slugify_token(platform_work_id, fallback="unknown")
+    return fallback_token or "unknown"
 
 
 def resolve_card_route_parts(