@ramarivera/coding-agent-langfuse 0.1.47 → 0.1.50

package/README.md

@@ -60,8 +60,8 @@ guessing from host names or Windows paths in the Langfuse UI.
 There are two config layers:
 
 - Global host config: `~/.config/coding-agent-langfuse/path-tags.json`
-- Optional project-local overlay: `.langfuse-ca.json` in the project directory
-  or any parent of the session cwd
+- Optional project-local overlays: every `.langfuse-ca.json` found while
+  walking from the session cwd up to the scanned home directory
 
 Global config uses prefix rules:
 
@@ -83,7 +83,9 @@ Global config uses prefix rules:
 ```
 
 Project-local config is intentionally smaller and overrides/extends the matched
-global rule:
+global rule. Parent overlays are applied before child overlays, so a config at
+`~/work/client-a/.langfuse-ca.json` can tag a whole workstream while nested
+repos add repo-specific fields:
 
 ```json
 {
@@ -97,10 +99,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:
 
@@ -109,9 +114,9 @@ npx @ramarivera/coding-agent-langfuse@latest \
   --path-tags-config "$HOME/.config/coding-agent-langfuse/path-tags.json"
 ```
 
-Generated services pass `--path-tags-config` when provided to
-`service install`; otherwise the package reads the default global config path if
-it exists.
+Generated services keep their command small and rely on the package's default
+global config plus upward project-local discovery. Use `--path-tags-config` only
+for one-off CLI runs that need a non-default global config path.
 
 ## Cost calculation
 

package/dist/backfill.d.ts

@@ -67,6 +67,7 @@ type OtlpOptions = {
     maxFieldBytes?: number;
     costRates?: CostCatalog;
     pathTagsConfig?: PathTagsConfig;
+    homeDir?: string;
 };
 type PathTagRule = {
     pathPrefix: string;

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,
@@ -195,7 +196,7 @@ function projectMetadata(cwd) {
         projectFolder: projectName,
     };
 }
-function matchPathTags(cwd, config) {
+function matchPathTags(cwd, config, homeDir) {
     if (!cwd)
         return { tags: [], metadata: {} };
     const normalizedCwd = normalizeRulePath(cwd);
@@ -217,7 +218,7 @@ function matchPathTags(cwd, config) {
     const overlays = [
         globalMatch,
         config.project,
-        loadProjectLocalOverlay(cwd),
+        ...loadProjectLocalOverlays(cwd, homeDir),
     ].filter((overlay) => overlay !== undefined);
     return overlays.reduce((acc, overlay) => {
         if (!overlay)
@@ -235,17 +236,69 @@ function matchPathTags(cwd, config) {
         projectFolder: undefined,
     });
 }
-function mergeProjectMetadata(cwd, config) {
+function mergeProjectMetadata(cwd, config, homeDir) {
     const project = projectMetadata(cwd);
-    const pathTags = matchPathTags(cwd, config);
+    const pathTags = matchPathTags(cwd, config, homeDir);
     return {
         ...project,
         projectName: pathTags.projectName ?? project.projectName,
         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]
 
@@ -475,10 +528,12 @@ function loadPathTagsConfig(path) {
     });
     return { rules, project: normalizeProjectTagOverlay(root, path) };
 }
-function loadProjectLocalOverlay(cwd) {
-    const configPath = findProjectLocalConfig(cwd);
-    if (!configPath)
-        return undefined;
+function loadProjectLocalOverlays(cwd, homeDir) {
+    return findProjectLocalConfigs(cwd, homeDir)
+        .map((configPath) => loadProjectLocalOverlay(configPath))
+        .filter((overlay) => overlay !== undefined);
+}
+function loadProjectLocalOverlay(configPath) {
     const cached = projectLocalConfigCache.get(configPath);
     if (projectLocalConfigCache.has(configPath))
         return cached;
@@ -492,31 +547,26 @@ function loadProjectLocalOverlay(cwd) {
     projectLocalConfigCache.set(configPath, overlay);
     return overlay;
 }
-function findProjectLocalConfig(cwd) {
-    if (!cwd)
-        return undefined;
-    let current = cwd;
-    while (true) {
-        try {
-            current = statSync(current).isDirectory() ? current : dirname(current);
-            break;
-        }
-        catch {
-            const parent = dirname(current);
-            if (parent === current)
-                return undefined;
-            current = parent;
-        }
-    }
+function findProjectLocalConfigs(cwd, homeDir) {
+    const start = nearestExistingDirectory(cwd);
+    if (!start)
+        return [];
+    const home = homeDir ? nearestExistingDirectory(homeDir) ?? homeDir : homedir();
+    const stopAtHome = isSameOrChildPath(start, home);
+    const configPaths = [];
+    let current = start;
     while (true) {
         const candidate = join(current, projectLocalConfigFile);
         if (existsSync(candidate))
-            return candidate;
+            configPaths.push(candidate);
+        if (stopAtHome && sameNormalizedPath(current, home))
+            break;
         const parent = dirname(current);
         if (parent === current)
-            return undefined;
+            break;
         current = parent;
     }
+    return configPaths.reverse();
 }
 function normalizeProjectTagOverlay(value, sourcePath) {
     const root = asRecord(value);
@@ -543,6 +593,15 @@ function normalizeRulePath(path) {
     const normalized = path.replace(/\\/g, "/").replace(/\/+$/, "");
     return /^[a-z]:\//i.test(normalized) ? normalized.toLowerCase() : normalized;
 }
+function sameNormalizedPath(left, right) {
+    return normalizeRulePath(left) === normalizeRulePath(right);
+}
+function isSameOrChildPath(child, parent) {
+    const normalizedChild = normalizeRulePath(child);
+    const normalizedParent = normalizeRulePath(parent);
+    return normalizedChild === normalizedParent ||
+        normalizedChild.startsWith(`${normalizedParent}/`);
+}
 function loadCostCatalogFromEnv() {
     let catalog = { ...defaultCostRates };
     const path = process.env.CODING_AGENT_LANGFUSE_COST_RATES_PATH ??
@@ -1815,6 +1874,7 @@ function toOtlp(events, options = {}) {
     const maxFieldBytes = options.maxFieldBytes ?? defaultMaxFieldBytes;
     const costRates = options.costRates ?? loadCostCatalogFromEnv();
     const pathTagsConfig = options.pathTagsConfig ?? { rules: [] };
+    const projectConfigHomeDir = options.homeDir ?? process.env.HOME ?? homedir();
     const spansByTrace = new Map();
     for (const rawEvent of events) {
         const event = limitEventPayload(rawEvent, maxFieldBytes);
@@ -1829,7 +1889,7 @@ function toOtlp(events, options = {}) {
         const traceStartMs = sortedEvents[0]?.startMs ?? Date.now();
         const traceEndMs = Math.max(...sortedEvents.map((event) => event.endMs ?? event.startMs + 1), traceStartMs + 1);
         const shouldEmitRootSpan = sortedEvents.some((event) => event.recordId === "session");
-        const firstProject = mergeProjectMetadata(first.cwd, pathTagsConfig);
+        const firstProject = mergeProjectMetadata(first.cwd, pathTagsConfig, projectConfigHomeDir);
         const rootAttributes = [
             attr("service.name", `agent.${first.agent}`),
             attr("deployment.environment", "local"),
@@ -1854,6 +1914,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 +1933,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 +1947,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),
@@ -1900,7 +1969,7 @@ function toOtlp(events, options = {}) {
             const generation = isGenerationEvent(event);
             const usage = usageDetails(event.usage);
             const cost = generation ? calculateCost(event, usage, costRates) : undefined;
-            const eventProject = mergeProjectMetadata(event.cwd, pathTagsConfig);
+            const eventProject = mergeProjectMetadata(event.cwd, pathTagsConfig, projectConfigHomeDir);
             const attributes = [
                 attr("service.name", `agent.${event.agent}`),
                 attr("deployment.environment", "local"),
@@ -1927,6 +1996,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 +2025,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),
@@ -2137,6 +2212,7 @@ async function run(options) {
                 maxFieldBytes: options.maxFieldBytes,
                 costRates: options.costRates,
                 pathTagsConfig: options.pathTagsConfig,
+                homeDir: options.homeDir,
             });
         }
         catch (error) {
@@ -2164,6 +2240,7 @@ async function run(options) {
                     maxFieldBytes: options.maxFieldBytes,
                     costRates: options.costRates,
                     pathTagsConfig: options.pathTagsConfig,
+                    homeDir: options.homeDir,
                     auth: options.auth,
                 });
                 for (const event of batch) {

package/dist/service.js

@@ -36,11 +36,11 @@ Service options:
 `;
 }
 function parseServiceArgs(argv) {
-    const action = parseServiceAction(argv[0]);
     if (argv.includes("--help") || argv.includes("-h")) {
         console.log(serviceUsage());
         process.exit(0);
     }
+    const action = parseServiceAction(argv[0]);
     let platform = currentServicePlatform();
     let agents = [...allAgents];
     let endpoint = process.env.LANGFUSE_BACKFILL_ENDPOINT ?? defaultEndpoint;
@@ -56,8 +56,7 @@ function parseServiceArgs(argv) {
         process.env.LANGFUSE_BACKFILL_COST_RATES_PATH;
     let costRatesJson = process.env.CODING_AGENT_LANGFUSE_COST_RATES_JSON ??
         process.env.LANGFUSE_BACKFILL_COST_RATES_JSON;
-    let pathTagsConfigPath = process.env.CODING_AGENT_LANGFUSE_PATH_TAGS_CONFIG ??
-        process.env.LANGFUSE_BACKFILL_PATH_TAGS_CONFIG;
+    let pathTagsConfigPath;
     let since;
     let dryRun = false;
     let start = true;

package/package.json

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