@graphrefly/graphrefly 0.44.0 → 0.46.0

package/dist/utils/harness/index.cjs

@@ -0,0 +1,656 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/harness/index.ts
+var harness_exports = {};
+__export(harness_exports, {
+  DEFAULT_DECAY_RATE: () => DEFAULT_DECAY_RATE,
+  DEFAULT_EXECUTE_PROMPT: () => DEFAULT_EXECUTE_PROMPT,
+  DEFAULT_PRESET_ID: () => DEFAULT_PRESET_ID,
+  DEFAULT_QUEUE_CONFIGS: () => DEFAULT_QUEUE_CONFIGS,
+  DEFAULT_SEVERITY_WEIGHTS: () => DEFAULT_SEVERITY_WEIGHTS,
+  DEFAULT_TRIAGE_PROMPT: () => DEFAULT_TRIAGE_PROMPT,
+  DEFAULT_VERIFY_PROMPT: () => DEFAULT_VERIFY_PROMPT,
+  QUEUE_NAMES: () => QUEUE_NAMES,
+  actuatorExecutor: () => actuatorExecutor,
+  affectedTaskFilter: () => affectedTaskFilter,
+  autoSolidify: () => autoSolidify,
+  beforeAfterCompare: () => beforeAfterCompare,
+  codeChangeBridge: () => codeChangeBridge,
+  createIntakeBridge: () => createIntakeBridge,
+  defaultErrorClassifier: () => defaultErrorClassifier,
+  dispatchActuator: () => dispatchActuator,
+  evalIntakeBridge: () => evalIntakeBridge,
+  evalSource: () => evalSource,
+  notifyEffect: () => notifyEffect,
+  priorityScore: () => priorityScore,
+  resolvePromptFn: () => resolvePromptFn,
+  strategyKey: () => strategyKey,
+  strategyModel: () => strategyModel
+});
+module.exports = __toCommonJS(harness_exports);
+
+// src/utils/harness/actuator-executor.ts
+var import_core = require("@graphrefly/pure-ts/core");
+var import_extra = require("@graphrefly/pure-ts/extra");
+function defaultToOutput(record, item) {
+  return {
+    outcome: "success",
+    detail: `actuator applied ${item.intervention} for ${truncate(item.summary)}`,
+    artifact: record
+  };
+}
+function defaultOnError(err, item) {
+  const message = err instanceof Error ? err.message : String(err);
+  return {
+    outcome: "failure",
+    detail: `actuator threw on ${item.intervention}: ${message}`
+  };
+}
+function defaultSkipDetail(item) {
+  return `actuator skipped ${item.intervention} (shouldApply returned false)`;
+}
+function truncate(s, max = 80) {
+  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+}
+function actuatorExecutor(config) {
+  const name = config.name ?? "actuator-executor";
+  const toOutput = config.toOutput ?? defaultToOutput;
+  const onError = config.onError ?? defaultOnError;
+  const skipDetail = config.skipDetail ?? defaultSkipDetail;
+  return (job, opts) => {
+    const item = job.payload.item;
+    if (config.shouldApply && !config.shouldApply(item)) {
+      return {
+        ...job.payload,
+        execution: { item, outcome: "failure", detail: skipDetail(item) }
+      };
+    }
+    return (0, import_core.node)(
+      [],
+      (_data, actions) => {
+        const ac = new AbortController();
+        const parentSignal = opts?.signal;
+        let unlinkParent = () => void 0;
+        if (parentSignal) {
+          if (parentSignal.aborted) {
+            ac.abort();
+          } else {
+            const onParentAbort = () => ac.abort();
+            parentSignal.addEventListener("abort", onParentAbort, { once: true });
+            unlinkParent = () => parentSignal.removeEventListener("abort", onParentAbort);
+          }
+        }
+        let captured = false;
+        let unsub = null;
+        const emitOnce = (out) => {
+          if (captured) return;
+          captured = true;
+          actions.down([
+            [import_core.DATA, { ...job.payload, execution: { item, ...out } }],
+            [import_core.COMPLETE]
+          ]);
+          unsub?.();
+          unsub = null;
+        };
+        let inner;
+        try {
+          const rawResult = config.apply(item, { signal: ac.signal });
+          inner = (0, import_extra.fromAny)(rawResult, { signal: ac.signal });
+        } catch (err) {
+          emitOnce(onError(err, item));
+          return () => {
+            unlinkParent();
+            ac.abort();
+          };
+        }
+        unsub = inner.subscribe((batch) => {
+          for (const m of batch) {
+            if (captured) return;
+            if (m[0] === import_core.DATA) {
+              emitOnce(toOutput(m[1], item));
+              return;
+            }
+            if (m[0] === import_core.ERROR) {
+              emitOnce(onError(m[1], item));
+              return;
+            }
+            if (m[0] === import_core.COMPLETE) {
+              emitOnce(onError(new Error("actuator inner completed without emitting DATA"), item));
+              return;
+            }
+          }
+        });
+        if (captured && unsub) {
+          unsub();
+          unsub = null;
+        }
+        return () => {
+          unlinkParent();
+          ac.abort();
+          unsub?.();
+          unsub = null;
+        };
+      },
+      { name: `${name}/inner`, describeKind: "producer" }
+    );
+  };
+}
+function dispatchActuator(config) {
+  const name = config.name ?? "dispatch-actuator";
+  const defaultFn = config.default ?? null;
+  const hasDefault = defaultFn != null;
+  return actuatorExecutor({
+    apply: (item, opts) => {
+      const fn = Object.hasOwn(config.routes, item.intervention) ? config.routes[item.intervention] : defaultFn;
+      if (!fn) {
+        throw new Error(`dispatchActuator: no route for intervention '${item.intervention}'`);
+      }
+      return fn(item, opts);
+    },
+    shouldApply: (item) => Object.hasOwn(config.routes, item.intervention) || hasDefault,
+    skipDetail: (item) => `no route for intervention '${item.intervention}'`,
+    name
+  });
+}
+
+// src/utils/harness/auto-solidify.ts
+var import_core2 = require("@graphrefly/pure-ts/core");
+function autoSolidify(config) {
+  const name = config.name ?? "auto-solidify";
+  const extract = config.extract ?? ((vr) => vr.execution.artifact ?? null);
+  const predicate = config.predicate ?? (() => true);
+  return (0, import_core2.node)(
+    [],
+    (_data, actions) => {
+      let unsub = null;
+      let terminated = false;
+      const tearDown = () => {
+        if (terminated) return;
+        terminated = true;
+        unsub?.();
+        unsub = null;
+      };
+      const emitTerminalError = (err) => {
+        if (terminated) return;
+        actions.down([[import_core2.ERROR, err]]);
+        tearDown();
+      };
+      unsub = config.verifyResults.subscribe((batch) => {
+        if (terminated) return;
+        for (const m of batch) {
+          if (terminated) return;
+          if (m[0] !== import_core2.DATA) {
+            if (m[0] === import_core2.COMPLETE) {
+              actions.down([[import_core2.COMPLETE]]);
+              tearDown();
+              return;
+            }
+            continue;
+          }
+          const vr = m[1];
+          if (vr == null) continue;
+          if (!vr.verified) continue;
+          let pass;
+          try {
+            pass = predicate(vr);
+          } catch (err) {
+            emitTerminalError(err);
+            return;
+          }
+          if (!pass) continue;
+          let artifact;
+          try {
+            artifact = extract(vr);
+          } catch (err) {
+            emitTerminalError(err);
+            return;
+          }
+          if (artifact == null) continue;
+          try {
+            config.write(artifact, vr);
+          } catch (err) {
+            emitTerminalError(err);
+            return;
+          }
+          actions.down([[import_core2.DATA, artifact]]);
+        }
+      });
+      if (terminated && unsub) {
+        unsub();
+        unsub = null;
+      }
+      return () => {
+        tearDown();
+      };
+    },
+    { name, describeKind: "producer" }
+  );
+}
+
+// src/utils/harness/bridge.ts
+var import_core3 = require("@graphrefly/pure-ts/core");
+var import_extra2 = require("@graphrefly/pure-ts/extra");
+function createIntakeBridge(opts) {
+  const { graph, source, intakeTopic, parser, name = "intake-bridge" } = opts;
+  const eff = (0, import_core3.node)(
+    [source],
+    (batchData, _actions, ctx) => {
+      const data = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      const value = data[0];
+      if (value === void 0) return;
+      const items = parser(value);
+      for (const item of items) {
+        intakeTopic.publish(item);
+      }
+    },
+    { describeKind: "effect" }
+  );
+  graph.add(eff, { name });
+  return eff;
+}
+function evalIntakeBridge(opts) {
+  const {
+    graph,
+    source,
+    intakeTopic,
+    name = "eval-intake-bridge",
+    defaultSeverity = "medium"
+  } = opts;
+  const eff = (0, import_core3.node)(
+    [source],
+    (batchData, _actions, ctx) => {
+      const data = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      const results = data[0];
+      if (results === void 0) return;
+      const runs = Array.isArray(results) ? results : [results];
+      for (const run of runs) {
+        for (const task of run.tasks) {
+          if (task.valid && task.judge_scores?.every((s) => s.pass)) continue;
+          if (!task.valid && (!task.judge_scores || task.judge_scores.length === 0)) {
+            intakeTopic.publish({
+              source: "eval",
+              summary: `Task ${task.task_id} invalid (model: ${run.model})`,
+              evidence: `Run ${run.run_id}: task produced invalid output`,
+              affectsAreas: ["graphspec"],
+              affectsEvalTasks: [task.task_id],
+              severity: defaultSeverity
+            });
+            continue;
+          }
+          if (task.judge_scores) {
+            for (const score of task.judge_scores) {
+              if (score.pass) continue;
+              intakeTopic.publish({
+                source: "eval",
+                summary: `${task.task_id}: ${score.claim} (model: ${run.model})`,
+                evidence: score.reasoning,
+                affectsAreas: ["graphspec"],
+                affectsEvalTasks: [task.task_id],
+                severity: defaultSeverity
+              });
+            }
+          }
+        }
+      }
+    },
+    { describeKind: "effect" }
+  );
+  graph.add(eff, { name });
+  return eff;
+}
+function evalSource(trigger, runner) {
+  return (0, import_extra2.switchMap)(trigger, () => (0, import_extra2.fromAny)(runner()));
+}
+function beforeAfterCompare(opts) {
+  const { graph, before, after, name = "eval-delta" } = opts;
+  const der = (0, import_core3.node)(
+    [before, after],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      const bRes = data[0];
+      const aRes = data[1];
+      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);
+      }
+      actions.emit({
+        newFailures,
+        resolved,
+        taskDeltas,
+        overallImproved: resolved.length > newFailures.length
+      });
+    },
+    { describeKind: "derived" }
+  );
+  graph.add(der, { name });
+  return der;
+}
+function affectedTaskFilter(opts) {
+  const { graph, issues, fullTaskSet, name = "affected-task-filter" } = opts;
+  let taskSetNode = null;
+  if (fullTaskSet != null) {
+    if (Array.isArray(fullTaskSet)) {
+      const inlineSet = (0, import_core3.node)([], { initial: fullTaskSet });
+      graph.add(inlineSet, { name: `${name}/fullTaskSet` });
+      taskSetNode = inlineSet;
+    } else {
+      taskSetNode = fullTaskSet;
+    }
+  }
+  const deps = [issues];
+  if (taskSetNode) deps.push(taskSetNode);
+  const der = (0, import_core3.node)(
+    deps,
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      const items = data[0];
+      const all = taskSetNode ? new Set(data[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);
+        }
+      }
+      actions.emit([...affected].sort());
+    },
+    { describeKind: "derived" }
+  );
+  graph.add(der, { name });
+  return der;
+}
+function codeChangeBridge(opts) {
+  const {
+    graph,
+    source,
+    intakeTopic,
+    parser,
+    name = "code-change-bridge",
+    defaultSeverity = "high"
+  } = opts;
+  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;
+  const eff = (0, import_core3.node)(
+    [source],
+    (batchData, _actions, ctx) => {
+      const data = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      const change = data[0];
+      if (change === void 0) return;
+      for (const item of resolve(change)) {
+        intakeTopic.publish(item);
+      }
+    },
+    { describeKind: "effect" }
+  );
+  graph.add(eff, { name });
+  return eff;
+}
+function notifyEffect(opts) {
+  const { graph, topic, transport, name = "notify-effect" } = opts;
+  const eff = (0, import_core3.node)(
+    [topic.latest],
+    (batchData, _actions, ctx) => {
+      const data = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      const item = data[0];
+      if (item === void 0) return;
+      void transport(item);
+    },
+    { describeKind: "effect" }
+  );
+  graph.add(eff, { name });
+  return eff;
+}
+
+// src/base/utils/decay.ts
+var DEFAULT_DECAY_RATE = Math.LN2 / (7 * 86400);
+function decay(baseScore, ageSeconds, ratePerSecond, minScore = 0) {
+  if (!Number.isFinite(baseScore)) return minScore;
+  if (!Number.isFinite(ageSeconds) || ageSeconds <= 0) return Math.max(minScore, baseScore);
+  if (!Number.isFinite(ratePerSecond) || ratePerSecond <= 0) return Math.max(minScore, baseScore);
+  const decayed = baseScore * Math.exp(-ratePerSecond * ageSeconds);
+  return Math.max(minScore, decayed);
+}
+
+// src/utils/harness/defaults.ts
+var QUEUE_NAMES = [
+  "auto-fix",
+  "needs-decision",
+  "investigation",
+  "backlog"
+];
+var DEFAULT_QUEUE_CONFIGS = {
+  "auto-fix": { gated: false },
+  "needs-decision": { gated: true },
+  investigation: { gated: true },
+  // `startOpen` intentionally omitted — backlog is not gated, so the flag
+  // would be meaningless. Dropped in Unit 15 G trim pass.
+  backlog: { gated: false }
+};
+var DEFAULT_SEVERITY_WEIGHTS = {
+  critical: 100,
+  high: 70,
+  medium: 40,
+  low: 10
+};
+function strategyKey(presetId, rootCause, intervention) {
+  return `${presetId}|${rootCause}\u2192${intervention}`;
+}
+var SELF_CORRECTABLE_RE = /\b(parse|json|config|validation|syntax)\b/i;
+var defaultErrorClassifier = (result) => SELF_CORRECTABLE_RE.test(result.detail) ? "self-correctable" : "structural";
+var DEFAULT_TRIAGE_PROMPT = `You are a triage classifier for a reactive collaboration harness.
+
+Given an intake item, classify it and output JSON:
+{
+  "rootCause": "composition" | "missing-fn" | "bad-docs" | "schema-gap" | "regression" | "unknown",
+  "intervention": "template" | "catalog-fn" | "docs" | "wrapper" | "schema-change" | "investigate",
+  "route": "auto-fix" | "needs-decision" | "investigation" | "backlog",
+  "priority": <number 0-100>,
+  "triageReasoning": "<one sentence>"
+}
+
+Strategy model (past effectiveness):
+{{strategy}}
+
+Intake item:
+{{item}}`;
+var DEFAULT_EXECUTE_PROMPT = `You are an implementation agent.
+
+Given a triaged issue with root cause and intervention type, produce a fix.
+
+Issue:
+{{item}}
+
+Output JSON:
+{
+  "outcome": "success" | "failure" | "partial",
+  "detail": "<description of what was done or what failed>"
+}`;
+var DEFAULT_VERIFY_PROMPT = `You are a QA reviewer.
+
+Given an execution result, verify whether the fix is correct.
+
+Execution:
+{{execution}}
+
+Original issue:
+{{item}}
+
+Output JSON:
+{
+  "verified": true/false,
+  "findings": ["<finding1>", ...],
+  "errorClass": "self-correctable" | "structural"  // only if verified=false
+}`;
+function resolvePromptFn(raw, fallbackTemplate, substitute) {
+  if (typeof raw === "function") return raw;
+  const template = raw ?? fallbackTemplate;
+  return (input) => substitute(template, input);
+}
+
+// src/utils/harness/strategy.ts
+var import_core4 = require("@graphrefly/pure-ts/core");
+
+// src/utils/orchestration/audited-success-tracker.ts
+var import_extra3 = require("@graphrefly/pure-ts/extra");
+var import_graph = require("@graphrefly/pure-ts/graph");
+var AuditedSuccessTrackerGraph = class extends import_graph.Graph {
+  /** Reactive entries — `Node<ReadonlyMap<TKey, TEntry>>`, fresh map per mutation. */
+  entries;
+  _map;
+  constructor(opts) {
+    super(opts?.name ?? "audited-success-tracker", opts?.graph);
+    this._map = (0, import_extra3.reactiveMap)({ name: "entries" });
+    this.entries = this._map.entries;
+    this.add(this.entries, { name: "entries" });
+    this.addDisposer((0, import_extra3.keepalive)(this.entries));
+    this.addDisposer(() => this._map.dispose());
+  }
+  /**
+   * Record a completed attempt. `extra` fields are merged into the stored
+   * entry — use for domain-specific decoration (e.g. `{ rootCause,
+   * intervention }` on the strategy-model collapse path).
+   *
+   * **Caller contract for typed `TEntry`.** When `TEntry` extends
+   * {@link AuditedSuccessEntry} with required fields beyond
+   * `key`/`attempts`/`successes`/`successRate`, the caller must supply
+   * those required fields in `extra` on the **first** `record(key, ...)`
+   * for that key. The internal `as TEntry` cast trusts this. Subsequent
+   * `record(key, ...)` calls inherit the prior entry's fields, so `extra`
+   * may be omitted or partial. Forgetting required fields on the first
+   * record produces an entry whose typed-required fields are `undefined`
+   * at runtime — TS won't catch it. Strategy callers always pass
+   * `{ rootCause, intervention }`, so the StrategyEntry case is safe.
+   */
+  record(key, success, extra) {
+    const existing = this._map.get(key);
+    const attempts = (existing?.attempts ?? 0) + 1;
+    const successes = (existing?.successes ?? 0) + (success ? 1 : 0);
+    this._map.set(key, {
+      ...existing ?? {},
+      ...extra ?? {},
+      key,
+      attempts,
+      successes,
+      successRate: successes / attempts
+    });
+  }
+  /**
+   * Look up the entry for a key.
+   *
+   * Pure read: this tracker doesn't configure a TTL on the underlying
+   * `reactiveMap`, so `_map.get(key)` never triggers TTL-expiry pruning
+   * (which would otherwise be an observable side effect emitting a fresh
+   * `entries` snapshot). If `AuditedSuccessTrackerOptions` ever gains a
+   * `mapOptions` carve-out exposing TTL, revisit this contract.
+   */
+  lookup(key) {
+    return this._map.get(key);
+  }
+};
+function auditedSuccessTracker(opts) {
+  return new AuditedSuccessTrackerGraph(opts);
+}
+
+// src/utils/harness/types.ts
+var DEFAULT_PRESET_ID = "default";
+
+// src/utils/harness/strategy.ts
+function strategyModel() {
+  return auditedSuccessTracker({ name: "strategy" });
+}
+function priorityScore(item, strategy, lastInteractionNs, urgency, signals) {
+  const severityWeights = { ...DEFAULT_SEVERITY_WEIGHTS, ...signals?.severityWeights };
+  const decayRate = signals?.decayRate ?? DEFAULT_DECAY_RATE;
+  const effectivenessThreshold = signals?.effectivenessThreshold ?? 0.7;
+  const effectivenessBoost = signals?.effectivenessBoost ?? 15;
+  const deps = [item, strategy, lastInteractionNs];
+  if (urgency) deps.push(urgency);
+  return (0, import_core4.node)(
+    deps,
+    (batchData, actions, ctx) => {
+      const values = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      const itm = values[0];
+      const strat = values[1];
+      const lastNs = values[2];
+      const urg = urgency ? values[3] : 0;
+      const baseWeight = severityWeights[itm.severity ?? "medium"];
+      const ageSeconds = ((0, import_core4.monotonicNs)() - lastNs) / 1e9;
+      let score = decay(baseWeight, ageSeconds, decayRate, 0);
+      const key = strategyKey(DEFAULT_PRESET_ID, itm.rootCause, itm.intervention);
+      const entry = strat.get(key);
+      if (entry && entry.successRate >= effectivenessThreshold) {
+        score += effectivenessBoost;
+      }
+      score += urg * 20;
+      actions.emit(score);
+    },
+    { name: "priority-score", describeKind: "derived" }
+  );
+}
+//# sourceMappingURL=index.cjs.map