AI search engine and MCP server for bots and agents. One Rust binary indexes code, docs, logs, JSONL/CSV and PDFs for BM25 full-text, vector and hybrid search, code search without grep, agent memory and RAG. Elasticsearch-compatible API; Corpus Hub serves hundreds of reference memory corpora.
Rust agent-memoryai-agentsbm25claude-codeclicode-searchcursordatabaseelasticsearchfull-text-searchhybrid-searchjsonllocal-firstmcpmcp-servermodel-context-protocolragrustsearch-enginevector-search
/* charts.js — interactive upgrade for the two XERJ hero charts.
*
* Progressive enhancement: each <svg class="chart" data-chart="..."> ships a
* hand-authored STATIC render in index.html (the no-JS fallback). This script,
* when it runs, replaces that svg's contents with an interactive, data-faithful
* render and adds an HTML legend + stat card around it. If anything required is
* missing it bails and the static fallback stays on screen.
*
* Vanilla, no deps, no external requests, CSP-safe. Idempotent.
*/
(function () {
'use strict';
var SVG_NS = 'http://www.w3.org/2000/svg';
var TOTAL_EMBEDDINGS = 830;
var ZOOM_MS = 450;
var PAD_FRAC = 0.12; // ~12% padding around a cluster bbox
var MAX_ZOOM = 2.4; // cap magnification so dots/labels don't balloon
var FULL_VB_SCATTER = [0, 0, 1200, 380];
/* Faithful per-cluster hull outlines from the original static SVG (index.html
* line 131), keyed by cluster so each hull dims/highlights with its cluster. */
var HULLS = {
rag: { op: '0.55', pts: '93.8,252.0 103.0,263.6 118.2,268.2 167.5,273.3 241.5,265.6 258.3,262.1 263.7,260.2 277.4,250.9 275.7,245.6 250.3,230.8 233.9,225.9 199.6,222.3 110.3,229.6 99.0,233.5 94.4,241.1 93.8,252.0' },
code: { op: '0.48', pts: '809.5,290.8 838.4,302.7 901.5,309.2 955.2,308.0 971.3,305.2 1014.9,288.1 1018.5,285.6 1011.6,268.2 997.2,261.8 950.3,250.7 886.5,249.2 846.6,255.9 822.7,263.0 810.4,281.6 809.5,290.8' },
docqa: { op: '0.41', pts: '396.6,119.7 409.2,141.2 456.1,151.6 524.3,156.5 564.0,154.8 609.1,146.1 634.0,135.6 640.7,124.8 626.6,106.1 613.8,101.3 576.9,95.6 528.3,90.1 459.2,96.7 410.2,106.3 396.6,119.7' },
extract: { op: '0.34', pts: '1002.2,68.6 1026.9,77.8 1045.9,78.0 1106.9,77.9 1160.0,69.6 1141.6,47.7 1105.1,40.0 1045.9,42.1 1017.2,48.5 1002.2,68.6' },
classify: { op: '0.27', pts: '40.0,54.0 57.7,76.1 93.6,77.6 124.7,76.9 144.7,74.3 160.4,63.0 157.1,52.2 147.6,48.8 114.1,46.0 89.1,44.0 52.2,50.2 40.0,54.0' },
agent: { op: '0.20', pts: '618.7,316.0 623.4,325.0 635.8,331.5 667.0,338.7 672.7,339.9 728.6,340.0 781.7,323.6 777.2,312.6 773.0,309.6 756.1,300.9 729.3,299.2 710.8,298.1 667.7,299.9 633.1,308.1 618.7,316.0' }
};
/* Hide the redundant hand-authored static caption legend once the interactive
* chip legend is in place (progressive enhancement — it reappears with JS off). */
function hideStaticLegend(wrap) {
var sibs = wrap.parentNode ? wrap.parentNode.children : [];
for (var i = 0; i < sibs.length; i++) {
if (sibs[i] !== wrap && sibs[i].classList &&
sibs[i].classList.contains('series-legend')) {
sibs[i].style.display = 'none';
}
}
}
var reduceMotion = false;
try {
reduceMotion = window.matchMedia &&
window.matchMedia('(prefers-reduced-motion: reduce)').matches;
} catch (e) { /* no matchMedia — treat as motion-ok */ }
/* ---------- tiny helpers ---------------------------------------------- */
function svgEl(tag, attrs) {
var n = document.createElementNS(SVG_NS, tag);
if (attrs) { for (var k in attrs) { n.setAttribute(k, attrs[k]); } }
return n;
}
function htmlEl(tag, cls) {
var n = document.createElement(tag);
if (cls) { n.className = cls; }
return n;
}
function clamp(v, lo, hi) { return v < lo ? lo : (v > hi ? hi : v); }
function slug(s) {
return String(s).toLowerCase().replace(/[^a-z0-9]+/g, '-')
.replace(/^-+|-+$/g, '');
}
/* Wrap the svg in a positioned container so the stat card / reset button can
* be absolutely placed within the chart's own bounds (never the page). */
function wrapChart(svg) {
var wrap = htmlEl('div', 'chart-wrap');
var parent = svg.parentNode;
parent.insertBefore(wrap, svg);
wrap.appendChild(svg); // moves svg into wrap
hideStaticLegend(wrap); // drop the redundant static caption legend
return wrap;
}
/* easeInOutCubic */
function ease(t) {
return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
}
/* Animate an svg's viewBox from `from` -> `to` (arrays of 4). Cancels any
* in-flight animation on the same svg. Reduced-motion => jump instantly. */
function animateViewBox(svg, to, done) {
if (svg._vbRaf) { cancelAnimationFrame(svg._vbRaf); svg._vbRaf = 0; }
var from = (svg.getAttribute('viewBox') || '0 0 1200 380')
.trim().split(/[\s,]+/).map(Number);
if (reduceMotion) {
svg.setAttribute('viewBox', to.join(' '));
if (done) { done(); }
return;
}
var start = 0;
function step(ts) {
if (!start) { start = ts; }
var t = clamp((ts - start) / ZOOM_MS, 0, 1);
var e = ease(t);
var vb = [
from[0] + (to[0] - from[0]) * e,
from[1] + (to[1] - from[1]) * e,
from[2] + (to[2] - from[2]) * e,
from[3] + (to[3] - from[3]) * e
];
svg.setAttribute('viewBox', vb.join(' '));
if (t < 1) { svg._vbRaf = requestAnimationFrame(step); }
else { svg._vbRaf = 0; if (done) { done(); } }
}
svg._vbRaf = requestAnimationFrame(step);
}
/* Bounding box of a cluster's points -> a padded viewBox that preserves the
* full chart's aspect ratio (so preserveAspectRatio="none" doesn't distort
* the zoom relative to the un-zoomed view), clamped inside the full canvas. */
function zoomBoxFor(pts, full) {
var minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
for (var i = 0; i < pts.length; i++) {
var x = pts[i][0], y = pts[i][1];
if (x < minX) { minX = x; } if (x > maxX) { maxX = x; }
if (y < minY) { minY = y; } if (y > maxY) { maxY = y; }
}
var w = Math.max(maxX - minX, 1);
var h = Math.max(maxY - minY, 1);
// pad each side
var px = w * PAD_FRAC, py = h * PAD_FRAC;
minX -= px; maxX += px; minY -= py; maxY += py;
w = maxX - minX; h = maxY - minY;
var cx = (minX + maxX) / 2, cy = (minY + maxY) / 2;
// expand to the full canvas aspect ratio around the centre
var aspect = full[2] / full[3];
if (w / h < aspect) { w = h * aspect; } else { h = w / aspect; }
// cap magnification: don't zoom tighter than MAX_ZOOM (small clusters would
// otherwise blow the "·" dots + label up several ×)
var minW = full[2] / MAX_ZOOM;
if (w < minW) { w = minW; h = w / aspect; }
// never larger than the whole canvas
w = Math.min(w, full[2]); h = Math.min(h, full[3]);
var x0 = clamp(cx - w / 2, full[0], full[0] + full[2] - w);
var y0 = clamp(cy - h / 2, full[1], full[1] + full[3] - h);
return [x0, y0, w, h];
}
/* ---------- shared state application ---------------------------------- */
/* Recompute .is-active / .is-dim across groups + chips, update the stat card
* and the reset button, from `hoverKey` (transient) and `pinnedKey`. */
function apply(chart) {
var activeKey = chart.hoverKey || chart.pinnedKey || null;
chart.items.forEach(function (it) {
var on = activeKey != null && it.key === activeKey;
var dim = activeKey != null && it.key !== activeKey;
it.group.classList.toggle('is-active', on);
it.group.classList.toggle('is-dim', dim);
if (it.chip) {
it.chip.classList.toggle('is-active', on);
it.chip.classList.toggle('is-dim', dim);
it.chip.setAttribute('aria-pressed', chart.pinnedKey === it.key ? 'true' : 'false');
}
});
// stat card
if (activeKey != null) {
var it2 = chart.byKey[activeKey];
chart.card.innerHTML = '';
var t = htmlEl('span', 'cc-title'); t.textContent = it2.title;
var m = htmlEl('span', 'cc-meta'); m.textContent = it2.meta;
chart.card.appendChild(t);
chart.card.appendChild(m);
chart.card.classList.add('is-shown');
} else {
chart.card.classList.remove('is-shown');
}
// reset button (scatter zoom only)
if (chart.reset) {
chart.reset.classList.toggle('is-shown', chart.pinnedKey != null);
}
}
/* ---------- renderer: intent-cluster scatter -------------------------- */
function enhanceClusters(svg) {
var data = window.XERJ_CLUSTERS;
if (!data || !data.clusters || !data.clusters.length) { return; } // keep fallback
var full = (data.viewBox && data.viewBox.length === 4)
? data.viewBox.slice() : FULL_VB_SCATTER.slice();
var wrap = wrapChart(svg);
var chart = {
kind: 'clusters', svg: svg, wrap: wrap, full: full,
items: [], byKey: {}, hoverKey: null, pinnedKey: null
};
// Build the interactive render into a fragment FIRST, so a failure mid-build
// can't blank the static fallback (we only clear once the frag is ready).
var frag = document.createDocumentFragment();
data.clusters.forEach(function (cl) {
var g = svgEl('g', {
'class': 'cl',
'data-cluster': cl.key,
tabindex: '0',
role: 'button',
'aria-label': 'Zoom into ' + cl.label + ' cluster, ' + cl.pts.length + ' queries'
});
// faint hull outline (behind the dots), matching the static SVG
var hull = HULLS[cl.key];
if (hull) {
g.appendChild(svgEl('polyline', {
points: hull.pts, fill: 'none', stroke: 'currentColor',
'stroke-width': '1', 'stroke-opacity': hull.op,
'vector-effect': 'non-scaling-stroke', 'class': 'cl-hull'
}));
}
// dots
for (var i = 0; i < cl.pts.length; i++) {
var p = cl.pts[i];
// brand-book dot: the "·" glyph in the data font (identical to the
// original static SVG) — NOT a filled <circle> (reads too large/heavy)
var dot = svgEl('text', {
x: p[0], y: p[1], fill: 'currentColor', opacity: p[2],
'font-family': 'var(--font-data)', 'font-size': '14',
'text-anchor': 'middle', 'dominant-baseline': 'middle',
'class': 'cl-dot'
});
dot.textContent = '·';
g.appendChild(dot);
}
// cluster label (matches the static render)
var lbl = svgEl('text', {
x: cl.cx, y: cl.cy, fill: 'currentColor',
'font-family': 'var(--font-prose)', 'font-size': '11',
'font-weight': '700', 'letter-spacing': '1.5',
'text-anchor': 'middle', 'class': 'cl-label'
});
lbl.textContent = cl.label;
g.appendChild(lbl);
frag.appendChild(g);
var pct = (cl.pts.length / TOTAL_EMBEDDINGS * 100).toFixed(1);
var item = {
key: cl.key, label: cl.label, group: g, chip: null, pts: cl.pts,
title: cl.label,
meta: cl.pts.length + ' queries · ' + pct + '% of ' + TOTAL_EMBEDDINGS,
count: cl.pts.length, opacity: (cl.pts[0] ? cl.pts[0][2] : 1)
};
chart.items.push(item);
chart.byKey[cl.key] = item;
});
while (svg.firstChild) { svg.removeChild(svg.firstChild); } // drop fallback
svg.appendChild(frag);
// stat card + reset button (inside wrap => within chart bounds)
chart.card = htmlEl('div', 'chart-card cc-scatter');
chart.card.setAttribute('aria-hidden', 'true');
wrap.appendChild(chart.card);
chart.reset = htmlEl('button', 'chart-reset');
chart.reset.type = 'button';
chart.reset.setAttribute('aria-label', 'Reset zoom to all clusters');
chart.reset.textContent = '⤢ RESET';
wrap.appendChild(chart.reset);
// legend chips (under the chart, inside wrap for single delegation root)
var legend = htmlEl('div', 'chart-legend');
legend.setAttribute('role', 'group');
legend.setAttribute('aria-label', 'Cluster legend');
chart.items.forEach(function (it) {
var chip = htmlEl('button', 'chart-chip');
chip.type = 'button';
chip.setAttribute('data-chip', it.key);
chip.setAttribute('aria-pressed', 'false');
chip.setAttribute('aria-label', 'Zoom into ' + it.label + ', ' + it.count + ' queries');
var sw = htmlEl('span', 'chip-sw');
sw.style.opacity = String(it.opacity);
var tx = htmlEl('span', 'chip-tx');
tx.textContent = it.label;
var ct = htmlEl('span', 'chip-ct');
ct.textContent = it.count;
chip.appendChild(sw); chip.appendChild(tx); chip.appendChild(ct);
legend.appendChild(chip);
it.chip = chip;
});
wrap.appendChild(legend);
// interactions --------------------------------------------------------
function zoomTo(key) {
var it = chart.byKey[key];
if (!it) { return; }
chart.pinnedKey = key;
animateViewBox(svg, zoomBoxFor(it.pts, full));
apply(chart);
}
function resetZoom() {
if (chart.pinnedKey == null) { return; }
chart.pinnedKey = null;
chart.hoverKey = null;
animateViewBox(svg, full.slice());
apply(chart);
}
bindHover(chart);
wrap.addEventListener('click', function (ev) {
var chip = closestAttr(ev.target, 'data-chip', wrap);
var grp = closestAttr(ev.target, 'data-cluster', wrap);
if (ev.target === chart.reset || chart.reset.contains(ev.target)) {
resetZoom(); return;
}
var key = (chip && chip.getAttribute('data-chip')) ||
(grp && grp.getAttribute('data-cluster'));
if (key) { zoomTo(key); return; }
// empty background while zoomed => reset
if (chart.pinnedKey != null) { resetZoom(); }
});
wrap.addEventListener('keydown', function (ev) {
var grp = closestAttr(ev.target, 'data-cluster', wrap);
if ((ev.key === 'Enter' || ev.key === ' ' || ev.key === 'Spacebar') && grp) {
ev.preventDefault();
zoomTo(grp.getAttribute('data-cluster'));
} else if (ev.key === 'Escape') {
resetZoom();
}
});
// Esc works even when focus has left the chart
document.addEventListener('keydown', function (ev) {
if (ev.key === 'Escape' && chart.pinnedKey != null) { resetZoom(); }
});
svg.dataset.enhanced = '1';
svg.classList.add('is-interactive');
}
/* ---------- renderer: latency multi-series line ----------------------- */
function enhanceLatency(svg) {
// Reuse the exact static nodes (verbatim points/labels) — group them.
// Walk element children in order, grouping [polyline, ...text] runs.
var series = [];
var cur = null;
var kids = [];
for (var n = svg.firstElementChild; n; n = n.nextElementSibling) {
kids.push(n);
}
kids.forEach(function (node) {
var tag = node.tagName.toLowerCase();
if (tag === 'polyline') {
cur = { poly: node, texts: [] };
series.push(cur);
} else if (tag === 'text' && cur) {
cur.texts.push(node);
}
});
if (!series.length) { return; } // nothing to enhance — keep fallback
var wrap = wrapChart(svg);
var chart = {
kind: 'latency', svg: svg, wrap: wrap,
items: [], byKey: {}, hoverKey: null, pinnedKey: null
};
series.forEach(function (s) {
var nameNode = null, valueNode = null;
s.texts.forEach(function (t) {
if (t.getAttribute('text-anchor') === 'end') { nameNode = t; }
else { valueNode = t; }
});
if (!nameNode) { nameNode = s.texts[0] || null; }
if (!valueNode) { valueNode = s.texts[s.texts.length - 1] || null; }
var name = nameNode ? nameNode.textContent.trim() : 'series';
var value = valueNode ? valueNode.textContent.trim() : '';
var key = slug(name) || ('s' + chart.items.length);
var op = s.poly.getAttribute('stroke-opacity') || '1';
var samples = (s.poly.getAttribute('points') || '')
.trim().split(/\s+/).filter(Boolean).length;
var g = svgEl('g', {
'class': 'ser',
'data-series': key,
tabindex: '0',
role: 'button',
'aria-label': 'Highlight ' + name + ' latency line'
});
// move the real nodes into the group (verbatim reuse)
g.appendChild(s.poly);
s.texts.forEach(function (t) { g.appendChild(t); });
svg.appendChild(g);
var item = {
key: key, label: name, group: g, chip: null,
title: name,
meta: 'p95 end · ' + value + ' · ' + samples + ' samples',
opacity: parseFloat(op) || 1, value: value
};
chart.items.push(item);
chart.byKey[key] = item;
});
// stat card
chart.card = htmlEl('div', 'chart-card cc-latency');
chart.card.setAttribute('aria-hidden', 'true');
wrap.appendChild(chart.card);
chart.reset = null; // latency has no zoom/reset
// legend chips
var legend = htmlEl('div', 'chart-legend');
legend.setAttribute('role', 'group');
legend.setAttribute('aria-label', 'Model legend');
chart.items.forEach(function (it) {
var chip = htmlEl('button', 'chart-chip');
chip.type = 'button';
chip.setAttribute('data-chip', it.key);
chip.setAttribute('aria-pressed', 'false');
chip.setAttribute('aria-label', 'Highlight ' + it.label + ' latency line');
var sw = htmlEl('span', 'chip-sw chip-sw-line');
sw.style.opacity = String(it.opacity);
var tx = htmlEl('span', 'chip-tx');
tx.textContent = it.label;
chip.appendChild(sw); chip.appendChild(tx);
legend.appendChild(chip);
it.chip = chip;
});
wrap.appendChild(legend);
// interactions --------------------------------------------------------
function toggleLock(key) {
chart.pinnedKey = (chart.pinnedKey === key) ? null : key;
apply(chart);
}
function unlock() {
if (chart.pinnedKey == null) { return; }
chart.pinnedKey = null;
apply(chart);
}
bindHover(chart);
wrap.addEventListener('click', function (ev) {
var chip = closestAttr(ev.target, 'data-chip', wrap);
var grp = closestAttr(ev.target, 'data-series', wrap);
var key = (chip && chip.getAttribute('data-chip')) ||
(grp && grp.getAttribute('data-series'));
if (key) { toggleLock(key); return; }
if (chart.pinnedKey != null) { unlock(); }
});
wrap.addEventListener('keydown', function (ev) {
var grp = closestAttr(ev.target, 'data-series', wrap);
if ((ev.key === 'Enter' || ev.key === ' ' || ev.key === 'Spacebar') && grp) {
ev.preventDefault();
toggleLock(grp.getAttribute('data-series'));
} else if (ev.key === 'Escape') {
unlock();
}
});
document.addEventListener('keydown', function (ev) {
if (ev.key === 'Escape' && chart.pinnedKey != null) { unlock(); }
});
svg.dataset.enhanced = '1';
svg.classList.add('is-interactive');
}
/* ---------- shared hover/focus wiring (event delegation) -------------- */
function bindHover(chart) {
var wrap = chart.wrap;
var attr = chart.kind === 'clusters' ? 'data-cluster' : 'data-series';
function keyFrom(target) {
var chip = closestAttr(target, 'data-chip', wrap);
if (chip) { return chip.getAttribute('data-chip'); }
var grp = closestAttr(target, attr, wrap);
if (grp) { return grp.getAttribute(attr); }
return null;
}
wrap.addEventListener('pointerover', function (ev) {
var k = keyFrom(ev.target);
if (k && k !== chart.hoverKey) { chart.hoverKey = k; apply(chart); }
});
wrap.addEventListener('pointerout', function (ev) {
// leaving the whole wrap, or moving to a non-item area
var to = ev.relatedTarget;
if (to && wrap.contains(to) && keyFrom(to)) { return; }
if (chart.hoverKey != null) { chart.hoverKey = null; apply(chart); }
});
// keyboard focus mirrors hover
wrap.addEventListener('focusin', function (ev) {
var k = keyFrom(ev.target);
if (k) { chart.hoverKey = k; apply(chart); }
});
wrap.addEventListener('focusout', function (ev) {
var to = ev.relatedTarget;
if (to && wrap.contains(to) && keyFrom(to)) { return; }
if (chart.hoverKey != null) { chart.hoverKey = null; apply(chart); }
});
}
/* closest ancestor (inclusive) that has attribute `name`, bounded by `root` */
function closestAttr(node, name, root) {
while (node && node !== root && node.nodeType === 1) {
if (node.hasAttribute && node.hasAttribute(name)) { return node; }
node = node.parentNode;
}
return null;
}
/* ---------- boot ------------------------------------------------------ */
function boot() {
var charts = document.querySelectorAll('svg.chart[data-chart]');
for (var i = 0; i < charts.length; i++) {
var svg = charts[i];
if (svg.dataset.enhanced === '1') { continue; } // idempotent
var kind = svg.getAttribute('data-chart');
try {
if (kind === 'intent-clusters') { enhanceClusters(svg); }
else if (kind === 'latency-series') { enhanceLatency(svg); }
} catch (err) {
// leave the static fallback intact on any failure
if (window.console && console.warn) {
console.warn('[charts] enhance failed for', kind, err);
}
}
}
}
if (document.readyState === 'loading') {
document.addEventListener('DOMContentLoaded', boot);
} else {
boot();
}
})();