@ramarivera/coding-agent-langfuse 0.1.47 → 0.1.48

package/README.md

@@ -97,10 +97,13 @@ global rule:
 
 Matched values are emitted on root trace metadata, observation metadata, and
 top-level OTLP attributes such as `project.tags`, `project.group`, and
-`project.owner`. The root span also sets `langfuse.trace.tags`, so Langfuse
-custom dashboards can filter/group by tags or metadata. Historical repair runs
-use the same OTLP builder as live follow mode, so rerunning with `--force` can
-backfill newly added tags for existing sessions.
+`project.owner`. When the session cwd is inside a Git repository, the exporter
+also emits `git.worktree.path`, `git.branch`, and `git.commit` plus matching
+Langfuse metadata fields. The root span also sets `langfuse.trace.tags`, so
+Langfuse custom dashboards can filter/group by tags, metadata, branch, or
+worktree. Historical repair runs use the same OTLP builder as live follow mode,
+so rerunning with `--force` can backfill newly added tags and Git metadata for
+existing sessions.
 
 Use a non-default global config path with:
 

package/dist/backfill.js

@@ -35,6 +35,7 @@ const defaultPathTagsConfigPath = join(homedir(), ".config/coding-agent-langfuse
 const currentHost = hostname();
 const projectLocalConfigFile = ".langfuse-ca.json";
 const projectLocalConfigCache = new Map();
+const gitMetadataCache = new Map();
 const kimiFirepassRates = {
     input: 2,
     output: 8,
@@ -244,8 +245,60 @@ function mergeProjectMetadata(cwd, config) {
         projectFolder: pathTags.projectFolder ?? project.projectFolder,
         tags: pathTags.tags,
         metadata: pathTags.metadata,
+        git: loadGitMetadata(cwd),
     };
 }
+function loadGitMetadata(cwd) {
+    const gitCwd = nearestExistingDirectory(cwd);
+    if (!gitCwd)
+        return {};
+    const cached = gitMetadataCache.get(gitCwd);
+    if (cached)
+        return cached;
+    const worktreePath = gitOutput(gitCwd, ["rev-parse", "--show-toplevel"]);
+    if (!worktreePath) {
+        gitMetadataCache.set(gitCwd, {});
+        return {};
+    }
+    const branch = gitOutput(gitCwd, ["branch", "--show-current"]) ??
+        gitOutput(gitCwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    const commit = gitOutput(gitCwd, ["rev-parse", "--verify", "HEAD"]);
+    const metadata = {
+        worktreePath,
+        branch: branch === "HEAD" ? undefined : branch,
+        commit,
+    };
+    gitMetadataCache.set(gitCwd, metadata);
+    return metadata;
+}
+function gitOutput(cwd, args) {
+    try {
+        const output = execFileSync("git", ["-C", cwd, ...args], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return output.length > 0 ? output : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function nearestExistingDirectory(path) {
+    if (!path)
+        return undefined;
+    let current = path;
+    while (true) {
+        try {
+            return statSync(current).isDirectory() ? current : dirname(current);
+        }
+        catch {
+            const parent = dirname(current);
+            if (parent === current)
+                return undefined;
+            current = parent;
+        }
+    }
+}
 function usage() {
     return `Usage: coding-agent-langfuse-backfill [options]
 
@@ -1854,6 +1907,9 @@ function toOtlp(events, options = {}) {
             attr("langfuse.trace.metadata.project_folder", firstProject.projectFolder),
             attr("langfuse.trace.metadata.project_tags", nonEmptyArray(firstProject.tags)),
             attr("langfuse.trace.metadata.path_tags", nonEmptyRecord(firstProject.metadata)),
+            attr("langfuse.trace.metadata.git_worktree_path", firstProject.git.worktreePath),
+            attr("langfuse.trace.metadata.git_branch", firstProject.git.branch),
+            attr("langfuse.trace.metadata.git_commit", firstProject.git.commit),
             attr("langfuse.trace.tags", nonEmptyArray(firstProject.tags)),
             attr("langfuse.trace.metadata.import_payload_version", payloadVersion(first)),
             attr("langfuse.trace.metadata.import_state_identity", importIdentity(first)),
@@ -1870,6 +1926,9 @@ function toOtlp(events, options = {}) {
             attr("langfuse.observation.metadata.project_folder", firstProject.projectFolder),
             attr("langfuse.observation.metadata.project_tags", nonEmptyArray(firstProject.tags)),
             attr("langfuse.observation.metadata.path_tags", nonEmptyRecord(firstProject.metadata)),
+            attr("langfuse.observation.metadata.git_worktree_path", firstProject.git.worktreePath),
+            attr("langfuse.observation.metadata.git_branch", firstProject.git.branch),
+            attr("langfuse.observation.metadata.git_commit", firstProject.git.commit),
             attr("langfuse.observation.metadata.import_payload_version", payloadVersion(first)),
             attr("langfuse.observation.metadata.import_state_identity", importIdentity(first)),
             attr("langfuse.observation.metadata.langfuse_id_identity", langfuseIdIdentity(first)),
@@ -1881,6 +1940,9 @@ function toOtlp(events, options = {}) {
             attr("project.tags", nonEmptyArray(firstProject.tags)),
             attr("project.group", firstProject.metadata.project_group),
             attr("project.owner", firstProject.metadata.project_owner),
+            attr("git.worktree.path", firstProject.git.worktreePath),
+            attr("git.branch", firstProject.git.branch),
+            attr("git.commit", firstProject.git.commit),
         ].filter((item) => Boolean(item));
         const rootSpan = {
             traceId: traceId(first),
@@ -1927,6 +1989,9 @@ function toOtlp(events, options = {}) {
                 attr("langfuse.observation.metadata.project_folder", eventProject.projectFolder),
                 attr("langfuse.observation.metadata.project_tags", nonEmptyArray(eventProject.tags)),
                 attr("langfuse.observation.metadata.path_tags", nonEmptyRecord(eventProject.metadata)),
+                attr("langfuse.observation.metadata.git_worktree_path", eventProject.git.worktreePath),
+                attr("langfuse.observation.metadata.git_branch", eventProject.git.branch),
+                attr("langfuse.observation.metadata.git_commit", eventProject.git.commit),
                 attr("langfuse.observation.metadata.model", modelName ?? event.model),
                 attr("langfuse.observation.metadata.provider", event.provider),
                 attr("langfuse.observation.metadata.import_payload_version", payloadVersion(event)),
@@ -1953,6 +2018,9 @@ function toOtlp(events, options = {}) {
                 attr("project.tags", nonEmptyArray(eventProject.tags)),
                 attr("project.group", eventProject.metadata.project_group),
                 attr("project.owner", eventProject.metadata.project_owner),
+                attr("git.worktree.path", eventProject.git.worktreePath),
+                attr("git.branch", eventProject.git.branch),
+                attr("git.commit", eventProject.git.commit),
                 attr("role", event.role),
                 attr("agent.model", event.model),
                 attr("agent.provider", event.provider),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ramarivera/coding-agent-langfuse",
-  "version": "0.1.47",
+  "version": "0.1.48",
   "description": "Universal coding-agent Langfuse backfiller and live OTLP helpers",
   "type": "module",
   "license": "MIT",