@graphrefly/graphrefly 0.19.0 → 0.21.0

package/dist/index.js

@@ -136,16 +136,26 @@ import {
   workerBridge,
   workerSelf,
   zip
-} from "./chunk-BER7UYLM.js";
+} from "./chunk-ECN37NVS.js";
 import {
   cqrs_exports,
-  nestjs_exports
-} from "./chunk-OO5QOAXI.js";
+  domainMeta,
+  nestjs_exports,
+  trackingKey
+} from "./chunk-XWBVAO2R.js";
+import {
+  JsonCodec,
+  createDagCborCodec,
+  createDagCborZstdCodec,
+  graph_exports,
+  negotiateCodec,
+  replayWAL
+} from "./chunk-G66H6ZRK.js";
 import {
   DEFAULT_DOWN,
   bridge,
   core_exports
-} from "./chunk-AHRKWMNI.js";
+} from "./chunk-DOSLSFKL.js";
 import {
   cached,
   createWatermarkController,
@@ -163,12 +173,14 @@ import {
   fromPromise,
   fromTimer,
   globToRegExp,
+  keepalive,
   logSlice,
   matchesAnyPattern,
   matchesCron,
   never,
   of,
   parseCron,
+  reactiveCounter,
   reactiveLog,
   replay,
   share,
@@ -176,34 +188,26 @@ import {
   throwError,
   toArray,
   toObservable
-} from "./chunk-IRZAGZUB.js";
+} from "./chunk-VOQFK7YN.js";
 import {
   ResettableTimer
 } from "./chunk-WZ2Z2CRV.js";
-import {
-  JsonCodec,
-  createDagCborCodec,
-  createDagCborZstdCodec,
-  graph_exports,
-  negotiateCodec,
-  replayWAL
-} from "./chunk-YLR5JUJZ.js";
 import {
   analyzeAndMeasure,
   computeLineBreaks,
   reactive_layout_exports
-} from "./chunk-UW77D7SP.js";
+} from "./chunk-ZTCDY5NQ.js";
 import {
   GRAPH_META_SEGMENT,
   Graph,
   graphProfile,
   reachable,
   sizeof
-} from "./chunk-JC2SN46B.js";
+} from "./chunk-2UDLYZHT.js";
 import {
   describeNode,
   resolveDescribeFields
-} from "./chunk-XUOY3YKN.js";
+} from "./chunk-7IGHIFTT.js";
 import {
   CLEANUP_RESULT,
   COMPLETE,
@@ -249,7 +253,7 @@ import {
   propagatesToMeta,
   state,
   wallClockNs
-} from "./chunk-YXR3WW3Q.js";
+} from "./chunk-4MQ2J6IG.js";
 
 // src/compat/index.ts
 var compat_exports = {};
@@ -1101,6 +1105,7 @@ __export(ai_exports, {
   agentLoop: () => agentLoop,
   agentMemory: () => agentMemory,
   chatStream: () => chatStream,
+  contentGate: () => contentGate,
   costMeterExtractor: () => costMeterExtractor,
   fromLLM: () => fromLLM,
   gatedStream: () => gatedStream,
@@ -1111,6 +1116,7 @@ __export(ai_exports, {
   llmConsolidator: () => llmConsolidator,
   llmExtractor: () => llmExtractor,
   promptNode: () => promptNode,
+  redactor: () => redactor,
   streamExtractor: () => streamExtractor,
   streamingPromptNode: () => streamingPromptNode,
   suggestStrategy: () => suggestStrategy,
@@ -1517,16 +1523,8 @@ function requireNonNegativeInt(value, label) {
   }
   return value;
 }
-function keepalive(n) {
-  return n.subscribe(() => {
-  });
-}
 function messagingMeta(kind, extra) {
-  return {
-    messaging: true,
-    messaging_type: kind,
-    ...extra ?? {}
-  };
+  return domainMeta("messaging", kind, extra);
 }
 var TopicGraph = class extends Graph {
   _log;
@@ -1909,11 +1907,7 @@ function registerStep(graph, name, step, depPaths) {
   }
 }
 function baseMeta(kind, meta) {
-  return {
-    orchestration: true,
-    orchestration_type: kind,
-    ...meta ?? {}
-  };
+  return domainMeta("orchestration", kind, meta);
 }
 function coerceLoopIterations(raw) {
   const parseString = (value) => {
@@ -2359,14 +2353,7 @@ function onFailure(graph, name, source, recover, opts) {
 
 // src/patterns/ai.ts
 function aiMeta(kind, extra) {
-  return {
-    ai: true,
-    ai_type: kind,
-    ...extra ?? {}
-  };
-}
-function keepalive2(n) {
-  return n.subscribe(() => void 0);
+  return domainMeta("ai", kind, extra);
 }
 function isPromiseLike(x) {
   return x != null && typeof x.then === "function";
@@ -2500,7 +2487,7 @@ function streamingPromptNode(adapter, deps, prompt, opts) {
     }
     return fromAny(pumpAndCollect());
   });
-  const unsub = keepalive2(output);
+  const unsub = keepalive(output);
   return {
     output,
     stream: streamTopic,
@@ -2626,6 +2613,53 @@ function costMeterExtractor(streamTopic, opts) {
     }
   );
 }
+function redactor(streamTopic, patterns, replaceFn, opts) {
+  const replace = replaceFn ?? (() => "[REDACTED]");
+  function sanitize(text) {
+    let result = text;
+    for (const pat of patterns) {
+      const global = pat.global ? pat : new RegExp(pat.source, `${pat.flags}g`);
+      result = result.replace(global, (m) => replace(m, pat));
+    }
+    return result;
+  }
+  return derived(
+    [streamTopic.latest],
+    ([chunk]) => {
+      if (chunk == null) {
+        return { source: "", token: "", accumulated: "", index: -1 };
+      }
+      const c = chunk;
+      const sanitizedAccumulated = sanitize(c.accumulated);
+      const sanitizedToken = sanitize(c.token);
+      return {
+        source: c.source,
+        token: sanitizedToken,
+        accumulated: sanitizedAccumulated,
+        index: c.index
+      };
+    },
+    { name: opts?.name ?? "redactor" }
+  );
+}
+function contentGate(streamTopic, classifier, threshold, opts) {
+  const hardThreshold = threshold * (opts?.hardMultiplier ?? 1.5);
+  const isNodeClassifier = typeof classifier !== "function";
+  const deps = [streamTopic.latest];
+  if (isNodeClassifier) deps.push(classifier);
+  return derived(
+    deps,
+    (values) => {
+      const chunk = values[0];
+      if (chunk == null) return "allow";
+      const score = isNodeClassifier ? values[1] ?? 0 : classifier(chunk.accumulated);
+      if (score >= hardThreshold) return "block";
+      if (score >= threshold) return "review";
+      return "allow";
+    },
+    { name: opts?.name ?? "content-gate", initial: "allow" }
+  );
+}
 function gatedStream(graph, name, adapter, deps, prompt, opts) {
   const cancelSignal = state(0, { name: `${name}/cancel` });
   let cancelCounter = 0;
@@ -2685,7 +2719,7 @@ function gatedStream(graph, name, adapter, deps, prompt, opts) {
     }
     return fromAny(pumpAndCollect());
   });
-  const unsub = keepalive2(output);
+  const unsub = keepalive(output);
   const nonNullOutput = derived(
     [output],
     ([v]) => {
@@ -2816,7 +2850,7 @@ var ChatStreamGraph = class extends Graph {
     );
     this.add("latest", this.latest);
     this.connect("messages", "latest");
-    this.addDisposer(keepalive2(this.latest));
+    this.addDisposer(keepalive(this.latest));
     this.messageCount = derived(
       [this.messages],
       ([snapshot]) => snapshot.length,
@@ -2829,7 +2863,7 @@ var ChatStreamGraph = class extends Graph {
     );
     this.add("messageCount", this.messageCount);
     this.connect("messages", "messageCount");
-    this.addDisposer(keepalive2(this.messageCount));
+    this.addDisposer(keepalive(this.messageCount));
   }
   append(role, content, extra) {
     this._log.append({ role, content, ...extra });
@@ -2870,7 +2904,7 @@ var ToolRegistryGraph = class extends Graph {
     );
     this.add("schemas", this.schemas);
     this.connect("definitions", "schemas");
-    this.addDisposer(keepalive2(this.schemas));
+    this.addDisposer(keepalive(this.schemas));
   }
   register(tool) {
     const current = this.definitions.get();
@@ -2912,7 +2946,7 @@ function systemPromptBuilder(sections, opts) {
       initial: ""
     }
   );
-  const unsub = keepalive2(prompt);
+  const unsub = keepalive(prompt);
   return Object.assign(prompt, { dispose: unsub });
 }
 function llmExtractor(systemPrompt, opts) {
@@ -4225,21 +4259,14 @@ __export(domain_templates_exports, {
 var reduction_exports = {};
 __export(reduction_exports, {
   budgetGate: () => budgetGate,
+  effectivenessTracker: () => effectivenessTracker,
   feedback: () => feedback,
   funnel: () => funnel,
   scorer: () => scorer,
   stratify: () => stratify
 });
 function baseMeta2(kind, meta) {
-  return {
-    reduction: true,
-    reduction_type: kind,
-    ...meta ?? {}
-  };
-}
-function keepalive3(n) {
-  return n.subscribe(() => {
-  });
+  return domainMeta("reduction", kind, meta);
 }
 function stratify(name, source, rules, opts) {
   const g = new Graph(name, opts);
@@ -4377,7 +4404,7 @@ function funnel(name, sources, stages, opts) {
     });
     g.add(bridgeName, br);
     g.connect(prevOutputPath, bridgeName);
-    g.addDisposer(keepalive3(br));
+    g.addDisposer(keepalive(br));
     prevOutputPath = `${stage.name}::output`;
   }
   return g;
@@ -4429,7 +4456,7 @@ function feedback(graph, condition, reentry, opts) {
   });
   graph.add(feedbackEffectName, feedbackEffect);
   graph.connect(condition, feedbackEffectName);
-  graph.addDisposer(keepalive3(feedbackEffect));
+  graph.addDisposer(keepalive(feedbackEffect));
   return graph;
 }
 function budgetGate(source, constraints, opts) {
@@ -4563,14 +4590,55 @@ function scorer(sources, weights, opts) {
     }
   );
 }
-
-// src/patterns/domain-templates.ts
-function keepalive4(n) {
-  return n.subscribe(() => {
+function effectivenessTracker(opts) {
+  const _map = reactiveMap({
+    name: opts?.name ?? "effectiveness-entries"
   });
+  const snapshot = derived(
+    [_map.entries],
+    ([mapSnap]) => {
+      return new Map(mapSnap);
+    },
+    {
+      name: `${opts?.name ?? "effectiveness"}-snapshot`,
+      equals: (a, b) => {
+        const am = a;
+        const bm = b;
+        if (am.size !== bm.size) return false;
+        for (const [k, v] of am) {
+          const bv = bm.get(k);
+          if (!bv || v.attempts !== bv.attempts || v.successes !== bv.successes) return false;
+        }
+        return true;
+      }
+    }
+  );
+  function record(key, success) {
+    const existing = _map.get(key);
+    const attempts = (existing?.attempts ?? 0) + 1;
+    const successes = (existing?.successes ?? 0) + (success ? 1 : 0);
+    _map.set(key, {
+      key,
+      attempts,
+      successes,
+      successRate: successes / attempts
+    });
+  }
+  function lookup(key) {
+    return _map.get(key);
+  }
+  const _unsub = keepalive(snapshot);
+  return {
+    node: snapshot,
+    record,
+    lookup,
+    dispose: () => _unsub()
+  };
 }
+
+// src/patterns/domain-templates.ts
 function baseMeta3(kind, extra) {
-  return { domain_template: true, template_type: kind, ...extra ?? {} };
+  return domainMeta("domain_template", kind, extra);
 }
 function observabilityGraph(name, opts) {
   const g = new Graph(name, opts);
@@ -4810,7 +4878,7 @@ function contentModerationGraph(name, opts) {
     }
   });
   g.add("__review_accumulator", reviewAccumulator);
-  g.addDisposer(keepalive4(reviewAccumulator));
+  g.addDisposer(keepalive(reviewAccumulator));
   try {
     g.connect("stratify::branch/review", "__review_accumulator");
   } catch {
@@ -4921,7 +4989,7 @@ function dataQualityGraph(name, opts) {
   });
   g.add("__baseline_updater", baselineUpdater);
   g.connect("validate", "__baseline_updater");
-  keepalive4(baselineUpdater);
+  keepalive(baselineUpdater);
   const detectDriftFn = opts.detectDrift ?? (() => ({ drift: false }));
   const driftNode = derived(
     [opts.source, baseline],
@@ -6011,52 +6079,179 @@ __export(harness_exports, {
   DEFAULT_SEVERITY_WEIGHTS: () => DEFAULT_SEVERITY_WEIGHTS,
   HarnessGraph: () => HarnessGraph,
   QUEUE_NAMES: () => QUEUE_NAMES,
+  affectedTaskFilter: () => affectedTaskFilter,
+  beforeAfterCompare: () => beforeAfterCompare,
+  codeChangeBridge: () => codeChangeBridge,
+  createIntakeBridge: () => createIntakeBridge,
   defaultErrorClassifier: () => defaultErrorClassifier,
   evalIntakeBridge: () => evalIntakeBridge,
+  evalSource: () => evalSource,
   harnessLoop: () => harnessLoop,
   harnessProfile: () => harnessProfile,
   harnessTrace: () => harnessTrace,
+  notifyEffect: () => notifyEffect,
   priorityScore: () => priorityScore,
   strategyKey: () => strategyKey,
   strategyModel: () => strategyModel
 });
 
 // src/patterns/harness/bridge.ts
-function evalIntakeBridge(evalSource, intakeTopic, opts) {
+function createIntakeBridge(source, intakeTopic, parser, opts) {
+  return effect(
+    [source],
+    ([value]) => {
+      if (value == null) return;
+      const items = parser(value);
+      for (const item of items) {
+        intakeTopic.publish(item);
+      }
+    },
+    { name: opts?.name ?? "intake-bridge" }
+  );
+}
+function evalIntakeBridge(evalSource2, intakeTopic, opts) {
   const defaultSeverity = opts?.defaultSeverity ?? "medium";
-  return effect([evalSource], ([results]) => {
-    if (results == null) return;
-    const runs = Array.isArray(results) ? results : [results];
-    for (const run of runs) {
-      for (const task2 of run.tasks) {
-        if (task2.valid && task2.judge_scores?.every((s) => s.pass)) continue;
-        if (!task2.valid && (!task2.judge_scores || task2.judge_scores.length === 0)) {
-          intakeTopic.publish({
-            source: "eval",
-            summary: `Task ${task2.task_id} invalid (model: ${run.model})`,
-            evidence: `Run ${run.run_id}: task produced invalid output`,
-            affectsAreas: ["graphspec"],
-            affectsEvalTasks: [task2.task_id],
-            severity: defaultSeverity
-          });
-          continue;
-        }
-        if (task2.judge_scores) {
-          for (const score of task2.judge_scores) {
-            if (score.pass) continue;
+  return effect(
+    [evalSource2],
+    ([results]) => {
+      if (results == null) return;
+      const runs = Array.isArray(results) ? results : [results];
+      for (const run of runs) {
+        for (const task2 of run.tasks) {
+          if (task2.valid && task2.judge_scores?.every((s) => s.pass)) continue;
+          if (!task2.valid && (!task2.judge_scores || task2.judge_scores.length === 0)) {
             intakeTopic.publish({
               source: "eval",
-              summary: `${task2.task_id}: ${score.claim} (model: ${run.model})`,
-              evidence: score.reasoning,
+              summary: `Task ${task2.task_id} invalid (model: ${run.model})`,
+              evidence: `Run ${run.run_id}: task produced invalid output`,
               affectsAreas: ["graphspec"],
               affectsEvalTasks: [task2.task_id],
               severity: defaultSeverity
             });
+            continue;
           }
+          if (task2.judge_scores) {
+            for (const score of task2.judge_scores) {
+              if (score.pass) continue;
+              intakeTopic.publish({
+                source: "eval",
+                summary: `${task2.task_id}: ${score.claim} (model: ${run.model})`,
+                evidence: score.reasoning,
+                affectsAreas: ["graphspec"],
+                affectsEvalTasks: [task2.task_id],
+                severity: defaultSeverity
+              });
+            }
+          }
+        }
+      }
+    },
+    { name: opts?.name ?? "eval-intake-bridge" }
+  );
+}
+function evalSource(trigger2, runner) {
+  return switchMap(trigger2, () => fromAny(runner()));
+}
+function beforeAfterCompare(before, after) {
+  return derived(
+    [before, after],
+    ([b, a]) => {
+      const bRes = b;
+      const aRes = a;
+      const beforeMap = new Map(bRes.tasks.map((t) => [t.task_id, t]));
+      const afterMap = new Map(aRes.tasks.map((t) => [t.task_id, t]));
+      const allIds = /* @__PURE__ */ new Set([...beforeMap.keys(), ...afterMap.keys()]);
+      const taskDeltas = [];
+      const newFailures = [];
+      const resolved = [];
+      for (const id of allIds) {
+        const bt = beforeMap.get(id);
+        const at = afterMap.get(id);
+        const beforeValid = bt?.valid ?? false;
+        const afterValid = at?.valid ?? false;
+        const beforeScore = bt?.judge_scores ? bt.judge_scores.filter((s) => s.pass).length : void 0;
+        const afterScore = at?.judge_scores ? at.judge_scores.filter((s) => s.pass).length : void 0;
+        const scoreDiff = beforeScore !== void 0 && afterScore !== void 0 ? afterScore - beforeScore : void 0;
+        taskDeltas.push({ taskId: id, before: beforeValid, after: afterValid, scoreDiff });
+        if (beforeValid && !afterValid) newFailures.push(id);
+        if (!beforeValid && afterValid) resolved.push(id);
+      }
+      return {
+        newFailures,
+        resolved,
+        taskDeltas,
+        overallImproved: resolved.length > newFailures.length
+      };
+    },
+    { name: "eval-delta" }
+  );
+}
+function affectedTaskFilter(issues, fullTaskSet) {
+  const taskSetNode = fullTaskSet == null ? null : Array.isArray(fullTaskSet) ? state(fullTaskSet) : fullTaskSet;
+  const deps = [issues];
+  if (taskSetNode) deps.push(taskSetNode);
+  return derived(
+    deps,
+    (values) => {
+      const items = values[0];
+      const all = taskSetNode ? new Set(values[1]) : null;
+      const affected = /* @__PURE__ */ new Set();
+      for (const item of items) {
+        for (const id of item.affectsEvalTasks ?? []) {
+          if (all == null || all.has(id)) affected.add(id);
         }
       }
+      return [...affected].sort();
+    },
+    { name: "affected-task-filter" }
+  );
+}
+function codeChangeBridge(source, intakeTopic, parser, opts) {
+  const defaultSeverity = opts?.defaultSeverity ?? "high";
+  function defaultParser(change) {
+    const items = [];
+    for (const err of change.lintErrors ?? []) {
+      items.push({
+        source: "code-change",
+        summary: `Lint: ${err.rule} in ${err.file}:${err.line}`,
+        evidence: err.message,
+        affectsAreas: [err.file],
+        severity: defaultSeverity
+      });
     }
-  });
+    for (const fail of change.testFailures ?? []) {
+      items.push({
+        source: "test",
+        summary: `Test failure: ${fail.testId}`,
+        evidence: fail.message,
+        affectsAreas: [fail.file],
+        affectsEvalTasks: [fail.testId],
+        severity: defaultSeverity
+      });
+    }
+    return items;
+  }
+  const resolve = parser ?? defaultParser;
+  return effect(
+    [source],
+    ([change]) => {
+      if (change == null) return;
+      for (const item of resolve(change)) {
+        intakeTopic.publish(item);
+      }
+    },
+    { name: opts?.name ?? "code-change-bridge" }
+  );
+}
+function notifyEffect(topic2, transport, opts) {
+  return effect(
+    [topic2.latest],
+    ([item]) => {
+      if (item == null) return;
+      void transport(item);
+    },
+    { name: opts?.name ?? "notify-effect" }
+  );
 }
 
 // src/patterns/harness/types.ts
@@ -6166,9 +6361,6 @@ function priorityScore(item, strategy, lastInteractionNs, urgency, signals) {
 }
 
 // src/patterns/harness/loop.ts
-function trackingKey(item) {
-  return item.relatedTo?.[0] ?? item.summary;
-}
 var DEFAULT_TRIAGE_PROMPT = `You are a triage classifier for a reactive collaboration harness.
 
 Given an intake item, classify it and output JSON:
@@ -6684,6 +6876,7 @@ export {
   isTerminalMessage,
   isV1,
   jotai_exports as jotai,
+  keepalive,
   knownMessageTypes,
   last,
   reactive_layout_exports as layout,
@@ -6726,6 +6919,7 @@ export {
   rateLimiter,
   reachable,
   react_exports as react,
+  reactiveCounter,
   reactiveIndex,
   reactiveList,
   reactiveLog,