@abstractframework/monitor-active-memory 0.1.0

package/dist/graph.d.ts

@@ -0,0 +1,74 @@
+import type { Edge, Node } from 'reactflow';
+import type { KgAssertion } from './types';
+export type KgEntityKind = 'person' | 'org' | 'concept' | 'claim' | 'event' | 'doc' | 'thing' | 'vocab' | 'entity';
+export interface KgGraphNodeData {
+    label: string;
+    kind: KgEntityKind;
+}
+export interface KgGraphEdgeData {
+    assertions: KgAssertion[];
+    predicateSummary: string;
+}
+export interface BuildKgGraphOptions {
+    groupEdges?: boolean;
+    maxEdgeLabelPredicates?: number;
+}
+export interface BuiltKgGraph {
+    nodes: Node<KgGraphNodeData>[];
+    edges: Edge<KgGraphEdgeData>[];
+}
+export type KgLayoutKind = 'grid' | 'circle' | 'radial' | 'force';
+export interface XY {
+    x: number;
+    y: number;
+}
+export type ViewportTransform = {
+    x: number;
+    y: number;
+    zoom: number;
+};
+export declare function sanitizeViewport(viewport: unknown, opts?: {
+    minZoom?: number;
+    maxZoom?: number;
+    maxAbsTranslate?: number;
+}): ViewportTransform | null;
+export declare function hashStringToSeed(input: string): number;
+export declare function buildKgLayout(graph: BuiltKgGraph, opts?: {
+    kind?: KgLayoutKind;
+    seed?: number;
+}): Record<string, XY>;
+export declare function buildKgGraph(items: KgAssertion[], opts?: BuildKgGraphOptions): BuiltKgGraph;
+export interface ShortestPathResult {
+    nodeIds: string[];
+    edgeIds: string[];
+}
+export declare function shortestPath(graph: BuiltKgGraph, startId: string, endId: string, opts?: {
+    directed?: boolean;
+}): ShortestPathResult | null;
+export interface ForceSimulationOptions {
+    seed?: number;
+    dt?: number;
+    springLength?: number;
+    springStrength?: number;
+    repulsionStrength?: number;
+    centeringStrength?: number;
+    damping?: number;
+    maxSpeed?: number;
+    maxRepulsionNodes?: number;
+}
+export interface ForceSimulationState {
+    nodeIds: string[];
+    pos: Float64Array;
+    vel: Float64Array;
+    acc: Float64Array;
+    edges: Uint32Array;
+    options: Required<ForceSimulationOptions>;
+    tick: number;
+}
+export declare function initForceSimulation(graph: BuiltKgGraph, opts?: ForceSimulationOptions & {
+    positions?: Record<string, XY>;
+}): ForceSimulationState;
+export declare function stepForceSimulation(state: ForceSimulationState, steps?: number): void;
+export declare function forceSimulationEnergy(state: ForceSimulationState): number;
+export declare function forceSimulationPositions(state: ForceSimulationState): Record<string, XY>;
+//# sourceMappingURL=graph.d.ts.map

package/dist/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../src/graph.ts"],"names":[],"mappings":"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"}

package/dist/graph.js

@@ -0,0 +1,523 @@
+export function sanitizeViewport(viewport, opts = {}) {
+    const obj = viewport && typeof viewport === 'object' && !Array.isArray(viewport) ? viewport : null;
+    if (!obj)
+        return null;
+    const x = typeof obj.x === 'number' && Number.isFinite(obj.x) ? obj.x : null;
+    const y = typeof obj.y === 'number' && Number.isFinite(obj.y) ? obj.y : null;
+    const zoom = typeof obj.zoom === 'number' && Number.isFinite(obj.zoom) ? obj.zoom : null;
+    if (x === null || y === null || zoom === null)
+        return null;
+    const maxAbs = typeof opts.maxAbsTranslate === 'number' && Number.isFinite(opts.maxAbsTranslate) ? Math.abs(opts.maxAbsTranslate) : 1000000;
+    if (Math.abs(x) > maxAbs || Math.abs(y) > maxAbs)
+        return null;
+    const minZoomRaw = typeof opts.minZoom === 'number' && Number.isFinite(opts.minZoom) ? opts.minZoom : 0.025;
+    const maxZoomRaw = typeof opts.maxZoom === 'number' && Number.isFinite(opts.maxZoom) ? opts.maxZoom : 6;
+    const lo = Math.min(minZoomRaw, maxZoomRaw);
+    const hi = Math.max(minZoomRaw, maxZoomRaw);
+    return { x, y, zoom: Math.min(hi, Math.max(lo, zoom)) };
+}
+function shortLabel(term) {
+    const s = String(term || '').trim();
+    if (!s)
+        return '';
+    const idx = s.indexOf(':');
+    if (idx !== -1 && idx < s.length - 1)
+        return s.slice(idx + 1);
+    return s;
+}
+function classifyKind(term) {
+    const s = String(term || '').trim();
+    if (!s)
+        return 'entity';
+    const idx = s.indexOf(':');
+    if (idx <= 0 || idx >= s.length - 1)
+        return 'entity';
+    const ns = s.slice(0, idx).toLowerCase();
+    const local = s.slice(idx + 1).toLowerCase();
+    if (ns === 'ex') {
+        const dash = local.indexOf('-');
+        const prefix = dash > 0 ? local.slice(0, dash) : local;
+        if (prefix === 'person')
+            return 'person';
+        if (prefix === 'org')
+            return 'org';
+        if (prefix === 'concept')
+            return 'concept';
+        if (prefix === 'claim')
+            return 'claim';
+        if (prefix === 'event')
+            return 'event';
+        if (prefix === 'doc')
+            return 'doc';
+        if (prefix === 'thing')
+            return 'thing';
+        return 'entity';
+    }
+    if (ns === 'schema' || ns === 'skos' || ns === 'dcterms' || ns === 'rdf' || ns === 'cito')
+        return 'vocab';
+    return 'entity';
+}
+function displayLabel(term) {
+    const s = String(term || '').trim();
+    if (!s)
+        return '';
+    const idx = s.indexOf(':');
+    if (idx <= 0 || idx >= s.length - 1)
+        return shortLabel(s);
+    const ns = s.slice(0, idx).toLowerCase();
+    const local = s.slice(idx + 1);
+    if (ns === 'ex') {
+        const dash = local.indexOf('-');
+        if (dash > 0 && dash < local.length - 1)
+            return local.slice(dash + 1);
+    }
+    return shortLabel(s);
+}
+function stableGridLayout(ids) {
+    const spacingX = 240;
+    const spacingY = 120;
+    const cols = Math.max(1, Math.ceil(Math.sqrt(ids.length)));
+    const pos = {};
+    for (let i = 0; i < ids.length; i++) {
+        const row = Math.floor(i / cols);
+        const col = i % cols;
+        pos[ids[i]] = { x: col * spacingX, y: row * spacingY };
+    }
+    return pos;
+}
+export function hashStringToSeed(input) {
+    // FNV-1a (32-bit), returns an unsigned uint32.
+    const s = String(input ?? '');
+    let h = 2166136261;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+}
+function mulberry32(seed) {
+    let t = seed >>> 0;
+    return () => {
+        t += 0x6d2b79f5;
+        let r = Math.imul(t ^ (t >>> 15), 1 | t);
+        r ^= r + Math.imul(r ^ (r >>> 7), 61 | r);
+        return ((r ^ (r >>> 14)) >>> 0) / 4294967296;
+    };
+}
+function circleLayout(ids, seed) {
+    const out = {};
+    const n = ids.length;
+    if (!n)
+        return out;
+    const radius = Math.max(260, Math.sqrt(n) * 150);
+    const angle0 = ((seed % 360) * Math.PI) / 180;
+    for (let i = 0; i < n; i++) {
+        const a = angle0 + (2 * Math.PI * i) / n;
+        out[ids[i]] = { x: radius * Math.cos(a), y: radius * Math.sin(a) };
+    }
+    return out;
+}
+function radialLayout(ids, edges, seed) {
+    const out = {};
+    if (!ids.length)
+        return out;
+    const neighbors = new Map();
+    for (const id of ids)
+        neighbors.set(id, new Set());
+    for (const e of edges) {
+        const s = String(e?.source || '').trim();
+        const t = String(e?.target || '').trim();
+        if (!s || !t || s === t)
+            continue;
+        const ns = neighbors.get(s);
+        const nt = neighbors.get(t);
+        if (ns)
+            ns.add(t);
+        if (nt)
+            nt.add(s);
+    }
+    let root = ids[0];
+    let rootDeg = -1;
+    for (const id of ids) {
+        const deg = neighbors.get(id)?.size ?? 0;
+        if (deg > rootDeg || (deg === rootDeg && id.localeCompare(root) < 0)) {
+            root = id;
+            rootDeg = deg;
+        }
+    }
+    const level = new Map();
+    const q = [];
+    level.set(root, 0);
+    q.push(root);
+    while (q.length) {
+        const cur = q.shift();
+        const curLevel = level.get(cur) ?? 0;
+        const neigh = Array.from(neighbors.get(cur) ?? []);
+        neigh.sort((a, b) => a.localeCompare(b));
+        for (const n of neigh) {
+            if (level.has(n))
+                continue;
+            level.set(n, curLevel + 1);
+            q.push(n);
+        }
+    }
+    // Keep disconnected nodes in an outer ring (still deterministic).
+    let maxLevel = 0;
+    for (const v of level.values())
+        maxLevel = Math.max(maxLevel, v);
+    for (const id of ids) {
+        if (!level.has(id))
+            level.set(id, maxLevel + 1);
+    }
+    const groups = new Map();
+    for (const id of ids) {
+        const l = level.get(id) ?? 0;
+        const cur = groups.get(l);
+        if (cur)
+            cur.push(id);
+        else
+            groups.set(l, [id]);
+    }
+    const levels = Array.from(groups.keys()).sort((a, b) => a - b);
+    const ringSpacing = 260;
+    const baseAngle = ((seed % 360) * Math.PI) / 180;
+    for (const l of levels) {
+        const idsInRing = groups.get(l) || [];
+        idsInRing.sort((a, b) => a.localeCompare(b));
+        if (l === 0) {
+            // If the ring has multiple ids (rare; root tie), spread them slightly.
+            if (idsInRing.length === 1) {
+                out[idsInRing[0]] = { x: 0, y: 0 };
+            }
+            else {
+                const r0 = 80;
+                for (let i = 0; i < idsInRing.length; i++) {
+                    const a = baseAngle + (2 * Math.PI * i) / idsInRing.length;
+                    out[idsInRing[i]] = { x: r0 * Math.cos(a), y: r0 * Math.sin(a) };
+                }
+            }
+            continue;
+        }
+        const r = ringSpacing * l;
+        const count = idsInRing.length;
+        if (count === 1) {
+            out[idsInRing[0]] = { x: r, y: 0 };
+            continue;
+        }
+        const angleOffset = baseAngle + l * 0.35;
+        for (let i = 0; i < count; i++) {
+            const a = angleOffset + (2 * Math.PI * i) / count;
+            out[idsInRing[i]] = { x: r * Math.cos(a), y: r * Math.sin(a) };
+        }
+    }
+    return out;
+}
+export function buildKgLayout(graph, opts = {}) {
+    const kind = opts.kind ?? 'grid';
+    const seed = typeof opts.seed === 'number' && Number.isFinite(opts.seed) ? Math.trunc(opts.seed) : 0;
+    const ids = graph.nodes.map((n) => n.id);
+    if (kind === 'grid')
+        return stableGridLayout(ids);
+    if (kind === 'circle')
+        return circleLayout(ids, seed);
+    if (kind === 'radial')
+        return radialLayout(ids, graph.edges, seed);
+    if (kind === 'force') {
+        const base = radialLayout(ids, graph.edges, seed);
+        const rng = mulberry32(seed || 1);
+        const jitter = Math.max(10, Math.min(42, Math.sqrt(ids.length) * 2.75));
+        const out = {};
+        for (const id of ids) {
+            const p = base[id] || { x: 0, y: 0 };
+            out[id] = { x: p.x + (rng() - 0.5) * jitter, y: p.y + (rng() - 0.5) * jitter };
+        }
+        return out;
+    }
+    return stableGridLayout(ids);
+}
+function safeAssertions(items) {
+    return Array.isArray(items)
+        ? items.filter((a) => a && typeof a === 'object' && typeof a.subject === 'string' && typeof a.predicate === 'string' && typeof a.object === 'string')
+        : [];
+}
+export function buildKgGraph(items, opts = {}) {
+    const groupEdges = Boolean(opts.groupEdges ?? true);
+    const maxPreds = Math.max(1, opts.maxEdgeLabelPredicates ?? 3);
+    const assertions = safeAssertions(items);
+    const idsSet = new Set();
+    for (const a of assertions) {
+        const s = String(a.subject || '').trim();
+        const o = String(a.object || '').trim();
+        if (s)
+            idsSet.add(s);
+        if (o)
+            idsSet.add(o);
+    }
+    const ids = Array.from(idsSet);
+    ids.sort((a, b) => a.localeCompare(b));
+    const positions = stableGridLayout(ids);
+    const nodes = ids.map((id) => ({
+        id,
+        type: 'default',
+        data: { label: displayLabel(id), kind: classifyKind(id) },
+        position: positions[id] || { x: 0, y: 0 },
+    }));
+    const edgeGroups = new Map();
+    const edgeKey = (a, idx) => {
+        const s = String(a.subject || '').trim();
+        const o = String(a.object || '').trim();
+        const p = String(a.predicate || '').trim();
+        if (!groupEdges)
+            return `edge:${idx}:${s}:${p}:${o}`;
+        return `edge:${s}:${o}`;
+    };
+    for (let i = 0; i < assertions.length; i++) {
+        const a = assertions[i];
+        const key = edgeKey(a, i);
+        const cur = edgeGroups.get(key);
+        if (cur)
+            cur.push(a);
+        else
+            edgeGroups.set(key, [a]);
+    }
+    const edges = [];
+    for (const [key, group] of edgeGroups.entries()) {
+        const a0 = group[0];
+        const source = String(a0.subject || '').trim();
+        const target = String(a0.object || '').trim();
+        if (!source || !target)
+            continue;
+        const predCounts = new Map();
+        for (const a of group) {
+            const p = String(a.predicate || '').trim();
+            if (!p)
+                continue;
+            predCounts.set(p, (predCounts.get(p) || 0) + 1);
+        }
+        const preds = Array.from(predCounts.entries());
+        preds.sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+        const top = preds.slice(0, maxPreds);
+        const label = top
+            .map(([p, c]) => (c > 1 ? `${shortLabel(p)}×${c}` : shortLabel(p)))
+            .join(' | ');
+        const more = preds.length > maxPreds ? ` +${preds.length - maxPreds}` : '';
+        const predicateSummary = `${label}${more}`.trim();
+        edges.push({
+            id: key,
+            source,
+            target,
+            label: predicateSummary,
+            animated: false,
+            data: { assertions: group, predicateSummary },
+        });
+    }
+    return { nodes, edges };
+}
+export function shortestPath(graph, startId, endId, opts = {}) {
+    const directed = opts.directed !== false;
+    const start = String(startId || '').trim();
+    const end = String(endId || '').trim();
+    if (!start || !end)
+        return null;
+    if (start === end)
+        return { nodeIds: [start], edgeIds: [] };
+    const adj = new Map();
+    const add = (from, to, edgeId) => {
+        const cur = adj.get(from);
+        if (cur)
+            cur.push({ to, edgeId });
+        else
+            adj.set(from, [{ to, edgeId }]);
+    };
+    for (const e of graph.edges) {
+        add(e.source, e.target, e.id);
+        if (!directed)
+            add(e.target, e.source, e.id);
+    }
+    const q = [start];
+    const prevNode = new Map();
+    const prevEdge = new Map();
+    prevNode.set(start, null);
+    prevEdge.set(start, null);
+    while (q.length) {
+        const cur = q.shift();
+        const neighbors = adj.get(cur) || [];
+        for (const n of neighbors) {
+            if (prevNode.has(n.to))
+                continue;
+            prevNode.set(n.to, cur);
+            prevEdge.set(n.to, n.edgeId);
+            if (n.to === end) {
+                q.length = 0;
+                break;
+            }
+            q.push(n.to);
+        }
+    }
+    if (!prevNode.has(end))
+        return null;
+    const nodeIds = [];
+    const edgeIds = [];
+    let cur = end;
+    while (cur) {
+        nodeIds.push(cur);
+        const e = prevEdge.get(cur);
+        if (e)
+            edgeIds.push(e);
+        cur = prevNode.get(cur) || null;
+    }
+    nodeIds.reverse();
+    edgeIds.reverse();
+    return { nodeIds, edgeIds };
+}
+const DEFAULT_FORCE_OPTS = {
+    seed: 1,
+    dt: 1,
+    springLength: 240,
+    springStrength: 0.03,
+    repulsionStrength: 9000,
+    centeringStrength: 0.003,
+    damping: 0.85,
+    maxSpeed: 90,
+    maxRepulsionNodes: 320,
+};
+export function initForceSimulation(graph, opts = {}) {
+    const merged = {
+        ...DEFAULT_FORCE_OPTS,
+        ...opts,
+        seed: typeof opts.seed === 'number' && Number.isFinite(opts.seed) ? Math.trunc(opts.seed) : DEFAULT_FORCE_OPTS.seed,
+    };
+    const nodeIds = graph.nodes.map((n) => n.id);
+    const n = nodeIds.length;
+    const pos = new Float64Array(2 * n);
+    const vel = new Float64Array(2 * n);
+    const acc = new Float64Array(2 * n);
+    const idxById = new Map();
+    for (let i = 0; i < n; i++)
+        idxById.set(nodeIds[i], i);
+    const basePos = opts.positions ?? buildKgLayout(graph, { kind: 'force', seed: merged.seed });
+    const rng = mulberry32(merged.seed || 1);
+    const jitter = Math.max(8, Math.min(38, Math.sqrt(n) * 2.25));
+    for (let i = 0; i < n; i++) {
+        const id = nodeIds[i];
+        const p = basePos[id];
+        const x = typeof p?.x === 'number' && Number.isFinite(p.x) ? p.x : (rng() - 0.5) * 500;
+        const y = typeof p?.y === 'number' && Number.isFinite(p.y) ? p.y : (rng() - 0.5) * 500;
+        pos[2 * i] = x + (rng() - 0.5) * jitter;
+        pos[2 * i + 1] = y + (rng() - 0.5) * jitter;
+        vel[2 * i] = 0;
+        vel[2 * i + 1] = 0;
+    }
+    const pairs = [];
+    for (const e of graph.edges) {
+        const s = idxById.get(String(e?.source || '').trim());
+        const t = idxById.get(String(e?.target || '').trim());
+        if (typeof s !== 'number' || typeof t !== 'number' || s === t)
+            continue;
+        pairs.push(s, t);
+    }
+    return {
+        nodeIds,
+        pos,
+        vel,
+        acc,
+        edges: new Uint32Array(pairs),
+        options: merged,
+        tick: 0,
+    };
+}
+export function stepForceSimulation(state, steps = 1) {
+    const n = state.nodeIds.length;
+    if (!n)
+        return;
+    const opts = state.options;
+    const dt = opts.dt;
+    for (let step = 0; step < Math.max(1, Math.trunc(steps)); step++) {
+        state.acc.fill(0);
+        const doRepulse = n <= opts.maxRepulsionNodes;
+        if (doRepulse) {
+            const repulse = opts.repulsionStrength;
+            for (let i = 0; i < n; i++) {
+                const xi = state.pos[2 * i];
+                const yi = state.pos[2 * i + 1];
+                for (let j = i + 1; j < n; j++) {
+                    const dx = state.pos[2 * j] - xi;
+                    const dy = state.pos[2 * j + 1] - yi;
+                    const dist2 = dx * dx + dy * dy + 1e-6;
+                    const invDist = 1 / Math.sqrt(dist2);
+                    const f = repulse / dist2;
+                    const fx = f * dx * invDist;
+                    const fy = f * dy * invDist;
+                    state.acc[2 * i] -= fx;
+                    state.acc[2 * i + 1] -= fy;
+                    state.acc[2 * j] += fx;
+                    state.acc[2 * j + 1] += fy;
+                }
+            }
+        }
+        const springLen = opts.springLength;
+        const springK = opts.springStrength;
+        const edges = state.edges;
+        for (let k = 0; k < edges.length; k += 2) {
+            const a = edges[k];
+            const b = edges[k + 1];
+            const ax = state.pos[2 * a];
+            const ay = state.pos[2 * a + 1];
+            const bx = state.pos[2 * b];
+            const by = state.pos[2 * b + 1];
+            const dx = bx - ax;
+            const dy = by - ay;
+            const dist2 = dx * dx + dy * dy + 1e-6;
+            const dist = Math.sqrt(dist2);
+            const f = springK * (dist - springLen);
+            const fx = (f * dx) / dist;
+            const fy = (f * dy) / dist;
+            state.acc[2 * a] += fx;
+            state.acc[2 * a + 1] += fy;
+            state.acc[2 * b] -= fx;
+            state.acc[2 * b + 1] -= fy;
+        }
+        const centerK = opts.centeringStrength;
+        for (let i = 0; i < n; i++) {
+            state.acc[2 * i] += -centerK * state.pos[2 * i];
+            state.acc[2 * i + 1] += -centerK * state.pos[2 * i + 1];
+        }
+        const damp = opts.damping;
+        const maxSpeed = opts.maxSpeed;
+        for (let i = 0; i < n; i++) {
+            let vx = (state.vel[2 * i] + state.acc[2 * i] * dt) * damp;
+            let vy = (state.vel[2 * i + 1] + state.acc[2 * i + 1] * dt) * damp;
+            const speed = Math.sqrt(vx * vx + vy * vy);
+            if (speed > maxSpeed) {
+                const s = maxSpeed / speed;
+                vx *= s;
+                vy *= s;
+            }
+            state.vel[2 * i] = vx;
+            state.vel[2 * i + 1] = vy;
+            state.pos[2 * i] += vx * dt;
+            state.pos[2 * i + 1] += vy * dt;
+        }
+        state.tick += 1;
+    }
+}
+export function forceSimulationEnergy(state) {
+    const n = state.nodeIds.length;
+    if (!n)
+        return 0;
+    let sum = 0;
+    for (let i = 0; i < n; i++) {
+        const vx = state.vel[2 * i];
+        const vy = state.vel[2 * i + 1];
+        sum += Math.sqrt(vx * vx + vy * vy);
+    }
+    return sum / n;
+}
+export function forceSimulationPositions(state) {
+    const out = {};
+    const n = state.nodeIds.length;
+    for (let i = 0; i < n; i++) {
+        out[state.nodeIds[i]] = { x: state.pos[2 * i], y: state.pos[2 * i + 1] };
+    }
+    return out;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { KgActiveMemoryExplorer, type KgActiveMemoryExplorerProps } from './KgActiveMemoryExplorer';
+export { buildKgGraph, shortestPath, buildKgLayout, hashStringToSeed, sanitizeViewport, initForceSimulation, stepForceSimulation, forceSimulationEnergy, forceSimulationPositions, } from './graph';
+export type { ForceSimulationOptions, ForceSimulationState, KgLayoutKind, ViewportTransform, XY } from './graph';
+export type { JsonValue, KgAssertion, KgQueryParams, KgQueryResult, MemoryScope, RecallLevel } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,KAAK,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AACpG,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,YAAY,EAAE,iBAAiB,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AACjH,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { KgActiveMemoryExplorer } from './KgActiveMemoryExplorer';
+export { buildKgGraph, shortestPath, buildKgLayout, hashStringToSeed, sanitizeViewport, initForceSimulation, stepForceSimulation, forceSimulationEnergy, forceSimulationPositions, } from './graph';

package/dist/types.d.ts

@@ -0,0 +1,50 @@
+export type JsonValue = null | string | number | boolean | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type MemoryScope = 'run' | 'session' | 'global' | 'all';
+export type RecallLevel = 'urgent' | 'standard' | 'deep';
+export interface KgAssertion {
+    subject: string;
+    predicate: string;
+    object: string;
+    scope?: string;
+    owner_id?: string;
+    observed_at?: string;
+    valid_from?: string | null;
+    valid_until?: string | null;
+    confidence?: number | null;
+    provenance?: Record<string, JsonValue> | null;
+    attributes?: Record<string, JsonValue> | null;
+}
+export interface KgQueryParams {
+    run_id?: string;
+    scope: MemoryScope;
+    owner_id?: string;
+    recall_level?: RecallLevel;
+    query_text?: string;
+    subject?: string;
+    predicate?: string;
+    object?: string;
+    since?: string;
+    until?: string;
+    active_at?: string;
+    min_score?: number;
+    limit?: number;
+    max_input_tokens?: number;
+    model?: string;
+}
+export interface KgQueryResult {
+    ok: boolean;
+    count?: number;
+    items?: KgAssertion[];
+    effort?: JsonValue;
+    warnings?: JsonValue;
+    packets?: JsonValue[];
+    packets_version?: number;
+    packed_count?: number;
+    active_memory_text?: string;
+    dropped?: number;
+    estimated_tokens?: number;
+    raw?: JsonValue;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GACjB,IAAI,GACJ,MAAM,GACN,MAAM,GACN,OAAO,GACP,SAAS,EAAE,GACX;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAEjC,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,SAAS,GAAG,QAAQ,GAAG,KAAK,CAAC;AAC/D,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,UAAU,GAAG,MAAM,CAAC;AAEzD,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,IAAI,CAAC;IAC9C,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,IAAI,CAAC;CAC/C;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,WAAW,EAAE,CAAC;IACtB,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,OAAO,CAAC,EAAE,SAAS,EAAE,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,GAAG,CAAC,EAAE,SAAS,CAAC;CACjB"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};