@nathapp/nax 0.73.3 → 0.73.4

package/dist/nax.js

@@ -17283,6 +17283,53 @@ var init_schemas_infra = __esm(() => {
   });
 });
 
+// src/config/schemas-reporters.ts
+var HeadersSchema, ReporterEventSchema, WebhookReporterConfigSchema, OtelReporterConfigSchema, ReportersConfigSchema;
+var init_schemas_reporters = __esm(() => {
+  init_zod();
+  HeadersSchema = exports_external.record(exports_external.string(), exports_external.string()).default({});
+  ReporterEventSchema = exports_external.enum(["onRunStart", "onStoryComplete", "onRunEnd"]);
+  WebhookReporterConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().default(false),
+    url: exports_external.string().url().optional(),
+    headers: HeadersSchema,
+    events: exports_external.array(ReporterEventSchema).optional(),
+    timeoutMs: exports_external.number().int().positive().default(5000)
+  }).default({
+    enabled: false,
+    headers: {},
+    timeoutMs: 5000
+  });
+  OtelReporterConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().default(false),
+    endpoint: exports_external.string().url().optional(),
+    headers: HeadersSchema,
+    serviceName: exports_external.string().default("nax"),
+    timeoutMs: exports_external.number().int().positive().default(5000)
+  }).default({
+    enabled: false,
+    headers: {},
+    serviceName: "nax",
+    timeoutMs: 5000
+  });
+  ReportersConfigSchema = exports_external.object({
+    webhook: WebhookReporterConfigSchema,
+    otel: OtelReporterConfigSchema
+  }).default({
+    webhook: {
+      enabled: false,
+      headers: {},
+      timeoutMs: 5000
+    },
+    otel: {
+      enabled: false,
+      headers: {},
+      serviceName: "nax",
+      timeoutMs: 5000
+    }
+  });
+});
+
 // src/config/schemas-review.ts
 var SemanticReviewConfigSchema, AdversarialReviewConfigSchema, ReviewConfigSchema;
 var init_schemas_review = __esm(() => {
@@ -17369,6 +17416,7 @@ var init_schemas3 = __esm(() => {
   init_schemas_execution();
   init_schemas_infra();
   init_schemas_model();
+  init_schemas_reporters();
   init_schemas_review();
   init_schemas_infra();
   init_schemas_review();
@@ -17739,6 +17787,7 @@ var init_schemas3 = __esm(() => {
       enabled: exports_external.boolean().default(false),
       draft: exports_external.boolean().default(true)
     }).optional().default({ enabled: false, draft: true }),
+    reporters: ReportersConfigSchema,
     profile: exports_external.string().default("default"),
     profileChain: exports_external.array(exports_external.string()).default([])
   }).refine((data) => data.version === 1, {
@@ -38977,9 +39026,10 @@ var init_full_suite_rectify_op = __esm(() => {
 });
 
 // src/operations/full-suite-rectify.ts
-function makeFullSuiteRectifyStrategy(story, config2, sink) {
-  const appliesTo = (finding) => finding.source === "test-runner" && (finding.category === "failed-test" || finding.category === "execution-failed");
+function makeFullSuiteRectifyStrategy(story, config2, sink, hasTestWriterDrainer) {
+  const claimsFailingTest = (finding) => finding.source === "test-runner" && (finding.category === "failed-test" || finding.category === "execution-failed");
   if (sink) {
+    const appliesTo = (finding) => claimsFailingTest(finding) && !(hasTestWriterDrainer === true && sink.mockHandoffs.length > 0);
     return {
       name: "full-suite-rectify",
       appliesTo,
@@ -39007,7 +39057,7 @@ function makeFullSuiteRectifyStrategy(story, config2, sink) {
   }
   return {
     name: "full-suite-rectify",
-    appliesTo,
+    appliesTo: claimsFailingTest,
     fixOp: implementerOp,
     buildInput: (findings) => ({
       story,
@@ -41765,7 +41815,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.73.3",
+    version: "0.73.4",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -41866,8 +41916,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("a98a211e"))
-        return "a98a211e";
+      if (/^[0-9a-f]{6,10}$/.test("ec04b570"))
+        return "ec04b570";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -58944,7 +58994,7 @@ async function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
     const fullSuiteGatePhasePresent = Boolean(inputs.fullSuiteGate) && (isThreeSession || regressionMode === "per-story");
     const verifyScopedPhasePresent = !isThreeSession && Boolean(inputs.verifyScoped);
     if (fullSuiteGatePhasePresent || verifyScopedPhasePresent) {
-      strategies.push(makeFullSuiteRectifyStrategy(story, config2, sink));
+      strategies.push(makeFullSuiteRectifyStrategy(story, config2, sink, isThreeSession));
     }
     if (config2.quality.autofix?.enabled !== false) {
       strategies.push(makeAutofixImplementerStrategy(story, config2, sink, {
@@ -59014,7 +59064,8 @@ async function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
         promptSeverityFloor: "info"
       }));
     }
-    nbStrategies.push(makeFullSuiteRectifyStrategy(story, config2, nbSink));
+    const nbHasTestWriterDrainer = isThreeSession && nbf.scope !== "source";
+    nbStrategies.push(makeFullSuiteRectifyStrategy(story, config2, nbSink, nbHasTestWriterDrainer));
     const nbPostValidate = async (findings, validateCtx) => {
       if (nbSink.testEdits.length === 0 && nbSink.mockHandoffs.length === 0)
         return findings;
@@ -63422,6 +63473,264 @@ var init_curator = __esm(() => {
   };
 });
 
+// src/plugins/builtin/reporter-shared/interpolate.ts
+function interpolateHeaders(headers, env2 = process.env) {
+  const resolved = {};
+  const missing = new Set;
+  for (const [key, value] of Object.entries(headers)) {
+    resolved[key] = value.replace(ENV_PLACEHOLDER, (_match, name) => {
+      const v = env2[name];
+      if (v === undefined) {
+        missing.add(name);
+        return "";
+      }
+      return v;
+    });
+  }
+  return { resolved, missing: [...missing] };
+}
+var ENV_PLACEHOLDER;
+var init_interpolate = __esm(() => {
+  ENV_PLACEHOLDER = /\$\{([A-Z0-9_]+)\}/g;
+});
+
+// src/plugins/builtin/reporter-shared/post-json.ts
+async function postJson(url2, body, opts) {
+  const deps = opts.deps ?? _postJsonDeps;
+  const logger = getSafeLogger();
+  try {
+    const res = await deps.fetch(url2, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...opts.headers },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(opts.timeoutMs)
+    });
+    if (!res.ok) {
+      logger?.warn(opts.stage, "Telemetry POST returned non-2xx", { url: url2, status: res.status });
+      return false;
+    }
+    return true;
+  } catch (err) {
+    logger?.warn(opts.stage, "Telemetry POST failed", { url: url2, error: errorMessage(err) });
+    return false;
+  }
+}
+var _postJsonDeps;
+var init_post_json = __esm(() => {
+  init_logger2();
+  _postJsonDeps = { fetch: globalThis.fetch };
+});
+
+// src/plugins/builtin/reporter-shared/index.ts
+var init_reporter_shared = __esm(() => {
+  init_interpolate();
+  init_post_json();
+});
+
+// src/plugins/builtin/otel-reporter/ids.ts
+function randomHex(bytes) {
+  const arr = new Uint8Array(bytes);
+  crypto.getRandomValues(arr);
+  let out = "";
+  for (const b of arr)
+    out += b.toString(16).padStart(2, "0");
+  return out;
+}
+var newTraceId = () => randomHex(16), newSpanId = () => randomHex(8);
+
+// src/plugins/builtin/otel-reporter/otlp.ts
+function attr(key, value) {
+  return typeof value === "number" ? { key, value: { doubleValue: value } } : { key, value: { stringValue: value } };
+}
+function msToUnixNano(ms) {
+  return (BigInt(Math.round(ms)) * 1000000n).toString();
+}
+function buildTracesPayload(p) {
+  const span = {
+    traceId: p.traceId,
+    spanId: p.spanId,
+    name: "nax.run",
+    kind: 1,
+    startTimeUnixNano: p.startUnixNano,
+    endTimeUnixNano: p.endUnixNano,
+    attributes: [
+      attr("feature", p.feature),
+      attr("runId", p.runId),
+      attr("stories.completed", p.storySummary.completed),
+      attr("stories.failed", p.storySummary.failed),
+      attr("stories.skipped", p.storySummary.skipped),
+      attr("stories.paused", p.storySummary.paused),
+      attr("cost.total", p.totalCost)
+    ],
+    events: p.events,
+    status: { code: p.storySummary.failed > 0 ? 2 : 1 }
+  };
+  return {
+    resourceSpans: [
+      {
+        resource: { attributes: [attr("service.name", p.serviceName)] },
+        scopeSpans: [{ scope: { name: "nax" }, spans: [span] }]
+      }
+    ]
+  };
+}
+function buildMetricsPayload(p) {
+  const statusEntries = Object.entries(p.storySummary).filter(([, n]) => n > 0);
+  const storiesSum = {
+    name: "nax.stories.total",
+    sum: {
+      aggregationTemporality: 2,
+      isMonotonic: true,
+      dataPoints: statusEntries.map(([status, count]) => ({
+        asInt: String(count),
+        timeUnixNano: p.timeUnixNano,
+        attributes: [attr("status", status)]
+      }))
+    }
+  };
+  const gauge = (name, value) => ({
+    name,
+    gauge: { dataPoints: [{ asDouble: value, timeUnixNano: p.timeUnixNano }] }
+  });
+  return {
+    resourceMetrics: [
+      {
+        resource: { attributes: [attr("service.name", p.serviceName)] },
+        scopeMetrics: [
+          {
+            scope: { name: "nax" },
+            metrics: [storiesSum, gauge("nax.run.cost", p.totalCost), gauge("nax.run.duration_ms", p.totalDurationMs)]
+          }
+        ]
+      }
+    ]
+  };
+}
+
+// src/plugins/builtin/otel-reporter/index.ts
+function createOtelReporterPlugin(cfg, deps) {
+  const states = new Map;
+  const base = cfg.endpoint?.replace(/\/$/, "");
+  const flush = async (st, endMs, e) => {
+    if (!base)
+      return;
+    const { resolved, missing } = interpolateHeaders(cfg.headers);
+    if (missing.length > 0) {
+      getSafeLogger()?.warn(STAGE, "Skipping OTLP export \u2014 unresolved env vars", { missing });
+      return;
+    }
+    const startUnixNano = msToUnixNano(st.startMs);
+    const endUnixNano = msToUnixNano(endMs);
+    const traces = buildTracesPayload({
+      serviceName: cfg.serviceName,
+      traceId: st.traceId,
+      spanId: st.spanId,
+      startUnixNano,
+      endUnixNano,
+      feature: st.feature,
+      runId: e.runId,
+      storySummary: e.storySummary,
+      totalCost: e.totalCost,
+      events: st.events
+    });
+    const metrics = buildMetricsPayload({
+      serviceName: cfg.serviceName,
+      runId: e.runId,
+      timeUnixNano: endUnixNano,
+      storySummary: e.storySummary,
+      totalCost: e.totalCost,
+      totalDurationMs: e.totalDurationMs
+    });
+    const opts = { headers: resolved, timeoutMs: cfg.timeoutMs, stage: STAGE, deps };
+    await postJson(`${base}/v1/traces`, traces, opts);
+    await postJson(`${base}/v1/metrics`, metrics, opts);
+  };
+  const reporter = {
+    name: STAGE,
+    async onRunStart(event) {
+      states.set(event.runId, {
+        traceId: newTraceId(),
+        spanId: newSpanId(),
+        startMs: Date.parse(event.startTime),
+        feature: event.feature,
+        events: []
+      });
+    },
+    async onStoryComplete(event) {
+      const st = states.get(event.runId);
+      if (!st)
+        return;
+      st.events.push({
+        timeUnixNano: msToUnixNano(st.startMs + event.runElapsedMs),
+        name: "story.complete",
+        attributes: [
+          attr("storyId", event.storyId),
+          attr("status", event.status),
+          attr("cost", event.cost),
+          attr("tier", event.tier),
+          attr("testStrategy", event.testStrategy)
+        ]
+      });
+    },
+    async onRunEnd(event) {
+      const existing = states.get(event.runId);
+      const startMs = existing?.startMs ?? Date.now() - event.totalDurationMs;
+      const st = existing ?? {
+        traceId: newTraceId(),
+        spanId: newSpanId(),
+        startMs,
+        feature: "",
+        events: []
+      };
+      states.delete(event.runId);
+      await flush(st, startMs + event.totalDurationMs, event);
+    }
+  };
+  return {
+    name: STAGE,
+    version: "1.0.0",
+    provides: ["reporter"],
+    extensions: { reporter }
+  };
+}
+var STAGE = "otel-reporter";
+var init_otel_reporter = __esm(() => {
+  init_logger2();
+  init_reporter_shared();
+});
+
+// src/plugins/builtin/webhook-reporter/index.ts
+function createWebhookReporterPlugin(cfg, deps) {
+  const enabledEvent = (event) => cfg.events === undefined || cfg.events.includes(event);
+  const emit = async (type, data) => {
+    if (!cfg.url || !enabledEvent(type))
+      return;
+    const { resolved, missing } = interpolateHeaders(cfg.headers);
+    if (missing.length > 0) {
+      getSafeLogger()?.warn(STAGE2, "Skipping webhook \u2014 unresolved env vars", { missing });
+      return;
+    }
+    await postJson(cfg.url, { type, emittedAt: new Date().toISOString(), data }, { headers: resolved, timeoutMs: cfg.timeoutMs, stage: STAGE2, deps });
+  };
+  const reporter = {
+    name: STAGE2,
+    onRunStart: (event) => emit("onRunStart", event),
+    onStoryComplete: (event) => emit("onStoryComplete", event),
+    onRunEnd: (event) => emit("onRunEnd", event)
+  };
+  return {
+    name: STAGE2,
+    version: "1.0.0",
+    provides: ["reporter"],
+    extensions: { reporter }
+  };
+}
+var STAGE2 = "webhook-reporter";
+var init_webhook_reporter = __esm(() => {
+  init_logger2();
+  init_reporter_shared();
+});
+
 // src/plugins/plugin-logger.ts
 function createPluginLogger(pluginName) {
   const stage = `plugin:${pluginName}`;
@@ -63777,7 +64086,7 @@ function extractPluginName(pluginPath) {
   }
   return basename12.replace(/\.(ts|js|mjs)$/, "");
 }
-async function loadPlugins(globalDir, projectDir, configPlugins, projectRoot, disabledPlugins, isTestFileFn) {
+async function loadPlugins(globalDir, projectDir, configPlugins, projectRoot, disabledPlugins, isTestFileFn, reporters) {
   const loadedPlugins = [];
   const builtinPostRunActions = [];
   const effectiveProjectRoot = projectRoot || projectDir;
@@ -63821,6 +64130,32 @@ async function loadPlugins(globalDir, projectDir, configPlugins, projectRoot, di
   } else {
     logger?.info("plugins", `Skipping disabled plugin: '${autoRoutePlugin.name}' (built-in)`);
   }
+  const reporterFactories = reporters ? [
+    {
+      name: "webhook-reporter",
+      enabled: reporters.webhook.enabled,
+      make: () => createWebhookReporterPlugin(reporters.webhook)
+    },
+    {
+      name: "otel-reporter",
+      enabled: reporters.otel.enabled,
+      make: () => createOtelReporterPlugin(reporters.otel)
+    }
+  ] : [];
+  for (const { name, enabled: reporterEnabled, make } of reporterFactories) {
+    if (!reporterEnabled)
+      continue;
+    if (disabledSet.has(name)) {
+      logger?.info("plugins", `Skipping disabled plugin: '${name}' (built-in)`);
+      continue;
+    }
+    const plugin = make();
+    if (plugin.setup) {
+      await plugin.setup({}, createPluginLogger(plugin.name));
+    }
+    loadedPlugins.push({ plugin, source: { type: "builtin", path: plugin.name } });
+    pluginNames.add(plugin.name);
+  }
   const globalPlugins = await discoverPlugins(globalDir, isTestFileFn);
   for (const plugin of globalPlugins) {
     const pluginName = extractPluginName(plugin.path);
@@ -63985,6 +64320,8 @@ var init_loader4 = __esm(() => {
   init_auto_pr();
   init_auto_route();
   init_curator();
+  init_otel_reporter();
+  init_webhook_reporter();
   init_plugin_logger();
   init_registry5();
   init_validator();
@@ -70674,7 +71011,7 @@ async function setupRun(options) {
     const configPlugins = config2.plugins || [];
     const resolvedPatterns = await resolveTestFilePatterns(config2, workdir);
     const isTestFileFn = (filename) => resolvedPatterns.regex.some((re) => re.test(filename));
-    const pluginRegistry = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, workdir, config2.disabledPlugins, isTestFileFn);
+    const pluginRegistry = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, workdir, config2.disabledPlugins, isTestFileFn, config2.reporters);
     clearCache();
     logger?.info("plugins", `Loaded ${pluginRegistry.plugins.length} plugins`, {
       plugins: pluginRegistry.plugins.map((p) => ({ name: p.name, version: p.version, provides: p.provides }))
@@ -86662,13 +86999,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           return false;
         }
         function utils_getInObject(object2, path31) {
-          return path31.reduce(function(reduced, attr) {
+          return path31.reduce(function(reduced, attr2) {
             if (reduced) {
-              if (utils_hasOwnProperty.call(reduced, attr)) {
-                return reduced[attr];
+              if (utils_hasOwnProperty.call(reduced, attr2)) {
+                return reduced[attr2];
               }
               if (typeof reduced[Symbol.iterator] === "function") {
-                return Array.from(reduced)[attr];
+                return Array.from(reduced)[attr2];
               }
             }
             return null;
@@ -97663,9 +98000,9 @@ The error thrown in the component is:
             getEnvironmentNames
           }, internalMcpFunctions);
         }
-        function decorate(object2, attr, fn) {
-          var old = object2[attr];
-          object2[attr] = function(instance2) {
+        function decorate(object2, attr2, fn) {
+          var old = object2[attr2];
+          object2[attr2] = function(instance2) {
             return fn.call(this, old, arguments);
           };
           return old;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nathapp/nax",
-  "version": "0.73.3",
+  "version": "0.73.4",
   "description": "AI Coding Agent Orchestrator — loops until done",
   "type": "module",
   "bin": {