@ramarivera/coding-agent-langfuse 0.1.52 → 0.1.53

package/README.md

@@ -63,13 +63,14 @@ There are two config layers:
 - 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:
+Global config uses path-prefix or Git-remote rules:
 
 ```json
 {
   "rules": [
     {
       "pathPrefix": "/Users/example/dev/acme",
+      "gitRemoteIncludes": ["github.com/acme"],
       "tags": ["acme", "client:acme"],
       "metadata": {
         "project_group": "acme",
@@ -82,6 +83,11 @@ Global config uses prefix rules:
 }
 ```
 
+Use `pathPrefix` for stable checkout roots. Use `gitRemoteIncludes` for
+temporary agent worktrees, where the cwd may live under a random directory such
+as `.codex/worktrees/<id>/repo` but the Git remote still identifies the real
+project.
+
 Project-local config is intentionally smaller and overrides/extends the matched
 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

package/dist/backfill.d.ts

@@ -70,7 +70,8 @@ type OtlpOptions = {
     homeDir?: string;
 };
 type PathTagRule = {
-    pathPrefix: string;
+    pathPrefix?: string;
+    gitRemoteIncludes?: string[];
     tags: string[];
     metadata: Record<string, unknown>;
     projectName?: string;

package/dist/backfill.js

@@ -196,13 +196,20 @@ function projectMetadata(cwd) {
         projectFolder: projectName,
     };
 }
-function matchPathTags(cwd, config, homeDir) {
-    if (!cwd)
+function matchPathTags(cwd, config, homeDir, git) {
+    if (!cwd && !git?.remoteUrls?.length)
         return { tags: [], metadata: {} };
-    const normalizedCwd = normalizeRulePath(cwd);
+    const normalizedCwd = cwd ? normalizeRulePath(cwd) : undefined;
+    const normalizedRemotes = (git?.remoteUrls ?? []).map((remote) => remote.toLowerCase());
     const matched = config.rules.filter((rule) => {
-        const prefix = normalizeRulePath(rule.pathPrefix);
-        return normalizedCwd === prefix || normalizedCwd.startsWith(`${prefix}/`);
+        const pathMatch = rule.pathPrefix && normalizedCwd
+            ? (() => {
+                const prefix = normalizeRulePath(rule.pathPrefix);
+                return normalizedCwd === prefix || normalizedCwd.startsWith(`${prefix}/`);
+            })()
+            : false;
+        const gitRemoteMatch = (rule.gitRemoteIncludes ?? []).some((needle) => normalizedRemotes.some((remote) => remote.includes(needle.toLowerCase())));
+        return pathMatch || gitRemoteMatch;
     });
     const globalMatch = matched.reduce((acc, rule) => ({
         tags: [...new Set([...acc.tags, ...rule.tags])],
@@ -238,14 +245,15 @@ function matchPathTags(cwd, config, homeDir) {
 }
 function mergeProjectMetadata(cwd, config, homeDir) {
     const project = projectMetadata(cwd);
-    const pathTags = matchPathTags(cwd, config, homeDir);
+    const git = loadGitMetadata(cwd);
+    const pathTags = matchPathTags(cwd, config, homeDir, git);
     return {
         ...project,
         projectName: pathTags.projectName ?? project.projectName,
         projectFolder: pathTags.projectFolder ?? project.projectFolder,
         tags: pathTags.tags,
         metadata: pathTags.metadata,
-        git: loadGitMetadata(cwd),
+        git,
     };
 }
 function loadGitMetadata(cwd) {
@@ -263,10 +271,16 @@ function loadGitMetadata(cwd) {
     const branch = gitOutput(gitCwd, ["branch", "--show-current"]) ??
         gitOutput(gitCwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
     const commit = gitOutput(gitCwd, ["rev-parse", "--verify", "HEAD"]);
+    const remoteUrls = gitOutput(gitCwd, ["remote", "-v"])
+        ?.split("\n")
+        .map((line) => line.trim().split(/\s+/)[1])
+        .filter((remote) => Boolean(remote))
+        .filter((remote, index, remotes) => remotes.indexOf(remote) === index);
     const metadata = {
         worktreePath,
         branch: branch === "HEAD" ? undefined : branch,
         commit,
+        remoteUrls,
     };
     gitMetadataCache.set(gitCwd, metadata);
     return metadata;
@@ -511,8 +525,10 @@ function loadPathTagsConfig(path) {
     const rules = rawRules.map((rawRule, index) => {
         const rule = asRecord(rawRule);
         const pathPrefix = asString(rule.pathPrefix) ?? asString(rule.path_prefix);
-        if (!pathPrefix) {
-            throw new Error(`Invalid path tags config ${path}: rules[${index}].pathPrefix is required`);
+        const gitRemoteIncludes = stringArray(rule.gitRemoteIncludes ?? rule.git_remote_includes ?? rule.gitRemoteInclude ??
+            rule.git_remote_include);
+        if (!pathPrefix && gitRemoteIncludes.length === 0) {
+            throw new Error(`Invalid path tags config ${path}: rules[${index}] requires pathPrefix or gitRemoteIncludes`);
         }
         const tags = Array.isArray(rule.tags)
             ? rule.tags.filter((tag) => typeof tag === "string" && tag.trim().length > 0)
@@ -520,6 +536,7 @@ function loadPathTagsConfig(path) {
         const metadata = asRecord(rule.metadata);
         return {
             pathPrefix,
+            gitRemoteIncludes,
             tags,
             metadata,
             projectName: asString(rule.projectName) ?? asString(rule.project_name),
@@ -764,6 +781,13 @@ function getPath(value, keys) {
 function asString(value) {
     return typeof value === "string" ? value : undefined;
 }
+function stringArray(value) {
+    if (typeof value === "string" && value.trim().length > 0)
+        return [value];
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
 function asNumber(value) {
     return typeof value === "number" && Number.isFinite(value)
         ? value

package/package.json

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