oh-langfuse 0.1.43 → 0.1.44

package/codex_langfuse_notify.py

@@ -61,6 +61,7 @@ LOG_FILE = STATE_DIR / "codex_langfuse_notify.log"
 
 DEBUG = os.environ.get("CODEX_LANGFUSE_DEBUG", "").lower() == "true"
 MAX_CHARS = int(os.environ.get("CODEX_LANGFUSE_MAX_CHARS", "20000"))
+MAX_SKILL_SCAN_CHARS = int(os.environ.get("CODEX_LANGFUSE_SKILL_SCAN_MAX_CHARS", "200000"))
 METRICS_SCHEMA_VERSION = "1.1"
 AGENT_NAME = "codex"
 
@@ -460,6 +461,7 @@ def build_interaction_metadata(
 def discover_known_skills(extra_roots: Optional[List[Path]] = None) -> set:
     roots = [
         CODEX_DIR / "skills",
+        CODEX_DIR / "plugins" / "cache",
         Path.home() / ".claude" / "skills",
         Path.home() / ".config" / "opencode" / "skill",
     ]
@@ -490,6 +492,71 @@ def _skill_id_segment(name: str) -> str:
     return (segment or "unknown")[:96]
 
 
+def _skill_usage(name: str, detected_by: str, skill_call_id: str = "") -> Dict[str, str]:
+    clean = str(name or "").strip()
+    return {
+        "name": clean,
+        "skill_namespace": _skill_namespace(clean),
+        "detected_by": detected_by,
+        "skill_call_id": str(skill_call_id or "").strip(),
+    }
+
+
+def _accept_skill_candidate(name: Any, known_skills: set, trusted: bool = False) -> str:
+    clean = str(name or "").strip()
+    if not clean:
+        return ""
+    if trusted or not known_skills or clean in known_skills:
+        return clean
+    return ""
+
+
+def _collect_strings_limited(value: Any, out: List[str], remaining: List[int]) -> None:
+    if remaining[0] <= 0 or value is None:
+        return
+    if isinstance(value, str):
+        text = value[: remaining[0]]
+        if text:
+            out.append(text)
+            remaining[0] -= len(text)
+        return
+    if isinstance(value, (int, float, bool)):
+        return
+    if isinstance(value, list):
+        for item in value:
+            _collect_strings_limited(item, out, remaining)
+            if remaining[0] <= 0:
+                break
+        return
+    if isinstance(value, dict):
+        for item in value.values():
+            _collect_strings_limited(item, out, remaining)
+            if remaining[0] <= 0:
+                break
+
+
+def _detect_skill_usages_from_text(text: str, known_skills: set) -> List[Dict[str, str]]:
+    found: List[Dict[str, str]] = []
+    if not text:
+        return found
+    seen: set = set()
+    for match in re.finditer(r"([A-Za-z]:)?[^\"'\n\r]*[\\/]+([^\\/\"'\n\r]+)[\\/]+SKILL\.md", text, re.IGNORECASE):
+        name = _accept_skill_candidate(match.group(2), known_skills)
+        if name and name not in seen:
+            seen.add(name)
+            found.append(_skill_usage(name, "skill_file_path"))
+    for match in re.finditer(r"Base directory for this skill:\s*([^\r\n]+)", text, re.IGNORECASE):
+        path_text = match.group(1)
+        path_match = re.search(r"[\\/](?:skills|skill)[\\/]([^\\/\"'\r\n]+)", path_text, re.IGNORECASE)
+        if not path_match:
+            continue
+        name = _accept_skill_candidate(path_match.group(1), known_skills)
+        if name and name not in seen:
+            seen.add(name)
+            found.append(_skill_usage(name, "skill_file_path"))
+    return found
+
+
 def detect_skill_usages(tool_calls: List[Dict[str, Any]], known_skills: set) -> List[Dict[str, str]]:
     found: List[Dict[str, str]] = []
     seen_call_ids: set = set()
@@ -507,19 +574,59 @@ def detect_skill_usages(tool_calls: List[Dict[str, Any]], known_skills: set) ->
                         if dedupe_key in seen_call_ids:
                             break
                         seen_call_ids.add(dedupe_key)
-                    found.append({"name": name, "skill_namespace": _skill_namespace(name), "detected_by": "tool_call", "skill_call_id": call_id})
+                    found.append(_skill_usage(name, "tool_call", call_id))
                     break
         try:
             text = json.dumps(input_obj, ensure_ascii=False)
         except Exception:
             text = str(input_obj)
-        for match in re.finditer(r"([A-Za-z]:)?[^\"'\n\r]*[\\/]+([^\\/\"'\n\r]+)[\\/]+SKILL\.md", text, re.IGNORECASE):
-            candidate = match.group(2)
-            if candidate and (candidate in known_skills or not known_skills):
-                found.append({"name": candidate, "skill_namespace": _skill_namespace(candidate), "detected_by": "skill_file_path"})
+        found.extend(_detect_skill_usages_from_text(text, known_skills))
     return found
 
 
+def _dedupe_turn_skill_usages(usages: List[Dict[str, str]]) -> List[Dict[str, str]]:
+    out: List[Dict[str, str]] = []
+    seen_call_ids: set = set()
+    seen_detected: set = set()
+    for usage in usages or []:
+        name = str(usage.get("name") or "").strip()
+        if not name:
+            continue
+        call_id = str(usage.get("skill_call_id") or "").strip()
+        if call_id:
+            key = f"call:{call_id}"
+            if key in seen_call_ids:
+                continue
+            seen_call_ids.add(key)
+            out.append(usage)
+            continue
+        detected_by = str(usage.get("detected_by") or "")
+        if detected_by == "skill_file_path":
+            key = f"{name}:{detected_by}"
+            if key in seen_detected:
+                continue
+            seen_detected.add(key)
+        out.append(usage)
+    return out
+
+
+def detect_turn_skill_usages(material: Dict[str, Any], known_skills: set) -> List[Dict[str, str]]:
+    found = list(detect_skill_usages(material.get("tool_calls") or [], known_skills))
+    sources = [
+        material.get("user_text"),
+        material.get("assistant_text"),
+        material.get("skill_detection_sources"),
+    ]
+    strings: List[str] = []
+    remaining = [max(0, MAX_SKILL_SCAN_CHARS)]
+    for source in sources:
+        _collect_strings_limited(source, strings, remaining)
+        if remaining[0] <= 0:
+            break
+    found.extend(_detect_skill_usages_from_text("\n".join(strings), known_skills))
+    return _dedupe_turn_skill_usages(found)
+
+
 def build_skill_use_events(interaction_id: str, skill_usages: List[Dict[str, str]]) -> List[Dict[str, Any]]:
     events: List[Dict[str, Any]] = []
     deduped: List[Dict[str, str]] = []
@@ -615,14 +722,16 @@ def usage_details_from_codex(usage: Dict[str, Any]) -> Dict[str, int]:
 
 
 def collect_turn_material(rows: List[Dict[str, Any]]) -> Dict[str, Any]:
-    user_texts: List[str] = []
-    assistant_texts: List[str] = []
-    tool_calls: List[Dict[str, Any]] = []
-    tool_results: List[Dict[str, Any]] = []
-
-    for row in rows:
-        row_type = row.get("type")
-        payload = get_payload(row)
+    user_texts: List[str] = []
+    assistant_texts: List[str] = []
+    tool_calls: List[Dict[str, Any]] = []
+    tool_results: List[Dict[str, Any]] = []
+    skill_detection_sources: List[Any] = []
+
+    for row in rows:
+        row_type = row.get("type")
+        payload = get_payload(row)
+        skill_detection_sources.append(payload or row)
 
         if row_type == "response_item":
             item_type = payload.get("type")
@@ -664,10 +773,11 @@ def collect_turn_material(rows: List[Dict[str, Any]]) -> Dict[str, Any]:
 
     return {
         "user_text": "\n\n".join(user_texts[-3:]),
-        "assistant_text": "\n\n".join(assistant_texts),
-        "tool_calls": tool_calls,
-        "tool_results": tool_results,
-    }
+        "assistant_text": "\n\n".join(assistant_texts),
+        "tool_calls": tool_calls,
+        "tool_results": tool_results,
+        "skill_detection_sources": skill_detection_sources,
+    }
 
 
 def emit_codex_turn(
@@ -686,7 +796,7 @@ def emit_codex_turn(
     model = first_string(meta.get("model"), meta.get("model_provider")) or "codex"
     tool_calls = material.get("tool_calls") or []
     tool_results = material.get("tool_results") or []
-    skill_usages = detect_skill_usages(tool_calls, discover_known_skills())
+    skill_usages = detect_turn_skill_usages(material, discover_known_skills())
     interaction_id = build_interaction_id("codex", session_id, turn_num)
     skill_use_events = build_skill_use_events(interaction_id, skill_usages)
     interaction_meta = build_interaction_metadata(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-langfuse",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "private": false,
   "type": "module",
   "description": "Use npm scripts to configure Claude Code / OpenCode / Codex with Langfuse tracing.",