@ramarivera/coding-agent-langfuse 0.1.16 → 0.1.17

package/README.md

@@ -18,7 +18,18 @@ npx @ramarivera/coding-agent-langfuse@latest \
   --agents claude,codex,grok,pi,opencode \
   --endpoint https://langfuse.ai.roxasroot.net/otel/v1/traces \
   --state "$HOME/.local/state/coding-agent-langfuse/backfill-v6.json" \
-  --batch-size 1000
+  --batch-size 10
+```
+
+Run live incremental forwarding without putting inference behind a gateway:
+
+```sh
+npx @ramarivera/coding-agent-langfuse@latest \
+  --agents codex \
+  --endpoint https://langfuse.ai.roxasroot.net/otel/v1/traces \
+  --state "$HOME/.local/state/coding-agent-langfuse/live-codex.json" \
+  --batch-size 10 \
+  --follow
 ```
 
 The importer is fail-fast: the first failed OTLP POST stops the run, prints the

package/dist/backfill.d.ts

@@ -33,6 +33,9 @@ type BackfillOptions = {
     statePath: string;
     homeDir: string;
     dryRun: boolean;
+    follow: boolean;
+    pollIntervalMs: number;
+    idleExitAfterMs?: number;
     limit?: number;
     sinceMs?: number;
     untilMs?: number;
@@ -50,6 +53,10 @@ type RunSummary = {
     endpoint: string;
     statePath: string;
 };
+type FollowSummary = RunSummary & {
+    iterations: number;
+    follow: true;
+};
 declare function parseArgs(argv: string[]): BackfillOptions;
 declare function codexEvents(homeDir: string): BackfillEvent[];
 declare function claudeEvents(homeDir: string): BackfillEvent[];
@@ -60,5 +67,6 @@ declare function fingerprint(event: BackfillEvent): string;
 declare function toOtlp(events: BackfillEvent[]): Record<string, unknown>;
 declare function discoverEvents(options: BackfillOptions): BackfillEvent[];
 declare function run(options: BackfillOptions): Promise<RunSummary>;
-declare function main(argv?: string[]): Promise<RunSummary>;
-export { type BackfillEvent, type BackfillOptions, claudeEvents, codexEvents, discoverEvents, fingerprint, grokEvents, main, opencodeEvents, parseArgs, piEvents, run, toOtlp, };
+declare function follow(options: BackfillOptions): Promise<FollowSummary>;
+declare function main(argv?: string[]): Promise<RunSummary | FollowSummary>;
+export { type BackfillEvent, type BackfillOptions, claudeEvents, codexEvents, discoverEvents, fingerprint, follow, grokEvents, main, opencodeEvents, parseArgs, piEvents, run, toOtlp, };

package/dist/backfill.js

@@ -21,6 +21,9 @@ Options:
   --until ISO_OR_MS       Only import events before or at this timestamp
   --limit N               Stop after N unsent events
   --batch-size N          OTLP spans per POST (default: 50)
+  --follow                Keep scanning and sending newly written events
+  --poll-interval-ms N    Delay between --follow scans (default: 5000)
+  --idle-exit-after-ms N  Stop --follow after this much time without new sends
   --dry-run               Discover and dedupe without sending or mutating state
   --help                  Show this help
 `;
@@ -34,6 +37,9 @@ function parseArgs(argv) {
     let sinceMs;
     let untilMs;
     let batchSize = 50;
+    let follow = false;
+    let pollIntervalMs = 5_000;
+    let idleExitAfterMs;
     const agents = new Set(allAgents);
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
@@ -75,6 +81,15 @@ function parseArgs(argv) {
         else if (arg === "--batch-size") {
             batchSize = Number.parseInt(next(), 10);
         }
+        else if (arg === "--follow") {
+            follow = true;
+        }
+        else if (arg === "--poll-interval-ms") {
+            pollIntervalMs = Number.parseInt(next(), 10);
+        }
+        else if (arg === "--idle-exit-after-ms") {
+            idleExitAfterMs = Number.parseInt(next(), 10);
+        }
         else if (arg === "--since") {
             sinceMs = parseTime(next());
         }
@@ -88,6 +103,13 @@ function parseArgs(argv) {
     if (!Number.isFinite(batchSize) || batchSize < 1) {
         throw new Error("--batch-size must be a positive integer");
     }
+    if (!Number.isFinite(pollIntervalMs) || pollIntervalMs < 1) {
+        throw new Error("--poll-interval-ms must be a positive integer");
+    }
+    if (idleExitAfterMs !== undefined &&
+        (!Number.isFinite(idleExitAfterMs) || idleExitAfterMs < 1)) {
+        throw new Error("--idle-exit-after-ms must be a positive integer");
+    }
     if (limit !== undefined && (!Number.isFinite(limit) || limit < 1)) {
         throw new Error("--limit must be a positive integer");
     }
@@ -97,6 +119,9 @@ function parseArgs(argv) {
         statePath,
         homeDir,
         dryRun,
+        follow,
+        pollIntervalMs,
+        idleExitAfterMs,
         limit,
         sinceMs,
         untilMs,
@@ -1035,8 +1060,63 @@ async function run(options) {
         statePath: options.statePath,
     };
 }
+function mergeSummary(base, next) {
+    return {
+        discovered: Object.fromEntries(allAgents.map((agent) => [
+            agent,
+            Math.max(base.discovered[agent] ?? 0, next.discovered[agent] ?? 0),
+        ])),
+        sent: base.sent + next.sent,
+        skipped: next.skipped,
+        failed: base.failed + next.failed,
+        notAttempted: next.notAttempted,
+        aborted: base.aborted || next.aborted,
+        ...(next.error ? { error: next.error } : base.error ? { error: base.error } : {}),
+        dryRun: base.dryRun,
+        endpoint: base.endpoint,
+        statePath: base.statePath,
+    };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function follow(options) {
+    let iterations = 0;
+    let lastSendOrStartMs = Date.now();
+    let aggregate;
+    while (true) {
+        iterations += 1;
+        const summary = await run(options);
+        aggregate = aggregate === undefined ? summary : mergeSummary(aggregate, summary);
+        if (summary.sent > 0)
+            lastSendOrStartMs = Date.now();
+        if (summary.aborted)
+            break;
+        if (options.idleExitAfterMs !== undefined &&
+            Date.now() - lastSendOrStartMs >= options.idleExitAfterMs) {
+            break;
+        }
+        await sleep(options.pollIntervalMs);
+    }
+    return {
+        ...(aggregate ?? {
+            discovered: Object.fromEntries(allAgents.map((agent) => [agent, 0])),
+            sent: 0,
+            skipped: 0,
+            failed: 0,
+            notAttempted: 0,
+            aborted: false,
+            dryRun: options.dryRun,
+            endpoint: options.endpoint,
+            statePath: options.statePath,
+        }),
+        iterations,
+        follow: true,
+    };
+}
 async function main(argv = process.argv.slice(2)) {
-    const summary = await run(parseArgs(argv));
+    const options = parseArgs(argv);
+    const summary = options.follow ? await follow(options) : await run(options);
     console.log(JSON.stringify(summary, null, 2));
     return summary;
 }
@@ -1050,4 +1130,4 @@ if (import.meta.url === `file://${process.argv[1]}`) {
         process.exit(1);
     }
 }
-export { claudeEvents, codexEvents, discoverEvents, fingerprint, grokEvents, main, opencodeEvents, parseArgs, piEvents, run, toOtlp, };
+export { claudeEvents, codexEvents, discoverEvents, fingerprint, follow, grokEvents, main, opencodeEvents, parseArgs, piEvents, run, toOtlp, };

package/package.json

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