oh-langfuse 0.1.44 → 0.1.45

package/langfuse_hook.py

@@ -10,7 +10,7 @@ import re
 import sys
 import time
 import hashlib
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
@@ -526,7 +526,7 @@ def _dedupe_turn_skill_usages(usages: List[Dict[str, str]]) -> List[Dict[str, st
 
 def detect_turn_skill_usages(turn: "Turn", tool_calls: List[Dict[str, Any]], known_skills: set) -> List[Dict[str, str]]:
     found = list(detect_skill_usages(tool_calls, known_skills))
-    rows = [turn.user_msg, *turn.assistant_msgs]
+    rows = [turn.user_msg, *getattr(turn, "context_msgs", []), *turn.assistant_msgs]
 
     for row in rows:
         attributed = _accept_skill_candidate(_attribution_skill_from_row(row), known_skills, trusted=True)
@@ -694,13 +694,20 @@ def read_new_jsonl(transcript_path: Path, ss: SessionState) -> Tuple[List[Dict[s
     return msgs, ss
 
 # ----------------- Turn assembly -----------------
-@dataclass
-class Turn:
-    user_msg: Dict[str, Any]
-    assistant_msgs: List[Dict[str, Any]]
-    tool_results_by_id: Dict[str, Any]
-
-def build_turns(messages: List[Dict[str, Any]]) -> List[Turn]:
+@dataclass
+class Turn:
+    user_msg: Dict[str, Any]
+    assistant_msgs: List[Dict[str, Any]]
+    tool_results_by_id: Dict[str, Any]
+    context_msgs: List[Dict[str, Any]] = field(default_factory=list)
+
+def is_skill_context_user_msg(msg: Dict[str, Any]) -> bool:
+    if get_role(msg) != "user" or is_tool_result(msg):
+        return False
+    text = extract_text(get_content(msg)).lstrip()
+    return text.startswith("Base directory for this skill:")
+
+def build_turns(messages: List[Dict[str, Any]]) -> List[Turn]:
     """
     Groups incremental transcript rows into turns:
     user (non-tool-result) -> assistant messages -> (tool_result rows, possibly interleaved)
@@ -715,38 +722,50 @@ def build_turns(messages: List[Dict[str, Any]]) -> List[Turn]:
     assistant_order: List[str] = []             # message ids in order of first appearance (or synthetic)
     assistant_latest: Dict[str, Dict[str, Any]] = {}  # id -> latest msg
 
-    tool_results_by_id: Dict[str, Any] = {}     # tool_use_id -> content
-
-    def flush_turn():
-        nonlocal current_user, assistant_order, assistant_latest, tool_results_by_id, turns
-        if current_user is None:
-            return
-        if not assistant_latest:
-            return
-        assistants = [assistant_latest[mid] for mid in assistant_order if mid in assistant_latest]
-        turns.append(Turn(user_msg=current_user, assistant_msgs=assistants, tool_results_by_id=dict(tool_results_by_id)))
+    tool_results_by_id: Dict[str, Any] = {}     # tool_use_id -> content
+    context_msgs: List[Dict[str, Any]] = []
+
+    def flush_turn():
+        nonlocal current_user, assistant_order, assistant_latest, tool_results_by_id, context_msgs, turns
+        if current_user is None:
+            return
+        if not assistant_latest:
+            return
+        assistants = [assistant_latest[mid] for mid in assistant_order if mid in assistant_latest]
+        turns.append(Turn(
+            user_msg=current_user,
+            assistant_msgs=assistants,
+            tool_results_by_id=dict(tool_results_by_id),
+            context_msgs=list(context_msgs),
+        ))
 
     for msg in messages:
         role = get_role(msg)
 
         # tool_result rows show up as role=user with content blocks of type tool_result
-        if is_tool_result(msg):
-            for tr in iter_tool_results(get_content(msg)):
-                tid = tr.get("tool_use_id")
-                if tid:
-                    tool_results_by_id[str(tid)] = tr.get("content")
-            continue
-
-        if role == "user":
-            # new user message -> finalize previous turn
-            flush_turn()
+        if is_tool_result(msg):
+            for tr in iter_tool_results(get_content(msg)):
+                tid = tr.get("tool_use_id")
+                if tid:
+                    tool_results_by_id[str(tid)] = tr.get("content")
+            continue
+
+        if is_skill_context_user_msg(msg):
+            if current_user is not None:
+                context_msgs.append(msg)
+            continue
+
+        if role == "user":
+            # new user message -> finalize previous turn
+            flush_turn()
 
             # start a new turn
             current_user = msg
-            assistant_order = []
-            assistant_latest = {}
-            tool_results_by_id = {}
-            continue
+            assistant_order = []
+            assistant_latest = {}
+            tool_results_by_id = {}
+            context_msgs = []
+            continue
 
         if role == "assistant":
             if current_user is None:

package/package.json

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

package/scripts/auto-update-runtime.mjs

@@ -10,6 +10,21 @@ const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
 const packageJson = JSON.parse(fs.readFileSync(path.join(rootDir, "package.json"), "utf8"));
 const ALLOWED_TARGETS = new Set(["claude", "opencode", "codex"]);
 
+const colorEnabled = process.stdout.isTTY && process.env.NO_COLOR !== "1";
+const ansi = (code) => (colorEnabled ? `\x1b[${code}m` : "");
+const t = {
+  reset: ansi(0),
+  bold: ansi(1),
+  cyan: ansi("96"),
+  green: ansi("92"),
+  gold: ansi("93"),
+};
+
+function paint(text, ...styles) {
+  if (!colorEnabled) return text;
+  return `${styles.join("")}${text}${t.reset}`;
+}
+
 function parseArgs(argv) {
   const args = { _: [] };
   for (const raw of argv) {
@@ -45,6 +60,26 @@ function npxCommand() {
   return process.platform === "win32" ? "npx.cmd" : "npx";
 }
 
+function targetLabel(target) {
+  if (target === "claude") return "Claude";
+  if (target === "codex") return "Codex";
+  if (target === "opencode") return "OpenCode";
+  return target;
+}
+
+function printUpdateAvailable(target, message, updateCommand) {
+  const label = targetLabel(target);
+  console.log(paint(`[UPDATE] \u68c0\u6d4b\u5230 ${label} Langfuse \u53ef\u66f4\u65b0`, t.bold, t.gold));
+  console.log(`[INFO] ${message}`);
+  console.log(`${paint("[CMD]", t.bold, t.cyan)} ${updateCommand}`);
+}
+
+function printUpdateCommand(target, updateCommand) {
+  const label = targetLabel(target);
+  console.log(paint(`[UPDATE] \u6b63\u5728\u6267\u884c\u66f4\u65b0\u547d\u4ee4\uff1a${label} Langfuse`, t.bold, t.cyan));
+  console.log(`${paint("[CMD]", t.bold, t.cyan)} ${updateCommand}`);
+}
+
 function runUpdate(target, args) {
   const updateArgs = ["-y", "oh-langfuse@latest", "update", target];
   if (args["skip-check"]) updateArgs.push("--skip-check");
@@ -89,24 +124,27 @@ async function main() {
   const updateCommand = `npx oh-langfuse@latest update ${target}`;
 
   if (args["notify-only"] || args.notifyOnly) {
-    console.log(`[INFO] ${message}`);
+    printUpdateAvailable(target, message, updateCommand);
     console.log(`[INFO] To update safely, close the agent and run: ${updateCommand}`);
     return 0;
   }
 
   if (args.yes || args.y) {
-    console.log(`[INFO] ${message}`);
+    printUpdateAvailable(target, message, updateCommand);
+    printUpdateCommand(target, updateCommand);
     const code = runUpdate(target, args);
     return args.strict ? code : 0;
   }
 
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
-    console.log(`[INFO] ${message} Run: ${updateCommand}`);
+    printUpdateAvailable(target, message, updateCommand);
     return 0;
   }
 
-  const answer = await question(`${message}\nUpdate now? (y/N) `);
+  printUpdateAvailable(target, message, updateCommand);
+  const answer = await question(`${paint("[CONFIRM]", t.bold, t.gold)} Update now? (y/N) `);
   if (!/^(y|yes)$/i.test(answer)) return 0;
+  printUpdateCommand(target, updateCommand);
   const code = runUpdate(target, args);
   return args.strict ? code : 0;
 }

package/scripts/update-langfuse-runtime.mjs

@@ -3,7 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { extractVersionFromNpmMetadata, selectUpdateTargets } from "./update-utils.mjs";
+import { buildUpdatePlan, extractVersionFromNpmMetadata } from "./update-utils.mjs";
 import { writeRuntimeInstallRecord } from "./runtime-state-utils.mjs";
 
 const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
@@ -13,6 +13,23 @@ const DEFAULT_LANGFUSE_BASE_URL = "http://120.46.221.227:3000";
 const DEFAULT_LANGFUSE_PUBLIC_KEY = "pk-lf-da0c90a7-6e93-4eb7-bb86-c1047c8d187d";
 const DEFAULT_LANGFUSE_SECRET_KEY = "sk-lf-0269b85d-bfdc-442c-bfa3-e737954e3315";
 
+const colorEnabled = process.stdout.isTTY && process.env.NO_COLOR !== "1";
+const ansi = (code) => (colorEnabled ? `\x1b[${code}m` : "");
+const t = {
+  reset: ansi(0),
+  bold: ansi(1),
+  dim: ansi(2),
+  cyan: ansi("96"),
+  green: ansi("92"),
+  gold: ansi("93"),
+  red: ansi("91"),
+};
+
+function paint(text, ...styles) {
+  if (!colorEnabled) return text;
+  return `${styles.join("")}${text}${t.reset}`;
+}
+
 function parseArgs(argv) {
   const args = { _: [] };
   for (const raw of argv) {
@@ -142,14 +159,72 @@ function checkScript(target) {
   return "opencode-langfuse-check.mjs";
 }
 
+function targetLabel(target) {
+  if (target === "claude") return "Claude";
+  if (target === "codex") return "Codex";
+  if (target === "opencode") return "OpenCode";
+  return target;
+}
+
+function updatedItems(target, args) {
+  const items = [];
+  if (target === "claude") {
+    items.push("Claude Code Langfuse hook", "direct claude auto-update command shim", "Claude launcher", "runtime version record");
+  } else if (target === "codex") {
+    items.push("Codex notify hook", "direct codex auto-update command shim", "Codex launcher", "runtime version record");
+  } else {
+    items.push("OpenCode Langfuse plugin/config", "direct opencode auto-update command shim", "OpenCode launcher", "runtime version record");
+    if (args["skip-plugin-install"] || args.skipPluginInstall) {
+      items[0] = "OpenCode Langfuse config";
+    }
+  }
+  if (!args["skip-check"]) items.push("post-update configuration check");
+  return items;
+}
+
+function printSkippedTarget(target) {
+  const label = targetLabel(target);
+  console.log(paint(`[WARN] \u5f53\u524d\u672a\u68c0\u6d4b\u5230 ${label} \u5b89\u88c5\uff0c\u8df3\u8fc7\u66f4\u65b0 ${label} Langfuse \u63d2\u4ef6\u3002`, t.bold, t.gold));
+}
+
+function printUpdateStart(target) {
+  const label = targetLabel(target);
+  console.log("");
+  console.log(paint(`[UPDATE] \u6b63\u5728\u66f4\u65b0 ${label} Langfuse ...`, t.bold, t.cyan));
+}
+
+function printUpdateCheck(target) {
+  const label = targetLabel(target);
+  console.log(paint(`[CHECK] \u6b63\u5728\u6821\u9a8c ${label} Langfuse \u914d\u7f6e ...`, t.bold, t.gold));
+}
+
+function printUpdateSuccess(target, args) {
+  const label = targetLabel(target);
+  console.log(paint(`[SUCCESS] ${label} Langfuse \u66f4\u65b0\u6210\u529f\uff1a${packageJson.name}@${packageJson.version}`, t.bold, t.green));
+  console.log(`${paint("[DETAIL]", t.bold, t.gold)} \u66f4\u65b0\u5185\u5bb9\uff1a${updatedItems(target, args).join("\u3001")}`);
+}
+
+function printUpdateSummary(targets) {
+  console.log("");
+  console.log(paint(`[SUCCESS] Langfuse \u66f4\u65b0\u5b8c\u6210\uff1a${targets.map(targetLabel).join("\u3001")} -> ${packageJson.name}@${packageJson.version}`, t.bold, t.green));
+}
+
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   const targetArg = args._[0] || "all";
   const installed = detectInstalledTargets();
-  const targets = selectUpdateTargets(targetArg, installed);
-  if (!targets.length) {
+  const plan = buildUpdatePlan(targetArg, installed);
+  const targets = plan.targets;
+  for (const item of plan.skipped) {
+    if (item.reason === "not_detected") printSkippedTarget(item.target);
+  }
+  if (!targets.length && !plan.skipped.length) {
     throw new Error("No installed oh-langfuse targets were detected. Run setup first, or specify a target with credentials.");
   }
+  if (!targets.length) {
+    console.log("[INFO] \u6ca1\u6709\u53ef\u66f4\u65b0\u7684 Langfuse agent runtime\u3002");
+    return;
+  }
 
   console.log(`[INFO] Running package: ${packageJson.name}@${packageJson.version}`);
   try {
@@ -163,8 +238,7 @@ async function main() {
   }
 
   for (const target of targets) {
-    console.log("");
-    console.log(`[INFO] Updating ${target} runtime...`);
+    printUpdateStart(target);
     const config = mergedConfig(target, args);
     runNodeScript(setupScript(target), setupArgs(target, config, args));
     writeRuntimeInstallRecord(target, {
@@ -172,9 +246,12 @@ async function main() {
       packageVersion: packageJson.version,
     });
     if (!args["skip-check"]) {
+      printUpdateCheck(target);
       runNodeScript(checkScript(target), []);
     }
+    printUpdateSuccess(target, args);
   }
+  printUpdateSummary(targets);
 }
 
 main().catch((error) => {

package/scripts/update-utils.mjs

@@ -1,4 +1,5 @@
 const ALLOWED_TARGETS = new Set(["claude", "opencode", "codex"]);
+const ALL_TARGETS = ["claude", "opencode", "codex"];
 
 export function extractVersionFromNpmMetadata(metadata) {
   const latest = metadata?.["dist-tags"]?.latest;
@@ -38,10 +39,35 @@ export function isNewerVersion(candidate, current) {
 export function selectUpdateTargets(target = "all", installed = {}) {
   const normalized = String(target || "all").trim().toLowerCase();
   if (normalized === "all") {
-    return ["claude", "opencode", "codex"].filter((name) => Boolean(installed[name]));
+    return ALL_TARGETS.filter((name) => Boolean(installed[name]));
   }
   if (!ALLOWED_TARGETS.has(normalized)) {
     throw new Error(`Unsupported update target: ${target}`);
   }
   return [normalized];
 }
+
+export function buildUpdatePlan(target = "all", installed = {}) {
+  const normalized = String(target || "all").trim().toLowerCase();
+  if (normalized === "all") {
+    return {
+      targets: ALL_TARGETS.filter((name) => Boolean(installed[name])),
+      skipped: ALL_TARGETS
+        .filter((name) => !installed[name])
+        .map((name) => ({ target: name, reason: "not_detected" })),
+    };
+  }
+  if (!ALLOWED_TARGETS.has(normalized)) {
+    throw new Error(`Unsupported update target: ${target}`);
+  }
+  if (!installed[normalized]) {
+    return {
+      targets: [],
+      skipped: [{ target: normalized, reason: "not_detected" }],
+    };
+  }
+  return {
+    targets: [normalized],
+    skipped: [],
+  };
+}