@energy8platform/golem 0.6.0 → 0.7.0

package/dist/lib/e8-client.js

@@ -0,0 +1,116 @@
+/**
+ * e8/client — the IDE half of golem's e8 row, a plain ES module the e8 IDE loads as is (no JSX, no bare imports;
+ * React comes from the IDE). A rig.json opens the rig editor (the host half serves it under /golem/) in its tab,
+ * painted with the IDE's theme tokens; an agent's rig write becomes one undo step that golem's own history takes back.
+ */
+const { React } = globalThis.__E8_IDE__;
+
+export const name = 'golem';
+export const inject = ['viewers', 'history', 'connection'];
+
+export const isRig = (path) => path === 'rig.json' || path.endsWith('/rig.json');
+
+/** golem editor token, the IDE token it takes its value from */
+export const THEME = [
+  ['--bg', '--e8-editor-bg'], ['--panel', '--e8-surface'], ['--chrome', '--e8-shell-bg'], ['--line', '--e8-border'],
+  ['--accent', '--e8-accent'], ['--accent-hover', '--e8-accent'], ['--fg', '--e8-fg'], ['--fg2', '--e8-fg-muted'],
+  ['--ctl', '--e8-hover'], ['--ctl-hover', '--e8-selected'], ['--ctl-line', '--e8-border'],
+  ['--err', '--e8-error'], ['--warn', '--e8-warning'], ['--font', '--e8-font'], ['--size', '--e8-size'],
+];
+
+/** The golem tokens from the IDE's computed style; a token the IDE does not define is left out. */
+export function themeVars(style) {
+  const vars = {};
+  for (const [golem, e8] of THEME) {
+    const value = style.getPropertyValue(e8).trim();
+    if (value) vars[golem] = value;
+  }
+  return vars;
+}
+
+export const editorUrl = (path) => `/golem/editor.html?rig=${encodeURIComponent(path)}&embed=1`;
+
+function RigEditor({ path }) {
+  const ref = React.useRef(null);
+  React.useEffect(() => {
+    const frame = ref.current;
+    if (!frame) return undefined;
+    // on every load (the editor reloads itself on reconnects) and on every theme switch
+    const post = () =>
+      frame.contentWindow?.postMessage(
+        { type: 'golem:theme', vars: themeVars(getComputedStyle(document.documentElement)) },
+        location.origin,
+      );
+    frame.addEventListener('load', post);
+    const observer = new MutationObserver(post);
+    observer.observe(document.documentElement, { attributes: true, attributeFilter: ['data-theme'] });
+    return () => {
+      frame.removeEventListener('load', post);
+      observer.disconnect();
+    };
+  }, []);
+  return React.createElement('iframe', {
+    ref,
+    src: editorUrl(path),
+    title: path,
+    'data-testid': 'golem-editor',
+    style: { border: 0, width: '100%', height: '100%', display: 'block' },
+  });
+}
+
+/**
+ * Per rig, a version an agent write saw (its before or after) → the version that same content has now. Versions are
+ * `mtimeMs:size`, so a move gives the content back under a new version; the steps around it find it here.
+ */
+const moved = new Map();
+function now(rig, version) {
+  const seen = new Set();
+  while (moved.has(`${rig}\n${version}`) && !seen.has(version)) {
+    seen.add(version);
+    version = moved.get(`${rig}\n${version}`);
+  }
+  return version;
+}
+
+/**
+ * One undo step for an agent's write to `rig` (`before` → `after`): golem's rig_undo / rig_redo, each refused (409)
+ * when the rig is no longer at the version that content has now — someone edited it since. Answers are the IDE's
+ * StepAnswer.
+ */
+export function rigStep(rig, label, before, after, post = fetch) {
+  const move = async (tool, verb, from, to) => {
+    let res;
+    try {
+      res = await post(`/golem/api/tool/${tool}`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ rig, baseVersion: now(rig, from) }),
+      });
+    } catch {
+      return { reason: 'golem editor unreachable — try again', keep: true }; // the IDE keeps the step for a later Mod+Z
+    }
+    if (res.status === 409) return `changed elsewhere since — can't ${verb}`;
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok || body.isError) return String(body.text ?? `${res.status} ${res.statusText}`).replace(/^ERROR: /, '');
+    if (typeof body.version !== 'string') return `golem answered with no version — can't ${verb}`;
+    moved.set(`${rig}\n${to}`, body.version);
+    return null;
+  };
+  return { label, undo: () => move('rig_undo', 'undo', after, before), redo: () => move('rig_redo', 'redo', before, after) };
+}
+
+export function apply(ctx) {
+  ctx.effect(() => ctx.viewers.register({ id: 'golem', match: isRig, component: RigEditor }), 'golem:viewer');
+  ctx.effect(
+    () => ctx.history.scope((key) => (key.startsWith('f:') && isRig(key.slice(2)) ? [`rig:${key.slice(2)}`] : undefined)),
+    'golem:history-scope',
+  );
+  ctx.effect(
+    () =>
+      ctx.connection.onFrame((frame) => {
+        if (frame.type !== 'agent-write' || !frame.key.startsWith('rig:')) return;
+        ctx.history.record(frame.key, rigStep(frame.key.slice(4), frame.label, frame.before, frame.after));
+      }),
+    'golem:agent-writes',
+  );
+}